fix(mcp): check the holes of a sparse content block array

Array.prototype.map skips the holes of a sparse array, so a hole passed the DF0081 check and reached the MCP client as null. Array.from visits each hole as undefined, so it now fails the check.

Author: erkamyaman

packages/agentic/src/mcp/__tests__/mcp-server.test.ts

@@ -1,5 +1,5 @@
 import type { StandardSchemaV1 } from '@standard-schema/spec'
-import type { DevframeHost } from 'devframe/types'
+import type { DevframeHost, McpContentBlock } from 'devframe/types'
 import { Client, InMemoryTransport } from '@modelcontextprotocol/client'
 import { withMcpContent } from 'devframe'
 import { createHostContext } from 'devframe/node'
@@ -258,6 +258,28 @@ describe('mcp adapter (in-memory)', () => {
     }
   })
 
+  it('returns DF0081 when the attached content blocks have holes', async () => {
+    const { ctx, client, cleanup } = await bootPair()
+    try {
+      // eslint-disable-next-line unicorn/no-new-array
+      const sparse = new Array(2) as McpContentBlock[]
+      sparse[1] = { type: 'text', text: 'second' }
+      ctx.agent.registerTool({
+        id: 'sparse',
+        description: 'Returns a sparse block array.',
+        handler: () => withMcpContent({}, sparse),
+      })
+
+      const result = await client.callTool({ name: 'sparse', arguments: {} })
+      expect(result.isError).toBe(true)
+      const content = result.content as Array<{ type: string, text: string }>
+      expect(content[0]!.text).toContain('DF0081')
+    }
+    finally {
+      await cleanup()
+    }
+  })
+
   it('calls an rpc-backed tool whose return schema has no native converter', async () => {
     const { ctx, client, cleanup } = await bootPair()
     try {

packages/agentic/src/mcp/build-server.ts

@@ -379,7 +379,8 @@ function mcpContentOf(name: string, result: unknown): McpContentBlock[] | undefi
     return undefined
   if (!Array.isArray(blocks) || blocks.length === 0)
     throw diagnostics.DF0081({ name, reason: 'expected a non-empty array' })
-  return blocks.map((block: unknown, index): McpContentBlock => {
+  // `Array.from` visits the holes of a sparse array as `undefined`, so they fail the check below.
+  return Array.from(blocks, (block: unknown, index): McpContentBlock => {
     const b = (block ?? {}) as Record<string, unknown>
     if (b.type === 'text' && typeof b.text === 'string')
       return { type: 'text', text: b.text }