feat(go): Add support for genkit resources

go/ai/document.go

@@ -38,6 +38,7 @@ type Part struct {
 	Text         string         `json:"text,omitempty"`         // valid for kind∈{text,blob}
 	ToolRequest  *ToolRequest   `json:"toolRequest,omitempty"`  // valid for kind==partToolRequest
 	ToolResponse *ToolResponse  `json:"toolResponse,omitempty"` // valid for kind==partToolResponse
+	Resource     *ResourcePart  `json:"resource,omitempty"`     // valid for kind==partResource
 	Custom       map[string]any `json:"custom,omitempty"`       // valid for plugin-specific custom parts
 	Metadata     map[string]any `json:"metadata,omitempty"`     // valid for all kinds
 }
@@ -52,6 +53,7 @@ const (
 	PartToolResponse
 	PartCustom
 	PartReasoning
+	PartResource
 )
 
 // NewTextPart returns a Part containing text.
@@ -118,6 +120,11 @@ func NewReasoningPart(text string, signature []byte) *Part {
 	}
 }
 
+// NewResourcePart returns a Part containing a resource reference.
+func NewResourcePart(uri string) *Part {
+	return &Part{Kind: PartResource, Resource: &ResourcePart{Uri: uri}}
+}
+
 // IsText reports whether the [Part] contains plain text.
 func (p *Part) IsText() bool {
 	return p.Kind == PartText
@@ -153,6 +160,11 @@ func (p *Part) IsReasoning() bool {
 	return p.Kind == PartReasoning
 }
 
+// IsResource reports whether the [Part] contains a resource reference.
+func (p *Part) IsResource() bool {
+	return p.Kind == PartResource
+}
+
 // MarshalJSON is called by the JSON marshaler to write out a Part.
 func (p *Part) MarshalJSON() ([]byte, error) {
 	// This is not handled by the schema generator because
@@ -192,6 +204,12 @@ func (p *Part) MarshalJSON() ([]byte, error) {
 			Metadata:     p.Metadata,
 		}
 		return json.Marshal(v)
+	case PartResource:
+		v := resourcePart{
+			Resource: p.Resource,
+			Metadata: p.Metadata,
+		}
+		return json.Marshal(v)
 	case PartCustom:
 		v := customPart{
 			Custom:   p.Custom,
@@ -215,6 +233,7 @@ type partSchema struct {
 	Data         string         `json:"data,omitempty" yaml:"data,omitempty"`
 	ToolRequest  *ToolRequest   `json:"toolRequest,omitempty" yaml:"toolRequest,omitempty"`
 	ToolResponse *ToolResponse  `json:"toolResponse,omitempty" yaml:"toolResponse,omitempty"`
+	Resource     *ResourcePart  `json:"resource,omitempty" yaml:"resource,omitempty"`
 	Custom       map[string]any `json:"custom,omitempty" yaml:"custom,omitempty"`
 	Metadata     map[string]any `json:"metadata,omitempty" yaml:"metadata,omitempty"`
 	Reasoning    string         `json:"reasoning,omitempty" yaml:"reasoning,omitempty"`
@@ -233,6 +252,9 @@ func (p *Part) unmarshalPartFromSchema(s partSchema) {
 	case s.ToolResponse != nil:
 		p.Kind = PartToolResponse
 		p.ToolResponse = s.ToolResponse
+	case s.Resource != nil:
+		p.Kind = PartResource
+		p.Resource = s.Resource
 	case s.Custom != nil:
 		p.Kind = PartCustom
 		p.Custom = s.Custom

go/ai/gen.go

@@ -129,6 +129,7 @@ type GenerateActionOptions struct {
 	Output             *GenerateActionOutputConfig `json:"output,omitempty"`
 	Resume             *GenerateActionResume       `json:"resume,omitempty"`
 	ReturnToolRequests bool                        `json:"returnToolRequests,omitempty"`
+	StepName           string                      `json:"stepName,omitempty"`
 	ToolChoice         ToolChoice                  `json:"toolChoice,omitempty"`
 	Tools              []string                    `json:"tools,omitempty"`
 }
@@ -315,6 +316,15 @@ type RerankerResponse struct {
 	Documents []*RankedDocumentData `json:"documents,omitempty"`
 }
 
+type resourcePart struct {
+	Metadata map[string]any `json:"metadata,omitempty"`
+	Resource *ResourcePart  `json:"resource,omitempty"`
+}
+
+type ResourcePart struct {
+	Uri string `json:"uri,omitempty"`
+}
+
 type RetrieverRequest struct {
 	Options any       `json:"options,omitempty"`
 	Query   *Document `json:"query,omitempty"`

go/ai/generate.go

@@ -399,6 +399,15 @@ func Generate(ctx context.Context, r *registry.Registry, opts ...GenerateOption)
 		}
 	}
 
+	if len(genOpts.DynamicResources) > 0 {
+		r = r.NewChild()
+
+		// Attach dynamic resources
+		for _, res := range genOpts.DynamicResources {
+			res.Register(r)
+		}
+	}
+
 	messages := []*Message{}
 	if genOpts.SystemFn != nil {
 		system, err := genOpts.SystemFn(ctx, nil)
@@ -477,6 +486,13 @@ func Generate(ctx context.Context, r *registry.Registry, opts ...GenerateOption)
 		}
 	}
 
+	// Process resources in messages
+	processedMessages, err := processResources(ctx, r, messages)
+	if err != nil {
+		return nil, core.NewError(core.INTERNAL, "ai.Generate: error processing resources: %v", err)
+	}
+	actionOpts.Messages = processedMessages
+
 	return GenerateWithRequest(ctx, r, actionOpts, genOpts.Middleware, genOpts.Stream)
 }
 
@@ -1058,3 +1074,87 @@ func handleResumeOption(ctx context.Context, r *registry.Registry, genOpts *Gene
 		toolMessage: toolMessage,
 	}, nil
 }
+
+// processResources processes messages to replace resource parts with actual content.
+func processResources(ctx context.Context, r *registry.Registry, messages []*Message) ([]*Message, error) {
+	processedMessages := make([]*Message, len(messages))
+	for i, msg := range messages {
+		processedContent := []*Part{}
+
+		for _, part := range msg.Content {
+			if part.IsResource() {
+				// Find and execute the matching resource
+				resourceParts, err := executeResourcePart(ctx, r, part.Resource.Uri)
+				if err != nil {
+					return nil, fmt.Errorf("failed to process resource %q: %w", part.Resource, err)
+				}
+				// Replace resource part with content parts
+				processedContent = append(processedContent, resourceParts...)
+			} else {
+				// Keep non-resource parts as-is
+				processedContent = append(processedContent, part)
+			}
+		}
+
+		processedMessages[i] = &Message{
+			Role:     msg.Role,
+			Content:  processedContent,
+			Metadata: msg.Metadata,
+		}
+	}
+
+	return processedMessages, nil
+}
+
+// findMatchingResource finds a resource action in the registry that matches the given URI.
+func findMatchingResource(r *registry.Registry, uri string) (core.Action, map[string]string, error) {
+	// Use our updated FindMatchingResource function
+	resource, resourceInput, err := FindMatchingResource(r, uri)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	// Execute the resource to get the action - we need to access the underlying action
+	// Since the resource interface doesn't expose the action directly, we'll look it up
+	action := r.LookupAction(fmt.Sprintf("/resource/%s", resource.Name()))
+	if action == nil {
+		return nil, nil, core.NewError(core.INTERNAL, "failed to lookup resource action")
+	}
+
+	if coreAction, ok := action.(core.Action); ok {
+		return coreAction, resourceInput.Variables, nil
+	}
+
+	return nil, nil, core.NewError(core.INTERNAL, "action does not implement core.Action interface")
+}
+
+// executeResourcePart finds and executes a resource, returning the content parts.
+func executeResourcePart(ctx context.Context, r *registry.Registry, resourceURI string) ([]*Part, error) {
+	action, variables, err := findMatchingResource(r, resourceURI)
+	if err != nil {
+		return nil, err
+	}
+
+	// Create resource input with extracted variables
+	input := ResourceInput{
+		URI:       resourceURI,
+		Variables: variables,
+	}
+
+	// Execute the resource action directly
+	inputJSON, _ := json.Marshal(input)
+	outputJSON, err := action.RunJSON(ctx, inputJSON, nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to execute resource %q: %w", resourceURI, err)
+	}
+
+	// Parse resource output - use a compatible structure
+	var output struct {
+		Content []*Part `json:"content"`
+	}
+	if err := json.Unmarshal(outputJSON, &output); err != nil {
+		return nil, fmt.Errorf("failed to parse resource output: %w", err)
+	}
+
+	return output.Content, nil
+}

go/ai/generate_test.go

@@ -1096,3 +1096,71 @@ func TestToolInterruptsAndResume(t *testing.T) {
 		}
 	})
 }
+
+func TestResourceProcessing(t *testing.T) {
+	r, _ := registry.New()
+
+	// Create test resources using DefineResource
+	DefineResource(r, "test-file", ResourceOptions{
+		URI:         "file:///test.txt",
+		Description: "Test file resource",
+	}, func(ctx context.Context, input ResourceInput) (ResourceOutput, error) {
+		return ResourceOutput{Content: []*Part{NewTextPart("FILE CONTENT")}}, nil
+	})
+
+	DefineResource(r, "test-api", ResourceOptions{
+		URI:         "api://data/123",
+		Description: "Test API resource",
+	}, func(ctx context.Context, input ResourceInput) (ResourceOutput, error) {
+		return ResourceOutput{Content: []*Part{NewTextPart("API DATA")}}, nil
+	})
+
+	// Test message with resources
+	messages := []*Message{
+		NewUserMessage(
+			NewTextPart("Read this:"),
+			NewResourcePart("file:///test.txt"),
+			NewTextPart("And this:"),
+			NewResourcePart("api://data/123"),
+			NewTextPart("Done."),
+		),
+	}
+
+	// Process resources
+	processed, err := processResources(context.Background(), r, messages)
+	if err != nil {
+		t.Fatalf("resource processing failed: %v", err)
+	}
+
+	// Verify content
+	content := processed[0].Content
+	expected := []string{"Read this:", "FILE CONTENT", "And this:", "API DATA", "Done."}
+
+	if len(content) != len(expected) {
+		t.Fatalf("expected %d parts, got %d", len(expected), len(content))
+	}
+
+	for i, want := range expected {
+		if content[i].Text != want {
+			t.Fatalf("part %d: got %q, want %q", i, content[i].Text, want)
+		}
+	}
+}
+
+func TestResourceProcessingError(t *testing.T) {
+	r, _ := registry.New()
+
+	// No resources registered
+	messages := []*Message{
+		NewUserMessage(NewResourcePart("missing://resource")),
+	}
+
+	_, err := processResources(context.Background(), r, messages)
+	if err == nil {
+		t.Fatal("expected error when no resources available")
+	}
+
+	if !strings.Contains(err.Error(), "no resource found for URI") {
+		t.Fatalf("wrong error: %v", err)
+	}
+}

go/ai/option.go

@@ -725,8 +725,9 @@ type generateOptions struct {
 	outputOptions
 	executionOptions
 	documentOptions
-	RespondParts []*Part // Tool responses to return from interrupted tool calls.
-	RestartParts []*Part // Tool requests to restart interrupted tools with.
+	RespondParts     []*Part    // Tool responses to return from interrupted tool calls.
+	RestartParts     []*Part    // Tool requests to restart interrupted tools with.
+	DynamicResources []Resource // Dynamic resources to be temporarily available during generation.
 }
 
 // GenerateOption is an option for generating a model response. It applies only to Generate().
@@ -770,6 +771,13 @@ func (o *generateOptions) applyGenerate(genOpts *generateOptions) error {
 		genOpts.RestartParts = o.RestartParts
 	}
 
+	if o.DynamicResources != nil {
+		if genOpts.DynamicResources != nil {
+			return errors.New("cannot set dynamic resources more than once (WithResources)")
+		}
+		genOpts.DynamicResources = o.DynamicResources
+	}
+
 	return nil
 }
 
@@ -783,6 +791,22 @@ func WithToolRestarts(parts ...*Part) GenerateOption {
 	return &generateOptions{RestartParts: parts}
 }
 
+// WithResources specifies dynamic resources to be temporarily available during generation.
+// Dynamic resources are unregistered resources that get attached to a temporary registry
+// during the generation request and cleaned up afterward.
+func WithResources(resources []Resource) GenerateOption {
+	return &withResources{resources: resources}
+}
+
+type withResources struct {
+	resources []Resource
+}
+
+func (w *withResources) applyGenerate(o *generateOptions) error {
+	o.DynamicResources = w.resources
+	return nil
+}
+
 // promptExecutionOptions are options for generating a model response by executing a prompt.
 type promptExecutionOptions struct {
 	commonGenOptions