Make embedded resource content accessible from composite tool templates

ContentArrayToMap previously ignored EmbeddedResource content types,
making it impossible for composite tool workflows to chain on embedded
resource data (e.g., an SBOM returned by get_referrer_content).

Handle ContentTypeResource in ContentArrayToMap with "resource",
"resource_1", "resource_2" key pattern. When structuredContent is
present, merge content array keys into it without overwriting, so
both structured metadata and actual content are template-accessible.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: JAORMX

pkg/vmcp/client/client.go

@@ -657,10 +657,19 @@ func (h *httpBackendClient) CallTool(
 		}
 	}
 
-	// If no structured content, convert result contents to a map for backward compatibility.
-	// MCP tools return an array of Content interface (TextContent, ImageContent, etc.).
-	// Text content is stored under "text" key, accessible via {{.steps.stepID.output.text}}.
-	if structuredContent == nil {
+	if structuredContent != nil {
+		// Merge content array keys (text, resource, etc.) without overwriting structured keys.
+		// This makes both the tool's structured metadata and actual content accessible.
+		contentMap := conversion.ContentArrayToMap(contentArray)
+		for k, v := range contentMap {
+			if _, exists := structuredContent[k]; !exists {
+				structuredContent[k] = v
+			}
+		}
+	} else {
+		// No structured content: convert result contents to a map for backward compatibility.
+		// MCP tools return an array of Content interface (TextContent, ImageContent, etc.).
+		// Text content is stored under "text" key, accessible via {{.steps.stepID.output.text}}.
 		structuredContent = conversion.ContentArrayToMap(contentArray)
 	}
 

pkg/vmcp/composer/workflow_engine_test.go

@@ -846,3 +846,64 @@ func TestWorkflowEngine_SessionEngine_ToolNotInList_ReturnsNilSchema(t *testing.
 	require.NoError(t, err)
 	assert.Equal(t, WorkflowStatusCompleted, result.Status)
 }
+
+func TestWorkflowEngine_EmbeddedResourceAccessibleFromTemplate(t *testing.T) {
+	t.Parallel()
+	te := newTestEngine(t)
+
+	// Step 1: tool returns structuredContent + embedded resource in Content array.
+	// The client layer merges content array keys into structuredContent.
+	// Step 2: uses {{.steps.fetch.output.resource}} from the merged result.
+	def := simpleWorkflow("resource-chain",
+		toolStep("fetch", "registry.get_referrer_content", map[string]any{
+			"image": "ghcr.io/org/repo:latest",
+		}),
+		toolStepWithDeps("analyze", "sbom.analyze", map[string]any{
+			"sbom_data": "{{.steps.fetch.output.resource}}",
+			"format":    "{{.steps.fetch.output.format}}",
+		}, []string{"fetch"}),
+	)
+
+	// Step 1 returns merged structuredContent (as the real client would after the fix).
+	target := &vmcp.BackendTarget{
+		WorkloadID:   "test-backend",
+		WorkloadName: "test",
+		BaseURL:      "http://test:8080",
+	}
+	te.Router.EXPECT().RouteTool(gomock.Any(), "registry.get_referrer_content").Return(target, nil)
+	te.Backend.EXPECT().CallTool(gomock.Any(), target, "registry.get_referrer_content",
+		map[string]any{"image": "ghcr.io/org/repo:latest"}, gomock.Any()).
+		Return(&vmcp.ToolCallResult{
+			StructuredContent: map[string]any{
+				"contentType": "sbom",
+				"format":      "spdx",
+				"text":        "summary of SBOM",
+				"resource":    `{"spdxVersion":"SPDX-2.3","name":"mypackage"}`,
+			},
+			Content: []vmcp.Content{
+				{Type: vmcp.ContentTypeText, Text: "summary of SBOM"},
+				{Type: vmcp.ContentTypeResource, Text: `{"spdxVersion":"SPDX-2.3","name":"mypackage"}`, URI: "file://sbom.json"},
+			},
+		}, nil)
+
+	// Step 2: verify that the template-expanded args contain the resource data.
+	te.Router.EXPECT().RouteTool(gomock.Any(), "sbom.analyze").Return(target, nil)
+	te.Backend.EXPECT().CallTool(gomock.Any(), target, "sbom.analyze", gomock.Any(), gomock.Any()).
+		DoAndReturn(func(_ context.Context, _ *vmcp.BackendTarget, _ string, args map[string]any, _ map[string]any) (*vmcp.ToolCallResult, error) {
+			// Verify the template expanded the resource content correctly
+			assert.Equal(t, `{"spdxVersion":"SPDX-2.3","name":"mypackage"}`, args["sbom_data"])
+			assert.Equal(t, "spdx", args["format"])
+			return &vmcp.ToolCallResult{
+				StructuredContent: map[string]any{"result": "analyzed"},
+				Content:           []vmcp.Content{},
+			}, nil
+		})
+
+	result, err := execute(t, te.Engine, def, nil)
+
+	require.NoError(t, err)
+	assert.Equal(t, WorkflowStatusCompleted, result.Status)
+	assert.Len(t, result.Steps, 2)
+	assert.Equal(t, StepStatusCompleted, result.Steps["fetch"].Status)
+	assert.Equal(t, StepStatusCompleted, result.Steps["analyze"].Status)
+}

pkg/vmcp/conversion/content.go

@@ -376,8 +376,10 @@ func ToMCPToolAnnotations(annotations *vmcp.ToolAnnotations) mcp.ToolAnnotation
 //   - First text content: key="text"
 //   - Subsequent text content: key="text_1", "text_2", etc.
 //   - Image content: key="image_0", "image_1", etc.
+//   - First resource content: key="resource" (text resources use .Text, blob resources use .Data)
+//   - Subsequent resource content: key="resource_1", "resource_2", etc.
 //   - Audio content: ignored (not supported for template substitution)
-//   - Resource content: ignored (handled separately, not converted to map)
+//   - Resource links: ignored (not supported for template substitution)
 //   - Unknown content types: ignored (warnings logged at conversion boundaries)
 //
 // This ensures consistent behavior between client response handling and workflow step output processing.
@@ -389,6 +391,7 @@ func ContentArrayToMap(content []vmcp.Content) map[string]any {
 
 	textIndex := 0
 	imageIndex := 0
+	resourceIndex := 0
 
 	for _, item := range content {
 		switch item.Type {
@@ -405,10 +408,23 @@ func ContentArrayToMap(content []vmcp.Content) map[string]any {
 			result[key] = item.Data
 			imageIndex++
 
-		case vmcp.ContentTypeAudio, vmcp.ContentTypeResource, vmcp.ContentTypeLink:
+		case vmcp.ContentTypeResource:
+			key := "resource"
+			if resourceIndex > 0 {
+				key = fmt.Sprintf("resource_%d", resourceIndex)
+			}
+			// Text resources use .Text, blob resources use .Data
+			value := item.Text
+			if value == "" {
+				value = item.Data
+			}
+			result[key] = value
+			resourceIndex++
+
+		case vmcp.ContentTypeAudio, vmcp.ContentTypeLink:
 			// Purposely ignored for template substitution:
 			// - Audio content is ignored (not supported for template substitution)
-			// - Resource content/link is handled separately, not converted to map
+			// - Resource links are ignored (not supported for template substitution)
 		default:
 			// Unknown content types are ignored (warnings logged at conversion boundaries)
 		}

pkg/vmcp/conversion/conversion_test.go

@@ -686,7 +686,58 @@ func TestContentArrayToMap(t *testing.T) {
 			content: []vmcp.Content{
 				{Type: vmcp.ContentTypeText, Text: "Text"},
 				{Type: "unknown", Text: "Should be ignored"},
-				{Type: vmcp.ContentTypeResource, URI: "file://test"},
+			},
+			expected: map[string]any{
+				"text": "Text",
+			},
+		},
+		{
+			name: "single text resource content",
+			content: []vmcp.Content{
+				{Type: vmcp.ContentTypeResource, Text: "SBOM JSON data", URI: "file://sbom.json", MimeType: "application/json"},
+			},
+			expected: map[string]any{
+				"resource": "SBOM JSON data",
+			},
+		},
+		{
+			name: "single blob resource content uses Data field",
+			content: []vmcp.Content{
+				{Type: vmcp.ContentTypeResource, Data: "base64blobdata", URI: "file://binary", MimeType: "application/octet-stream"},
+			},
+			expected: map[string]any{
+				"resource": "base64blobdata",
+			},
+		},
+		{
+			name: "multiple resource contents",
+			content: []vmcp.Content{
+				{Type: vmcp.ContentTypeResource, Text: "First resource", URI: "file://a"},
+				{Type: vmcp.ContentTypeResource, Text: "Second resource", URI: "file://b"},
+				{Type: vmcp.ContentTypeResource, Data: "Third blob", URI: "file://c"},
+			},
+			expected: map[string]any{
+				"resource":   "First resource",
+				"resource_1": "Second resource",
+				"resource_2": "Third blob",
+			},
+		},
+		{
+			name: "mixed text and resource content",
+			content: []vmcp.Content{
+				{Type: vmcp.ContentTypeText, Text: "summary"},
+				{Type: vmcp.ContentTypeResource, Text: "SBOM JSON", URI: "file://sbom.json"},
+			},
+			expected: map[string]any{
+				"text":     "summary",
+				"resource": "SBOM JSON",
+			},
+		},
+		{
+			name: "resource link content is still ignored",
+			content: []vmcp.Content{
+				{Type: vmcp.ContentTypeText, Text: "Text"},
+				{Type: vmcp.ContentTypeLink, URI: "file://link", Name: "link"},
 			},
 			expected: map[string]any{
 				"text": "Text",
@@ -735,6 +786,76 @@ func TestContentArrayToMap(t *testing.T) {
 	}
 }
 
+func TestContentArrayToMap_MergeWithStructuredContent(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name              string
+		structuredContent map[string]any
+		content           []vmcp.Content
+		expected          map[string]any
+	}{
+		{
+			name: "content array keys merged into structuredContent without overwriting",
+			structuredContent: map[string]any{
+				"contentType": "sbom",
+				"format":      "spdx",
+				"size":        float64(5347),
+			},
+			content: []vmcp.Content{
+				{Type: vmcp.ContentTypeText, Text: "summary"},
+				{Type: vmcp.ContentTypeResource, Text: `{"spdxVersion":"SPDX-2.3"}`, URI: "file://sbom.json"},
+			},
+			expected: map[string]any{
+				"contentType": "sbom",
+				"format":      "spdx",
+				"size":        float64(5347),
+				"text":        "summary",
+				"resource":    `{"spdxVersion":"SPDX-2.3"}`,
+			},
+		},
+		{
+			name: "structuredContent keys are not overwritten by content array",
+			structuredContent: map[string]any{
+				"text": "structured text takes priority",
+			},
+			content: []vmcp.Content{
+				{Type: vmcp.ContentTypeText, Text: "content array text"},
+			},
+			expected: map[string]any{
+				"text": "structured text takes priority",
+			},
+		},
+		{
+			name: "empty content array leaves structuredContent unchanged",
+			structuredContent: map[string]any{
+				"key": "value",
+			},
+			content:  []vmcp.Content{},
+			expected: map[string]any{"key": "value"},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			// Simulate the merge logic from client.go / mcp_session.go
+			result := make(map[string]any, len(tt.structuredContent))
+			for k, v := range tt.structuredContent {
+				result[k] = v
+			}
+			contentMap := conversion.ContentArrayToMap(tt.content)
+			for k, v := range contentMap {
+				if _, exists := result[k]; !exists {
+					result[k] = v
+				}
+			}
+			assert.Equal(t, tt.expected, result)
+		})
+	}
+}
+
 func TestFromMCPMeta(t *testing.T) {
 	t.Parallel()
 

pkg/vmcp/session/internal/backend/mcp_session.go

@@ -125,7 +125,15 @@ func (c *mcpSession) CallTool(
 			structuredContent = m
 		}
 	}
-	if structuredContent == nil {
+	if structuredContent != nil {
+		// Merge content array keys (text, resource, etc.) without overwriting structured keys.
+		contentMap := conversion.ContentArrayToMap(contentArray)
+		for k, v := range contentMap {
+			if _, exists := structuredContent[k]; !exists {
+				structuredContent[k] = v
+			}
+		}
+	} else {
 		structuredContent = conversion.ContentArrayToMap(contentArray)
 	}