fix(agentic): do not advertise an output schema devframe cannot derive

An RPC function whose `returns` validator has no Standard JSON Schema
converter degraded to a permissive `{ type: 'object' }` schema. That is
fine as documentation, but it is advertised as the MCP `outputSchema`,
which obliges the tool to return a matching object on every call.

Any such function returning an array or a primitive therefore failed
`tools/call` with -32602, the SDK rejecting the server's own response:

  Invalid tools/call result: expected record, received array

Return no output schema instead when the converter is absent, so the
result travels as text content only. Validators with a native converter
(zod 4) are unaffected.

Author: erkamyaman

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

@@ -1,6 +1,7 @@
 import type { DevframeHost } from 'devframe/types'
 import { Client, InMemoryTransport } from '@modelcontextprotocol/client'
 import { createHostContext } from 'devframe/node'
+import * as v from 'valibot'
 import { describe, expect, it } from 'vitest'
 import { buildMcpServerFromContext } from '../build-server'
 
@@ -165,6 +166,35 @@ describe('mcp adapter (in-memory)', () => {
     }
   })
 
+  it('calls an rpc-backed tool whose return schema has no native converter', async () => {
+    const { ctx, client, cleanup } = await bootPair()
+    try {
+      ctx.rpc.register({
+        name: 'list-things',
+        type: 'query',
+        jsonSerializable: true,
+        args: [],
+        returns: v.array(v.object({ id: v.string() })),
+        agent: { description: 'Lists things.' },
+        handler: () => [{ id: 'a' }, { id: 'b' }],
+      } as never)
+
+      const listed = await client.listTools()
+      const tool = listed.tools.find(t => t.name.endsWith('list-things'))
+      expect(tool).toBeDefined()
+      expect(tool!.outputSchema).toBeUndefined()
+
+      const result = await client.callTool({ name: tool!.name, arguments: {} })
+      expect(result.isError).toBeFalsy()
+      const content = result.content as Array<{ type: string, text: string }>
+      expect(JSON.parse(content[0]!.text)).toEqual([{ id: 'a' }, { id: 'b' }])
+      expect(result.structuredContent).toBeUndefined()
+    }
+    finally {
+      await cleanup()
+    }
+  })
+
   it('coerces non-JSON values returned from a tool', async () => {
     const { ctx, client, cleanup } = await bootPair()
     try {

packages/devframe/src/agent/__tests__/to-json-schema.test.ts

@@ -49,7 +49,8 @@ describe('returnToJsonSchema', () => {
       .toEqual({ type: 'object', properties: { ok: { type: 'boolean' } } })
   })
 
-  it('falls back to permissive for validators without a native converter', () => {
-    expect(returnToJsonSchema(v.object({ ok: v.boolean() }))).toEqual(PERMISSIVE)
+  it('yields no schema for validators without a native converter', () => {
+    expect(returnToJsonSchema(v.object({ ok: v.boolean() }))).toBeUndefined()
+    expect(returnToJsonSchema(v.array(v.object({ ok: v.boolean() })))).toBeUndefined()
   })
 })

packages/devframe/src/agent/to-json-schema.ts

@@ -29,11 +29,20 @@ function safeToJsonSchema(schema: StandardSchemaV1): unknown {
 
 /**
  * JSON Schema for an RPC return value on the agent/MCP surface.
+ *
+ * Unlike args, a return value has no permissive fallback: the schema is
+ * advertised as an MCP `outputSchema`, which obliges the tool to return a
+ * matching object on every call. A validator without a native converter
+ * (e.g. valibot) yields no output schema rather than an unfounded object
+ * one, so array- and primitive-returning tools still work.
  * @internal
  */
 export function returnToJsonSchema(schema: StandardSchemaV1 | undefined): unknown {
   if (!schema)
     return undefined
+  const standard = schema['~standard'] as MaybeJsonSchema
+  if (!standard.jsonSchema)
+    return undefined
   return safeToJsonSchema(schema)
 }