@tanstack/ai 0.1.0 → 0.2.1

package/src/index.ts

@@ -47,14 +47,17 @@ export {
   type InferToolInput,
   type InferToolOutput,
 } from './activities/chat/tools/tool-definition'
-export { convertZodToJsonSchema } from './activities/chat/tools/zod-converter'
+
+// Schema conversion (Standard JSON Schema compliant)
+export { convertSchemaToJsonSchema } from './activities/chat/tools/schema-converter'
 
 // Stream utilities
 export {
   streamToText,
   toServerSentEventsStream,
-  toStreamResponse,
+  toServerSentEventsResponse,
   toHttpStream,
+  toHttpResponse,
 } from './stream-to-response'
 
 // Tool call management

package/src/stream-to-response.ts

@@ -45,13 +45,6 @@ export async function streamToText(
  * @param stream - AsyncIterable of StreamChunks from chat()
  * @param abortController - Optional AbortController to abort when stream is cancelled
  * @returns ReadableStream in Server-Sent Events format
- *
- * @example
- * ```typescript
- * const stream = chat({ adapter: openaiText(), model: "gpt-4o", messages: [...] });
- * const readableStream = toServerSentEventsStream(stream);
- * // Use with Response, or any API that accepts ReadableStream
- * ```
  */
 export function toServerSentEventsStream(
   stream: AsyncIterable<StreamChunk>,
@@ -109,6 +102,52 @@ export function toServerSentEventsStream(
   })
 }
 
+/**
+ * Convert a StreamChunk async iterable to a Response in Server-Sent Events format
+ *
+ * This creates a Response that emits chunks in SSE format:
+ * - Each chunk is prefixed with "data: "
+ * - Each chunk is followed by "\n\n"
+ * - Stream ends with "data: [DONE]\n\n"
+ *
+ * @param stream - AsyncIterable of StreamChunks from chat()
+ * @param init - Optional Response initialization options (including `abortController`)
+ * @returns Response in Server-Sent Events format
+ *
+ * @example
+ * ```typescript
+ * const stream = chat({ adapter: openaiText(), model: "gpt-4o", messages: [...] });
+ * return toServerSentEventsResponse(stream, { abortController });
+ * ```
+ */
+export function toServerSentEventsResponse(
+  stream: AsyncIterable<StreamChunk>,
+  init?: ResponseInit & { abortController?: AbortController },
+): Response {
+  const { headers, abortController, ...responseInit } = init ?? {}
+
+  // Start with default SSE headers
+  const mergedHeaders = new Headers({
+    'Content-Type': 'text/event-stream',
+    'Cache-Control': 'no-cache',
+    Connection: 'keep-alive',
+  })
+
+  // Override with user headers if provided, handling all HeadersInit forms:
+  // Headers instance, string[][], or plain object
+  if (headers) {
+    const userHeaders = new Headers(headers)
+    userHeaders.forEach((value, key) => {
+      mergedHeaders.set(key, value)
+    })
+  }
+
+  return new Response(toServerSentEventsStream(stream, abortController), {
+    ...responseInit,
+    headers: mergedHeaders,
+  })
+}
+
 /**
  * Convert a StreamChunk async iterable to a ReadableStream in HTTP stream format (newline-delimited JSON)
  *
@@ -185,53 +224,29 @@ export function toHttpStream(
 }
 
 /**
- * Create a streaming HTTP response from a StreamChunk async iterable
- * Includes proper headers for Server-Sent Events
+ * Convert a StreamChunk async iterable to a Response in HTTP stream format (newline-delimited JSON)
  *
- * @deprecated Use `toServerSentEventsStream` instead. This function will be removed in a future version.
+ * This creates a Response that emits chunks in HTTP stream format:
+ * - Each chunk is JSON.stringify'd and followed by "\n"
+ * - No SSE formatting (no "data: " prefix)
+ *
+ * This format is compatible with `fetchHttpStream` connection adapter.
  *
  * @param stream - AsyncIterable of StreamChunks from chat()
- * @param init - Optional Response initialization options
- * @param abortController - Optional AbortController to abort when client disconnects
- * @returns Response object with SSE headers and streaming body
+ * @param init - Optional Response initialization options (including `abortController`)
+ * @returns Response in HTTP stream format (newline-delimited JSON)
  *
  * @example
  * ```typescript
- * export async function POST(request: Request) {
- *   const { messages } = await request.json();
- *   const abortController = new AbortController();
- *   const stream = chat({
- *     adapter: openaiText(),
- *     model: "gpt-4o",
- *     messages,
- *     options: { abortSignal: abortController.signal }
- *   });
- *   return toStreamResponse(stream, undefined, abortController);
- * }
+ * const stream = chat({ adapter: openaiText(), model: "gpt-4o", messages: [...] });
+ * return toHttpResponse(stream, { abortController });
  * ```
  */
-export function toStreamResponse(
+export function toHttpResponse(
   stream: AsyncIterable<StreamChunk>,
   init?: ResponseInit & { abortController?: AbortController },
 ): Response {
-  if (typeof console !== 'undefined') {
-    console.warn(
-      '`toStreamResponse` is deprecated. Use `toServerSentEventsStream` instead. Example:\n' +
-        '  const readableStream = toServerSentEventsStream(stream, abortController);\n' +
-        '  return new Response(readableStream, {\n' +
-        "    headers: { 'Content-Type': 'text/event-stream', 'Cache-Control': 'no-cache', Connection: 'keep-alive' }\n" +
-        '  });',
-    )
-  }
-
-  const { headers, abortController, ...responseInit } = init ?? {}
-  return new Response(toServerSentEventsStream(stream, abortController), {
-    ...responseInit,
-    headers: {
-      'Content-Type': 'text/event-stream',
-      'Cache-Control': 'no-cache',
-      Connection: 'keep-alive',
-      ...(headers || {}),
-    },
+  return new Response(toHttpStream(stream, init?.abortController), {
+    ...init,
   })
 }

package/src/types.ts

@@ -1,4 +1,4 @@
-import type { z } from 'zod'
+import type { StandardJSONSchemaV1 } from '@standard-schema/spec'
 
 /**
  * Tool call states - track the lifecycle of a tool call
@@ -20,17 +20,17 @@ export type ToolResultState =
 
 /**
  * JSON Schema type for defining tool input/output schemas as raw JSON Schema objects.
- * This allows tools to be defined without Zod when you have JSON Schema definitions available.
+ * This allows tools to be defined without schema libraries when you have JSON Schema definitions available.
  */
 export interface JSONSchema {
   type?: string | Array<string>
   properties?: Record<string, JSONSchema>
   items?: JSONSchema | Array<JSONSchema>
   required?: Array<string>
-  enum?: Array<any>
-  const?: any
+  enum?: Array<unknown>
+  const?: unknown
   description?: string
-  default?: any
+  default?: unknown
   $ref?: string
   $defs?: Record<string, JSONSchema>
   definitions?: Record<string, JSONSchema>
@@ -59,21 +59,30 @@ export interface JSONSchema {
   minProperties?: number
   maxProperties?: number
   title?: string
-  examples?: Array<any>
+  examples?: Array<unknown>
   [key: string]: any // Allow additional properties for extensibility
 }
 
 /**
- * Union type for schema input - can be either a Zod schema or a JSONSchema object.
+ * Union type for schema input - can be any Standard JSON Schema compliant schema or a plain JSONSchema object.
+ *
+ * Standard JSON Schema compliant libraries include:
+ * - Zod v4.2+ (natively supports StandardJSONSchemaV1)
+ * - ArkType v2.1.28+ (natively supports StandardJSONSchemaV1)
+ * - Valibot v1.2+ (via `toStandardJsonSchema()` from `@valibot/to-json-schema`)
+ *
+ * @see https://standardschema.dev/json-schema
  */
-export type SchemaInput = z.ZodType | JSONSchema
+
+export type SchemaInput = StandardJSONSchemaV1<any, any> | JSONSchema
 
 /**
  * Infer the TypeScript type from a schema.
- * For Zod schemas, uses z.infer to get the proper type.
- * For JSONSchema, returns `any` since we can't infer types from JSON Schema at compile time.
+ * For Standard JSON Schema compliant schemas, extracts the input type.
+ * For plain JSONSchema, returns `any` since we can't infer types from JSON Schema at compile time.
  */
-export type InferSchemaType<T> = T extends z.ZodType ? z.infer<T> : any
+export type InferSchemaType<T> =
+  T extends StandardJSONSchemaV1<infer TInput, unknown> ? TInput : unknown
 
 export interface ToolCall {
   id: string
@@ -309,14 +318,16 @@ export type ConstrainedModelMessage<
  * Tools allow the model to interact with external systems, APIs, or perform computations.
  * The model will decide when to call tools based on the user's request and the tool descriptions.
  *
- * Tools can use either Zod schemas or JSON Schema objects for runtime validation and type safety.
+ * Tools can use any Standard JSON Schema compliant library (Zod, ArkType, Valibot, etc.)
+ * or plain JSON Schema objects for runtime validation and type safety.
  *
  * @see https://platform.openai.com/docs/guides/function-calling
  * @see https://docs.anthropic.com/claude/docs/tool-use
+ * @see https://standardschema.dev/json-schema
  */
 export interface Tool<
-  TInput extends SchemaInput = z.ZodType,
-  TOutput extends SchemaInput = z.ZodType,
+  TInput extends SchemaInput = SchemaInput,
+  TOutput extends SchemaInput = SchemaInput,
   TName extends string = string,
 > {
   /**
@@ -342,16 +353,16 @@ export interface Tool<
   /**
    * Schema describing the tool's input parameters.
    *
-   * Can be either a Zod schema or a JSON Schema object.
+   * Can be any Standard JSON Schema compliant schema (Zod, ArkType, Valibot, etc.) or a plain JSON Schema object.
    * Defines the structure and types of arguments the tool accepts.
    * The model will generate arguments matching this schema.
-   * Zod schemas are converted to JSON Schema for LLM providers.
+   * Standard JSON Schema compliant schemas are converted to JSON Schema for LLM providers.
    *
-   * @see https://zod.dev/
+   * @see https://standardschema.dev/json-schema
    * @see https://json-schema.org/
    *
    * @example
-   * // Using Zod schema
+   * // Using Zod v4+ schema (natively supports Standard JSON Schema)
    * import { z } from 'zod';
    * z.object({
    *   location: z.string().describe("City name or coordinates"),
@@ -359,7 +370,15 @@ export interface Tool<
    * })
    *
    * @example
-   * // Using JSON Schema
+   * // Using ArkType (natively supports Standard JSON Schema)
+   * import { type } from 'arktype';
+   * type({
+   *   location: 'string',
+   *   unit: "'celsius' | 'fahrenheit'"
+   * })
+   *
+   * @example
+   * // Using plain JSON Schema
    * {
    *   type: 'object',
    *   properties: {
@@ -374,15 +393,16 @@ export interface Tool<
   /**
    * Optional schema for validating tool output.
    *
-   * Can be either a Zod schema or a JSON Schema object.
-   * If provided with a Zod schema, tool results will be validated against this schema before
-   * being sent back to the model. This catches bugs in tool implementations
-   * and ensures consistent output formatting.
+   * Can be any Standard JSON Schema compliant schema or a plain JSON Schema object.
+   * If provided with a Standard Schema compliant schema, tool results will be validated
+   * against this schema before being sent back to the model. This catches bugs in tool
+   * implementations and ensures consistent output formatting.
    *
    * Note: This is client-side validation only - not sent to LLM providers.
-   * Note: JSON Schema output validation is not performed at runtime.
+   * Note: Plain JSON Schema output validation is not performed at runtime.
    *
    * @example
+   * // Using Zod
    * z.object({
    *   temperature: z.number(),
    *   conditions: z.string(),
@@ -601,12 +621,13 @@ export interface TextOptions<
   request?: Request | RequestInit
 
   /**
-   * Zod schema for structured output.
+   * Schema for structured output.
    * When provided, the adapter should use the provider's native structured output API
    * to ensure the response conforms to this schema.
    * The schema will be converted to JSON Schema format before being sent to the provider.
+   * Supports any Standard JSON Schema compliant library (Zod, ArkType, Valibot, etc.).
    */
-  outputSchema?: z.ZodType
+  outputSchema?: SchemaInput
   /**
    * Conversation ID for correlating client and server-side devtools events.
    * When provided, server-side events will be linked to the client conversation in devtools.

package/dist/esm/activities/chat/tools/zod-converter.d.ts

@@ -1,69 +0,0 @@
-import { SchemaInput } from '../../../types.js';
-/**
- * Options for schema conversion
- */
-export interface ConvertSchemaOptions {
-    /**
-     * When true, transforms the schema to be compatible with OpenAI's structured output requirements:
-     * - All properties are added to the `required` array
-     * - Optional fields get null added to their type union
-     * - additionalProperties is set to false for all objects
-     *
-     * @default false
-     */
-    forStructuredOutput?: boolean;
-}
-/**
- * Converts a schema (Zod or JSONSchema) to JSON Schema format compatible with LLM providers.
- * If the input is already a JSONSchema object, it is returned as-is.
- * If the input is a Zod schema, it is converted to JSON Schema.
- *
- * @param schema - Zod schema or JSONSchema object to convert
- * @param options - Conversion options
- * @returns JSON Schema object that can be sent to LLM providers
- *
- * @example
- * ```typescript
- * import { z } from 'zod';
- *
- * // Using Zod schema
- * const zodSchema = z.object({
- *   location: z.string().describe('City name'),
- *   unit: z.enum(['celsius', 'fahrenheit']).optional()
- * });
- *
- * const jsonSchema = convertZodToJsonSchema(zodSchema);
- * // Returns:
- * // {
- * //   type: 'object',
- * //   properties: {
- * //     location: { type: 'string', description: 'City name' },
- * //     unit: { type: 'string', enum: ['celsius', 'fahrenheit'] }
- * //   },
- * //   required: ['location']
- * // }
- *
- * // For OpenAI structured output (all fields required, optional fields nullable)
- * const structuredSchema = convertZodToJsonSchema(zodSchema, { forStructuredOutput: true });
- * // Returns:
- * // {
- * //   type: 'object',
- * //   properties: {
- * //     location: { type: 'string', description: 'City name' },
- * //     unit: { type: ['string', 'null'], enum: ['celsius', 'fahrenheit'] }
- * //   },
- * //   required: ['location', 'unit'],
- * //   additionalProperties: false
- * // }
- *
- * // Using JSONSchema directly (passes through unchanged)
- * const rawSchema = {
- *   type: 'object',
- *   properties: { location: { type: 'string' } },
- *   required: ['location']
- * };
- * const result = convertZodToJsonSchema(rawSchema);
- * // Returns the same object
- * ```
- */
-export declare function convertZodToJsonSchema(schema: SchemaInput | undefined, options?: ConvertSchemaOptions): Record<string, any> | undefined;

package/dist/esm/activities/chat/tools/zod-converter.js

@@ -1,99 +0,0 @@
-import { toJSONSchema } from "zod";
-function isZodSchema(schema) {
-  return typeof schema === "object" && schema !== null && "_zod" in schema && typeof schema._zod === "object";
-}
-function makeStructuredOutputCompatible(schema, originalRequired = []) {
-  const result = { ...schema };
-  if (result.type === "object" && result.properties) {
-    const properties = { ...result.properties };
-    const allPropertyNames = Object.keys(properties);
-    for (const propName of allPropertyNames) {
-      const prop = properties[propName];
-      const wasOptional = !originalRequired.includes(propName);
-      if (prop.type === "object" && prop.properties) {
-        properties[propName] = makeStructuredOutputCompatible(
-          prop,
-          prop.required || []
-        );
-      } else if (prop.type === "array" && prop.items) {
-        properties[propName] = {
-          ...prop,
-          items: makeStructuredOutputCompatible(
-            prop.items,
-            prop.items.required || []
-          )
-        };
-      } else if (wasOptional) {
-        if (prop.type && !Array.isArray(prop.type)) {
-          properties[propName] = {
-            ...prop,
-            type: [prop.type, "null"]
-          };
-        } else if (Array.isArray(prop.type) && !prop.type.includes("null")) {
-          properties[propName] = {
-            ...prop,
-            type: [...prop.type, "null"]
-          };
-        }
-      }
-    }
-    result.properties = properties;
-    result.required = allPropertyNames;
-    result.additionalProperties = false;
-  }
-  if (result.type === "array" && result.items) {
-    result.items = makeStructuredOutputCompatible(
-      result.items,
-      result.items.required || []
-    );
-  }
-  return result;
-}
-function convertZodToJsonSchema(schema, options = {}) {
-  if (!schema) return void 0;
-  const { forStructuredOutput = false } = options;
-  if (!isZodSchema(schema)) {
-    if (forStructuredOutput && typeof schema === "object") {
-      return makeStructuredOutputCompatible(
-        schema,
-        schema.required || []
-      );
-    }
-    return schema;
-  }
-  const jsonSchema = toJSONSchema(schema, {
-    target: "openapi-3.0",
-    reused: "ref"
-  });
-  let result = jsonSchema;
-  if (typeof result === "object" && "$schema" in result) {
-    const { $schema, ...rest } = result;
-    result = rest;
-  }
-  if (typeof result === "object") {
-    const isZodObject = typeof schema === "object" && "def" in schema && schema.def.type === "object";
-    if (isZodObject && !result.type) {
-      result.type = "object";
-    }
-    if (Object.keys(result).length === 0) {
-      result.type = "object";
-    }
-    if ("properties" in result && !result.type) {
-      result.type = "object";
-    }
-    if (result.type === "object" && !("properties" in result)) {
-      result.properties = {};
-    }
-    if (result.type === "object" && !("required" in result)) {
-      result.required = [];
-    }
-    if (forStructuredOutput) {
-      result = makeStructuredOutputCompatible(result, result.required || []);
-    }
-  }
-  return result;
-}
-export {
-  convertZodToJsonSchema
-};
-//# sourceMappingURL=zod-converter.js.map

package/dist/esm/activities/chat/tools/zod-converter.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"zod-converter.js","sources":["../../../../../src/activities/chat/tools/zod-converter.ts"],"sourcesContent":["import { toJSONSchema } from 'zod'\nimport type { z } from 'zod'\nimport type { SchemaInput } from '../../../types'\n\n/**\n * Check if a value is a Zod schema by looking for Zod-specific internals.\n * Zod schemas have a `_zod` property that contains metadata.\n */\nfunction isZodSchema(schema: unknown): schema is z.ZodType {\n  return (\n    typeof schema === 'object' &&\n    schema !== null &&\n    '_zod' in schema &&\n    typeof (schema as any)._zod === 'object'\n  )\n}\n\n/**\n * Transform a JSON schema to be compatible with OpenAI's structured output requirements.\n * OpenAI requires:\n * - All properties must be in the `required` array\n * - Optional fields should have null added to their type union\n * - additionalProperties must be false for objects\n *\n * @param schema - JSON schema to transform\n * @param originalRequired - Original required array (to know which fields were optional)\n * @returns Transformed schema compatible with OpenAI structured output\n */\nfunction makeStructuredOutputCompatible(\n  schema: Record<string, any>,\n  originalRequired: Array<string> = [],\n): Record<string, any> {\n  const result = { ...schema }\n\n  // Handle object types\n  if (result.type === 'object' && result.properties) {\n    const properties = { ...result.properties }\n    const allPropertyNames = Object.keys(properties)\n\n    // Transform each property\n    for (const propName of allPropertyNames) {\n      const prop = properties[propName]\n      const wasOptional = !originalRequired.includes(propName)\n\n      // Recursively transform nested objects/arrays\n      if (prop.type === 'object' && prop.properties) {\n        properties[propName] = makeStructuredOutputCompatible(\n          prop,\n          prop.required || [],\n        )\n      } else if (prop.type === 'array' && prop.items) {\n        properties[propName] = {\n          ...prop,\n          items: makeStructuredOutputCompatible(\n            prop.items,\n            prop.items.required || [],\n          ),\n        }\n      } else if (wasOptional) {\n        // Make optional fields nullable by adding null to the type\n        if (prop.type && !Array.isArray(prop.type)) {\n          properties[propName] = {\n            ...prop,\n            type: [prop.type, 'null'],\n          }\n        } else if (Array.isArray(prop.type) && !prop.type.includes('null')) {\n          properties[propName] = {\n            ...prop,\n            type: [...prop.type, 'null'],\n          }\n        }\n      }\n    }\n\n    result.properties = properties\n    // ALL properties must be required for OpenAI structured output\n    result.required = allPropertyNames\n    // additionalProperties must be false\n    result.additionalProperties = false\n  }\n\n  // Handle array types with object items\n  if (result.type === 'array' && result.items) {\n    result.items = makeStructuredOutputCompatible(\n      result.items,\n      result.items.required || [],\n    )\n  }\n\n  return result\n}\n\n/**\n * Options for schema conversion\n */\nexport interface ConvertSchemaOptions {\n  /**\n   * When true, transforms the schema to be compatible with OpenAI's structured output requirements:\n   * - All properties are added to the `required` array\n   * - Optional fields get null added to their type union\n   * - additionalProperties is set to false for all objects\n   *\n   * @default false\n   */\n  forStructuredOutput?: boolean\n}\n\n/**\n * Converts a schema (Zod or JSONSchema) to JSON Schema format compatible with LLM providers.\n * If the input is already a JSONSchema object, it is returned as-is.\n * If the input is a Zod schema, it is converted to JSON Schema.\n *\n * @param schema - Zod schema or JSONSchema object to convert\n * @param options - Conversion options\n * @returns JSON Schema object that can be sent to LLM providers\n *\n * @example\n * ```typescript\n * import { z } from 'zod';\n *\n * // Using Zod schema\n * const zodSchema = z.object({\n *   location: z.string().describe('City name'),\n *   unit: z.enum(['celsius', 'fahrenheit']).optional()\n * });\n *\n * const jsonSchema = convertZodToJsonSchema(zodSchema);\n * // Returns:\n * // {\n * //   type: 'object',\n * //   properties: {\n * //     location: { type: 'string', description: 'City name' },\n * //     unit: { type: 'string', enum: ['celsius', 'fahrenheit'] }\n * //   },\n * //   required: ['location']\n * // }\n *\n * // For OpenAI structured output (all fields required, optional fields nullable)\n * const structuredSchema = convertZodToJsonSchema(zodSchema, { forStructuredOutput: true });\n * // Returns:\n * // {\n * //   type: 'object',\n * //   properties: {\n * //     location: { type: 'string', description: 'City name' },\n * //     unit: { type: ['string', 'null'], enum: ['celsius', 'fahrenheit'] }\n * //   },\n * //   required: ['location', 'unit'],\n * //   additionalProperties: false\n * // }\n *\n * // Using JSONSchema directly (passes through unchanged)\n * const rawSchema = {\n *   type: 'object',\n *   properties: { location: { type: 'string' } },\n *   required: ['location']\n * };\n * const result = convertZodToJsonSchema(rawSchema);\n * // Returns the same object\n * ```\n */\nexport function convertZodToJsonSchema(\n  schema: SchemaInput | undefined,\n  options: ConvertSchemaOptions = {},\n): Record<string, any> | undefined {\n  if (!schema) return undefined\n\n  const { forStructuredOutput = false } = options\n\n  // If it's not a Zod schema, assume it's already a JSONSchema and pass through\n  if (!isZodSchema(schema)) {\n    // Still apply structured output transformation if requested\n    if (forStructuredOutput && typeof schema === 'object') {\n      return makeStructuredOutputCompatible(\n        schema,\n        (schema as any).required || [],\n      )\n    }\n    return schema\n  }\n\n  // Use Alcyone Labs fork which is compatible with Zod v4\n  const jsonSchema = toJSONSchema(schema, {\n    target: 'openapi-3.0',\n    reused: 'ref',\n  })\n\n  // Remove $schema property as it's not needed for LLM providers\n  let result = jsonSchema\n  if (typeof result === 'object' && '$schema' in result) {\n    const { $schema, ...rest } = result\n    result = rest\n  }\n\n  // Ensure object schemas always have type: \"object\"\n  // This fixes cases where zod-to-json-schema doesn't set type for empty objects\n  if (typeof result === 'object') {\n    // Check if the input schema is a ZodObject by inspecting its internal structure\n    const isZodObject =\n      typeof schema === 'object' &&\n      'def' in schema &&\n      schema.def.type === 'object'\n\n    // If we know it's a ZodObject but result doesn't have type, set it\n    if (isZodObject && !result.type) {\n      result.type = 'object'\n    }\n\n    // If result is completely empty (no keys), it's likely an empty object schema\n    if (Object.keys(result).length === 0) {\n      result.type = 'object'\n    }\n\n    // If it has properties (even empty), it should be an object type\n    if ('properties' in result && !result.type) {\n      result.type = 'object'\n    }\n\n    // Ensure properties exists for object types (even if empty)\n    if (result.type === 'object' && !('properties' in result)) {\n      result.properties = {}\n    }\n\n    // Ensure required exists for object types (even if empty array)\n    if (result.type === 'object' && !('required' in result)) {\n      result.required = []\n    }\n\n    // Apply structured output transformation if requested\n    if (forStructuredOutput) {\n      result = makeStructuredOutputCompatible(result, result.required || [])\n    }\n  }\n\n  return result\n}\n"],"names":[],"mappings":"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"}