fix(agentic): yield no return schema when conversion fails

Checking only for a converter's presence left the throwing path on the
fallback: `input`/`output` may throw when conversion is unsupported, and
that was caught into the permissive object schema, reproducing the same
MCP rejection.

Convert via the converter's `output` too, since a transforming validator
returns its output type, and the return value is what `outputSchema`
describes.

Author: erkamyaman

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

@@ -53,4 +53,35 @@ describe('returnToJsonSchema', () => {
     expect(returnToJsonSchema(v.object({ ok: v.boolean() }))).toBeUndefined()
     expect(returnToJsonSchema(v.array(v.object({ ok: v.boolean() })))).toBeUndefined()
   })
+
+  it('yields no schema when the converter cannot express the schema', () => {
+    const throwing = {
+      '~standard': {
+        version: 1,
+        vendor: 'test',
+        validate: (value: unknown) => ({ value }),
+        jsonSchema: {
+          input: () => { throw new Error('unsupported') },
+          output: () => { throw new Error('unsupported') },
+        },
+      } as StandardSchemaV1['~standard'],
+    }
+    expect(returnToJsonSchema(throwing)).toBeUndefined()
+  })
+
+  it('converts the output type, not the input type', () => {
+    const transforming = {
+      '~standard': {
+        version: 1,
+        vendor: 'test',
+        validate: (value: unknown) => ({ value }),
+        jsonSchema: {
+          input: () => ({ type: 'string' }),
+          output: () => ({ type: 'object', properties: { parsed: { type: 'number' } } }),
+        },
+      } as StandardSchemaV1['~standard'],
+    }
+    expect(returnToJsonSchema(transforming))
+      .toEqual({ type: 'object', properties: { parsed: { type: 'number' } } })
+  })
 })

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

@@ -32,9 +32,11 @@ function safeToJsonSchema(schema: StandardSchemaV1): unknown {
  *
  * 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.
+ * matching object on every call. A validator with no native converter
+ * (e.g. valibot), or one whose converter cannot express the schema, yields
+ * no output schema rather than an unfounded object one, so array- and
+ * primitive-returning tools still work. Conversion uses the converter's
+ * `output`, since a transforming validator returns its output type.
  * @internal
  */
 export function returnToJsonSchema(schema: StandardSchemaV1 | undefined): unknown {
@@ -43,7 +45,12 @@ export function returnToJsonSchema(schema: StandardSchemaV1 | undefined): unknow
   const standard = schema['~standard'] as MaybeJsonSchema
   if (!standard.jsonSchema)
     return undefined
-  return safeToJsonSchema(schema)
+  try {
+    return standard.jsonSchema.output({ target: 'draft-2020-12' })
+  }
+  catch {
+    return undefined
+  }
 }
 
 /**