fix: route function-typed Standard Schemas through elicitation conversion

The schema-detection guard required typeof object, so function-typed
Standard Schemas (e.g. ArkType) fell through to the raw branch and the
vendor-internal object shipped as requestedSchema with no conversion or
flat-primitive gate. Delegate to isStandardSchema, which accepts
functions and verifies ~standard.validate — and, matching the precedent
in normalizeRawShapeSchema, does not gate on ~standard.jsonSchema so
the zod 4.0/4.1 fallback stays reachable. Also fixes the reverse
misroute: a plain JSON requestedSchema containing a literal '~standard'
key is wire-legal and now stays on the raw branch instead of throwing a
vendor error.

Author: felixweinberger

packages/core-internal/src/shared/elicitation.ts

@@ -6,7 +6,7 @@ import { ElicitRequestFormParamsSchema } from '../types/schemas';
 import type { ElicitRequestFormParams } from '../types/types';
 import { parseSchema } from '../util/schema';
 import type { StandardSchemaWithJSON } from '../util/standardSchema';
-import { standardSchemaToJsonSchema } from '../util/standardSchema';
+import { isStandardSchema, standardSchemaToJsonSchema } from '../util/standardSchema';
 import type { ElicitInputFormParams } from './protocol';
 
 export type NormalizedElicitInputFormParams = {
@@ -154,7 +154,12 @@ function findStrippedJsonSchemaPaths(original: unknown, parsed: unknown, path =
 function isElicitInputSchema(
     schema: ElicitRequestFormParams['requestedSchema'] | StandardSchemaWithJSON
 ): schema is StandardSchemaWithJSON {
-    return typeof schema === 'object' && schema !== null && '~standard' in schema;
+    // isStandardSchema, not a plain '~standard' key probe: ArkType schemas are functions
+    // (a typeof-object check routes them, unconverted, to the raw branch), and a plain JSON
+    // schema containing a literal '~standard' key — wire-legal via the catchall — must stay
+    // on the raw branch. Not isStandardSchemaWithJSON: gating on `~standard.jsonSchema` here
+    // would front-run standardSchemaToJsonSchema's zod 4.0/4.1 fallback (see zodCompat.ts).
+    return isStandardSchema(schema);
 }
 
 function convertStandardElicitationSchema(standardSchema: StandardSchemaWithJSON): Record<string, unknown> {

packages/core-internal/test/shared/elicitation.test.ts

@@ -19,6 +19,51 @@ function schemaFromJson(jsonSchema: Record<string, unknown>): StandardSchemaWith
     } satisfies StandardSchemaWithJSON;
 }
 
+describe('normalizeElicitInputFormParams schema detection', () => {
+    test('converts function-typed Standard Schemas (ArkType-style)', () => {
+        const jsonSchema = {
+            type: 'object',
+            properties: { name: { type: 'string' } },
+            required: ['name']
+        };
+        const functionSchema = Object.assign(() => {}, {
+            '~standard': {
+                version: 1 as const,
+                vendor: 'test',
+                validate: (value: unknown) => ({ value }),
+                jsonSchema: {
+                    input: () => jsonSchema,
+                    output: () => ({})
+                }
+            }
+        });
+
+        const { params, standardSchema } = normalizeElicitInputFormParams({
+            message: 'Name?',
+            requestedSchema: functionSchema as unknown as StandardSchemaWithJSON
+        });
+
+        expect(standardSchema).toBe(functionSchema);
+        expect(params.requestedSchema).toEqual(jsonSchema);
+    });
+
+    test('routes a plain JSON schema containing a literal "~standard" key to the raw branch', () => {
+        const rawSchema = {
+            type: 'object' as const,
+            properties: { name: { type: 'string' as const } },
+            '~standard': 'extension-data'
+        };
+
+        const { params, standardSchema } = normalizeElicitInputFormParams({
+            message: 'Name?',
+            requestedSchema: rawSchema as never
+        });
+
+        expect(standardSchema).toBeUndefined();
+        expect(params.requestedSchema).toBe(rawSchema);
+    });
+});
+
 describe('normalizeElicitInputFormParams root keywords', () => {
     test('keeps the spec-declared root keys including $schema', () => {
         const { params } = normalizeElicitInputFormParams({