@tanstack/ai 0.1.0 → 0.2.1

package/dist/esm/stream-to-response.js.map

@@ -1 +1 @@
-{"version":3,"file":"stream-to-response.js","sources":["../../src/stream-to-response.ts"],"sourcesContent":["import type { StreamChunk } from './types'\n\n/**\n * Collect all text content from a StreamChunk async iterable and return as a string.\n *\n * This function consumes the entire stream, accumulating content from 'content' type chunks,\n * and returns the final concatenated text.\n *\n * @param stream - AsyncIterable of StreamChunks from chat()\n * @returns Promise<string> - The accumulated text content\n *\n * @example\n * ```typescript\n * const stream = chat({\n *   adapter: openaiText(),\n *   model: 'gpt-4o',\n *   messages: [{ role: 'user', content: 'Hello!' }]\n * });\n * const text = await streamToText(stream);\n * console.log(text); // \"Hello! How can I help you today?\"\n * ```\n */\nexport async function streamToText(\n  stream: AsyncIterable<StreamChunk>,\n): Promise<string> {\n  let accumulatedContent = ''\n\n  for await (const chunk of stream) {\n    if (chunk.type === 'content' && chunk.delta) {\n      accumulatedContent += chunk.delta\n    }\n  }\n\n  return accumulatedContent\n}\n\n/**\n * Convert a StreamChunk async iterable to a ReadableStream in Server-Sent Events format\n *\n * This creates a ReadableStream that emits chunks in SSE format:\n * - Each chunk is prefixed with \"data: \"\n * - Each chunk is followed by \"\\n\\n\"\n * - Stream ends with \"data: [DONE]\\n\\n\"\n *\n * @param stream - AsyncIterable of StreamChunks from chat()\n * @param abortController - Optional AbortController to abort when stream is cancelled\n * @returns ReadableStream in Server-Sent Events format\n *\n * @example\n * ```typescript\n * const stream = chat({ adapter: openaiText(), model: \"gpt-4o\", messages: [...] });\n * const readableStream = toServerSentEventsStream(stream);\n * // Use with Response, or any API that accepts ReadableStream\n * ```\n */\nexport function toServerSentEventsStream(\n  stream: AsyncIterable<StreamChunk>,\n  abortController?: AbortController,\n): ReadableStream<Uint8Array> {\n  const encoder = new TextEncoder()\n\n  return new ReadableStream({\n    async start(controller) {\n      try {\n        for await (const chunk of stream) {\n          // Check if stream was cancelled/aborted\n          if (abortController?.signal.aborted) {\n            break\n          }\n\n          // Send each chunk as Server-Sent Events format\n          controller.enqueue(\n            encoder.encode(`data: ${JSON.stringify(chunk)}\\n\\n`),\n          )\n        }\n\n        // Send completion marker\n        controller.enqueue(encoder.encode('data: [DONE]\\n\\n'))\n        controller.close()\n      } catch (error: any) {\n        // Don't send error if aborted\n        if (abortController?.signal.aborted) {\n          controller.close()\n          return\n        }\n\n        // Send error chunk\n        controller.enqueue(\n          encoder.encode(\n            `data: ${JSON.stringify({\n              type: 'error',\n              error: {\n                message: error.message || 'Unknown error occurred',\n                code: error.code,\n              },\n            })}\\n\\n`,\n          ),\n        )\n        controller.close()\n      }\n    },\n    cancel() {\n      // When the ReadableStream is cancelled (e.g., client disconnects),\n      // abort the underlying stream\n      if (abortController) {\n        abortController.abort()\n      }\n    },\n  })\n}\n\n/**\n * Convert a StreamChunk async iterable to a ReadableStream in HTTP stream format (newline-delimited JSON)\n *\n * This creates a ReadableStream that emits chunks as newline-delimited JSON:\n * - Each chunk is JSON.stringify'd and followed by \"\\n\"\n * - No SSE formatting (no \"data: \" prefix)\n *\n * This format is compatible with `fetchHttpStream` connection adapter.\n *\n * @param stream - AsyncIterable of StreamChunks from chat()\n * @param abortController - Optional AbortController to abort when stream is cancelled\n * @returns ReadableStream in HTTP stream format (newline-delimited JSON)\n *\n * @example\n * ```typescript\n * const stream = chat({ adapter: openaiText(), model: \"gpt-4o\", messages: [...] });\n * const readableStream = toHttpStream(stream);\n * // Use with Response for HTTP streaming (not SSE)\n * return new Response(readableStream, {\n *   headers: { 'Content-Type': 'application/x-ndjson' }\n * });\n * ```\n */\nexport function toHttpStream(\n  stream: AsyncIterable<StreamChunk>,\n  abortController?: AbortController,\n): ReadableStream<Uint8Array> {\n  const encoder = new TextEncoder()\n\n  return new ReadableStream({\n    async start(controller) {\n      try {\n        for await (const chunk of stream) {\n          // Check if stream was cancelled/aborted\n          if (abortController?.signal.aborted) {\n            break\n          }\n\n          // Send each chunk as newline-delimited JSON\n          controller.enqueue(encoder.encode(`${JSON.stringify(chunk)}\\n`))\n        }\n\n        controller.close()\n      } catch (error: any) {\n        // Don't send error if aborted\n        if (abortController?.signal.aborted) {\n          controller.close()\n          return\n        }\n\n        // Send error chunk\n        controller.enqueue(\n          encoder.encode(\n            `${JSON.stringify({\n              type: 'error',\n              error: {\n                message: error.message || 'Unknown error occurred',\n                code: error.code,\n              },\n            })}\\n`,\n          ),\n        )\n        controller.close()\n      }\n    },\n    cancel() {\n      // When the ReadableStream is cancelled (e.g., client disconnects),\n      // abort the underlying stream\n      if (abortController) {\n        abortController.abort()\n      }\n    },\n  })\n}\n\n/**\n * Create a streaming HTTP response from a StreamChunk async iterable\n * Includes proper headers for Server-Sent Events\n *\n * @deprecated Use `toServerSentEventsStream` instead. This function will be removed in a future version.\n *\n * @param stream - AsyncIterable of StreamChunks from chat()\n * @param init - Optional Response initialization options\n * @param abortController - Optional AbortController to abort when client disconnects\n * @returns Response object with SSE headers and streaming body\n *\n * @example\n * ```typescript\n * export async function POST(request: Request) {\n *   const { messages } = await request.json();\n *   const abortController = new AbortController();\n *   const stream = chat({\n *     adapter: openaiText(),\n *     model: \"gpt-4o\",\n *     messages,\n *     options: { abortSignal: abortController.signal }\n *   });\n *   return toStreamResponse(stream, undefined, abortController);\n * }\n * ```\n */\nexport function toStreamResponse(\n  stream: AsyncIterable<StreamChunk>,\n  init?: ResponseInit & { abortController?: AbortController },\n): Response {\n  if (typeof console !== 'undefined') {\n    console.warn(\n      '`toStreamResponse` is deprecated. Use `toServerSentEventsStream` instead. Example:\\n' +\n        '  const readableStream = toServerSentEventsStream(stream, abortController);\\n' +\n        '  return new Response(readableStream, {\\n' +\n        \"    headers: { 'Content-Type': 'text/event-stream', 'Cache-Control': 'no-cache', Connection: 'keep-alive' }\\n\" +\n        '  });',\n    )\n  }\n\n  const { headers, abortController, ...responseInit } = init ?? {}\n  return new Response(toServerSentEventsStream(stream, abortController), {\n    ...responseInit,\n    headers: {\n      'Content-Type': 'text/event-stream',\n      'Cache-Control': 'no-cache',\n      Connection: 'keep-alive',\n      ...(headers || {}),\n    },\n  })\n}\n"],"names":[],"mappings":"AAsBA,eAAsB,aACpB,QACiB;AACjB,MAAI,qBAAqB;AAEzB,mBAAiB,SAAS,QAAQ;AAChC,QAAI,MAAM,SAAS,aAAa,MAAM,OAAO;AAC3C,4BAAsB,MAAM;AAAA,IAC9B;AAAA,EACF;AAEA,SAAO;AACT;AAqBO,SAAS,yBACd,QACA,iBAC4B;AAC5B,QAAM,UAAU,IAAI,YAAA;AAEpB,SAAO,IAAI,eAAe;AAAA,IACxB,MAAM,MAAM,YAAY;AACtB,UAAI;AACF,yBAAiB,SAAS,QAAQ;AAEhC,cAAI,iBAAiB,OAAO,SAAS;AACnC;AAAA,UACF;AAGA,qBAAW;AAAA,YACT,QAAQ,OAAO,SAAS,KAAK,UAAU,KAAK,CAAC;AAAA;AAAA,CAAM;AAAA,UAAA;AAAA,QAEvD;AAGA,mBAAW,QAAQ,QAAQ,OAAO,kBAAkB,CAAC;AACrD,mBAAW,MAAA;AAAA,MACb,SAAS,OAAY;AAEnB,YAAI,iBAAiB,OAAO,SAAS;AACnC,qBAAW,MAAA;AACX;AAAA,QACF;AAGA,mBAAW;AAAA,UACT,QAAQ;AAAA,YACN,SAAS,KAAK,UAAU;AAAA,cACtB,MAAM;AAAA,cACN,OAAO;AAAA,gBACL,SAAS,MAAM,WAAW;AAAA,gBAC1B,MAAM,MAAM;AAAA,cAAA;AAAA,YACd,CACD,CAAC;AAAA;AAAA;AAAA,UAAA;AAAA,QACJ;AAEF,mBAAW,MAAA;AAAA,MACb;AAAA,IACF;AAAA,IACA,SAAS;AAGP,UAAI,iBAAiB;AACnB,wBAAgB,MAAA;AAAA,MAClB;AAAA,IACF;AAAA,EAAA,CACD;AACH;AAyBO,SAAS,aACd,QACA,iBAC4B;AAC5B,QAAM,UAAU,IAAI,YAAA;AAEpB,SAAO,IAAI,eAAe;AAAA,IACxB,MAAM,MAAM,YAAY;AACtB,UAAI;AACF,yBAAiB,SAAS,QAAQ;AAEhC,cAAI,iBAAiB,OAAO,SAAS;AACnC;AAAA,UACF;AAGA,qBAAW,QAAQ,QAAQ,OAAO,GAAG,KAAK,UAAU,KAAK,CAAC;AAAA,CAAI,CAAC;AAAA,QACjE;AAEA,mBAAW,MAAA;AAAA,MACb,SAAS,OAAY;AAEnB,YAAI,iBAAiB,OAAO,SAAS;AACnC,qBAAW,MAAA;AACX;AAAA,QACF;AAGA,mBAAW;AAAA,UACT,QAAQ;AAAA,YACN,GAAG,KAAK,UAAU;AAAA,cAChB,MAAM;AAAA,cACN,OAAO;AAAA,gBACL,SAAS,MAAM,WAAW;AAAA,gBAC1B,MAAM,MAAM;AAAA,cAAA;AAAA,YACd,CACD,CAAC;AAAA;AAAA,UAAA;AAAA,QACJ;AAEF,mBAAW,MAAA;AAAA,MACb;AAAA,IACF;AAAA,IACA,SAAS;AAGP,UAAI,iBAAiB;AACnB,wBAAgB,MAAA;AAAA,MAClB;AAAA,IACF;AAAA,EAAA,CACD;AACH;AA4BO,SAAS,iBACd,QACA,MACU;AACV,MAAI,OAAO,YAAY,aAAa;AAClC,YAAQ;AAAA,MACN;AAAA,IAAA;AAAA,EAMJ;AAEA,QAAM,EAAE,SAAS,iBAAiB,GAAG,aAAA,IAAiB,QAAQ,CAAA;AAC9D,SAAO,IAAI,SAAS,yBAAyB,QAAQ,eAAe,GAAG;AAAA,IACrE,GAAG;AAAA,IACH,SAAS;AAAA,MACP,gBAAgB;AAAA,MAChB,iBAAiB;AAAA,MACjB,YAAY;AAAA,MACZ,GAAI,WAAW,CAAA;AAAA,IAAC;AAAA,EAClB,CACD;AACH;"}
+{"version":3,"file":"stream-to-response.js","sources":["../../src/stream-to-response.ts"],"sourcesContent":["import type { StreamChunk } from './types'\n\n/**\n * Collect all text content from a StreamChunk async iterable and return as a string.\n *\n * This function consumes the entire stream, accumulating content from 'content' type chunks,\n * and returns the final concatenated text.\n *\n * @param stream - AsyncIterable of StreamChunks from chat()\n * @returns Promise<string> - The accumulated text content\n *\n * @example\n * ```typescript\n * const stream = chat({\n *   adapter: openaiText(),\n *   model: 'gpt-4o',\n *   messages: [{ role: 'user', content: 'Hello!' }]\n * });\n * const text = await streamToText(stream);\n * console.log(text); // \"Hello! How can I help you today?\"\n * ```\n */\nexport async function streamToText(\n  stream: AsyncIterable<StreamChunk>,\n): Promise<string> {\n  let accumulatedContent = ''\n\n  for await (const chunk of stream) {\n    if (chunk.type === 'content' && chunk.delta) {\n      accumulatedContent += chunk.delta\n    }\n  }\n\n  return accumulatedContent\n}\n\n/**\n * Convert a StreamChunk async iterable to a ReadableStream in Server-Sent Events format\n *\n * This creates a ReadableStream that emits chunks in SSE format:\n * - Each chunk is prefixed with \"data: \"\n * - Each chunk is followed by \"\\n\\n\"\n * - Stream ends with \"data: [DONE]\\n\\n\"\n *\n * @param stream - AsyncIterable of StreamChunks from chat()\n * @param abortController - Optional AbortController to abort when stream is cancelled\n * @returns ReadableStream in Server-Sent Events format\n */\nexport function toServerSentEventsStream(\n  stream: AsyncIterable<StreamChunk>,\n  abortController?: AbortController,\n): ReadableStream<Uint8Array> {\n  const encoder = new TextEncoder()\n\n  return new ReadableStream({\n    async start(controller) {\n      try {\n        for await (const chunk of stream) {\n          // Check if stream was cancelled/aborted\n          if (abortController?.signal.aborted) {\n            break\n          }\n\n          // Send each chunk as Server-Sent Events format\n          controller.enqueue(\n            encoder.encode(`data: ${JSON.stringify(chunk)}\\n\\n`),\n          )\n        }\n\n        // Send completion marker\n        controller.enqueue(encoder.encode('data: [DONE]\\n\\n'))\n        controller.close()\n      } catch (error: any) {\n        // Don't send error if aborted\n        if (abortController?.signal.aborted) {\n          controller.close()\n          return\n        }\n\n        // Send error chunk\n        controller.enqueue(\n          encoder.encode(\n            `data: ${JSON.stringify({\n              type: 'error',\n              error: {\n                message: error.message || 'Unknown error occurred',\n                code: error.code,\n              },\n            })}\\n\\n`,\n          ),\n        )\n        controller.close()\n      }\n    },\n    cancel() {\n      // When the ReadableStream is cancelled (e.g., client disconnects),\n      // abort the underlying stream\n      if (abortController) {\n        abortController.abort()\n      }\n    },\n  })\n}\n\n/**\n * Convert a StreamChunk async iterable to a Response in Server-Sent Events format\n *\n * This creates a Response that emits chunks in SSE format:\n * - Each chunk is prefixed with \"data: \"\n * - Each chunk is followed by \"\\n\\n\"\n * - Stream ends with \"data: [DONE]\\n\\n\"\n *\n * @param stream - AsyncIterable of StreamChunks from chat()\n * @param init - Optional Response initialization options (including `abortController`)\n * @returns Response in Server-Sent Events format\n *\n * @example\n * ```typescript\n * const stream = chat({ adapter: openaiText(), model: \"gpt-4o\", messages: [...] });\n * return toServerSentEventsResponse(stream, { abortController });\n * ```\n */\nexport function toServerSentEventsResponse(\n  stream: AsyncIterable<StreamChunk>,\n  init?: ResponseInit & { abortController?: AbortController },\n): Response {\n  const { headers, abortController, ...responseInit } = init ?? {}\n\n  // Start with default SSE headers\n  const mergedHeaders = new Headers({\n    'Content-Type': 'text/event-stream',\n    'Cache-Control': 'no-cache',\n    Connection: 'keep-alive',\n  })\n\n  // Override with user headers if provided, handling all HeadersInit forms:\n  // Headers instance, string[][], or plain object\n  if (headers) {\n    const userHeaders = new Headers(headers)\n    userHeaders.forEach((value, key) => {\n      mergedHeaders.set(key, value)\n    })\n  }\n\n  return new Response(toServerSentEventsStream(stream, abortController), {\n    ...responseInit,\n    headers: mergedHeaders,\n  })\n}\n\n/**\n * Convert a StreamChunk async iterable to a ReadableStream in HTTP stream format (newline-delimited JSON)\n *\n * This creates a ReadableStream that emits chunks as newline-delimited JSON:\n * - Each chunk is JSON.stringify'd and followed by \"\\n\"\n * - No SSE formatting (no \"data: \" prefix)\n *\n * This format is compatible with `fetchHttpStream` connection adapter.\n *\n * @param stream - AsyncIterable of StreamChunks from chat()\n * @param abortController - Optional AbortController to abort when stream is cancelled\n * @returns ReadableStream in HTTP stream format (newline-delimited JSON)\n *\n * @example\n * ```typescript\n * const stream = chat({ adapter: openaiText(), model: \"gpt-4o\", messages: [...] });\n * const readableStream = toHttpStream(stream);\n * // Use with Response for HTTP streaming (not SSE)\n * return new Response(readableStream, {\n *   headers: { 'Content-Type': 'application/x-ndjson' }\n * });\n * ```\n */\nexport function toHttpStream(\n  stream: AsyncIterable<StreamChunk>,\n  abortController?: AbortController,\n): ReadableStream<Uint8Array> {\n  const encoder = new TextEncoder()\n\n  return new ReadableStream({\n    async start(controller) {\n      try {\n        for await (const chunk of stream) {\n          // Check if stream was cancelled/aborted\n          if (abortController?.signal.aborted) {\n            break\n          }\n\n          // Send each chunk as newline-delimited JSON\n          controller.enqueue(encoder.encode(`${JSON.stringify(chunk)}\\n`))\n        }\n\n        controller.close()\n      } catch (error: any) {\n        // Don't send error if aborted\n        if (abortController?.signal.aborted) {\n          controller.close()\n          return\n        }\n\n        // Send error chunk\n        controller.enqueue(\n          encoder.encode(\n            `${JSON.stringify({\n              type: 'error',\n              error: {\n                message: error.message || 'Unknown error occurred',\n                code: error.code,\n              },\n            })}\\n`,\n          ),\n        )\n        controller.close()\n      }\n    },\n    cancel() {\n      // When the ReadableStream is cancelled (e.g., client disconnects),\n      // abort the underlying stream\n      if (abortController) {\n        abortController.abort()\n      }\n    },\n  })\n}\n\n/**\n * Convert a StreamChunk async iterable to a Response in HTTP stream format (newline-delimited JSON)\n *\n * This creates a Response that emits chunks in HTTP stream format:\n * - Each chunk is JSON.stringify'd and followed by \"\\n\"\n * - No SSE formatting (no \"data: \" prefix)\n *\n * This format is compatible with `fetchHttpStream` connection adapter.\n *\n * @param stream - AsyncIterable of StreamChunks from chat()\n * @param init - Optional Response initialization options (including `abortController`)\n * @returns Response in HTTP stream format (newline-delimited JSON)\n *\n * @example\n * ```typescript\n * const stream = chat({ adapter: openaiText(), model: \"gpt-4o\", messages: [...] });\n * return toHttpResponse(stream, { abortController });\n * ```\n */\nexport function toHttpResponse(\n  stream: AsyncIterable<StreamChunk>,\n  init?: ResponseInit & { abortController?: AbortController },\n): Response {\n  return new Response(toHttpStream(stream, init?.abortController), {\n    ...init,\n  })\n}\n"],"names":[],"mappings":"AAsBA,eAAsB,aACpB,QACiB;AACjB,MAAI,qBAAqB;AAEzB,mBAAiB,SAAS,QAAQ;AAChC,QAAI,MAAM,SAAS,aAAa,MAAM,OAAO;AAC3C,4BAAsB,MAAM;AAAA,IAC9B;AAAA,EACF;AAEA,SAAO;AACT;AAcO,SAAS,yBACd,QACA,iBAC4B;AAC5B,QAAM,UAAU,IAAI,YAAA;AAEpB,SAAO,IAAI,eAAe;AAAA,IACxB,MAAM,MAAM,YAAY;AACtB,UAAI;AACF,yBAAiB,SAAS,QAAQ;AAEhC,cAAI,iBAAiB,OAAO,SAAS;AACnC;AAAA,UACF;AAGA,qBAAW;AAAA,YACT,QAAQ,OAAO,SAAS,KAAK,UAAU,KAAK,CAAC;AAAA;AAAA,CAAM;AAAA,UAAA;AAAA,QAEvD;AAGA,mBAAW,QAAQ,QAAQ,OAAO,kBAAkB,CAAC;AACrD,mBAAW,MAAA;AAAA,MACb,SAAS,OAAY;AAEnB,YAAI,iBAAiB,OAAO,SAAS;AACnC,qBAAW,MAAA;AACX;AAAA,QACF;AAGA,mBAAW;AAAA,UACT,QAAQ;AAAA,YACN,SAAS,KAAK,UAAU;AAAA,cACtB,MAAM;AAAA,cACN,OAAO;AAAA,gBACL,SAAS,MAAM,WAAW;AAAA,gBAC1B,MAAM,MAAM;AAAA,cAAA;AAAA,YACd,CACD,CAAC;AAAA;AAAA;AAAA,UAAA;AAAA,QACJ;AAEF,mBAAW,MAAA;AAAA,MACb;AAAA,IACF;AAAA,IACA,SAAS;AAGP,UAAI,iBAAiB;AACnB,wBAAgB,MAAA;AAAA,MAClB;AAAA,IACF;AAAA,EAAA,CACD;AACH;AAoBO,SAAS,2BACd,QACA,MACU;AACV,QAAM,EAAE,SAAS,iBAAiB,GAAG,aAAA,IAAiB,QAAQ,CAAA;AAG9D,QAAM,gBAAgB,IAAI,QAAQ;AAAA,IAChC,gBAAgB;AAAA,IAChB,iBAAiB;AAAA,IACjB,YAAY;AAAA,EAAA,CACb;AAID,MAAI,SAAS;AACX,UAAM,cAAc,IAAI,QAAQ,OAAO;AACvC,gBAAY,QAAQ,CAAC,OAAO,QAAQ;AAClC,oBAAc,IAAI,KAAK,KAAK;AAAA,IAC9B,CAAC;AAAA,EACH;AAEA,SAAO,IAAI,SAAS,yBAAyB,QAAQ,eAAe,GAAG;AAAA,IACrE,GAAG;AAAA,IACH,SAAS;AAAA,EAAA,CACV;AACH;AAyBO,SAAS,aACd,QACA,iBAC4B;AAC5B,QAAM,UAAU,IAAI,YAAA;AAEpB,SAAO,IAAI,eAAe;AAAA,IACxB,MAAM,MAAM,YAAY;AACtB,UAAI;AACF,yBAAiB,SAAS,QAAQ;AAEhC,cAAI,iBAAiB,OAAO,SAAS;AACnC;AAAA,UACF;AAGA,qBAAW,QAAQ,QAAQ,OAAO,GAAG,KAAK,UAAU,KAAK,CAAC;AAAA,CAAI,CAAC;AAAA,QACjE;AAEA,mBAAW,MAAA;AAAA,MACb,SAAS,OAAY;AAEnB,YAAI,iBAAiB,OAAO,SAAS;AACnC,qBAAW,MAAA;AACX;AAAA,QACF;AAGA,mBAAW;AAAA,UACT,QAAQ;AAAA,YACN,GAAG,KAAK,UAAU;AAAA,cAChB,MAAM;AAAA,cACN,OAAO;AAAA,gBACL,SAAS,MAAM,WAAW;AAAA,gBAC1B,MAAM,MAAM;AAAA,cAAA;AAAA,YACd,CACD,CAAC;AAAA;AAAA,UAAA;AAAA,QACJ;AAEF,mBAAW,MAAA;AAAA,MACb;AAAA,IACF;AAAA,IACA,SAAS;AAGP,UAAI,iBAAiB;AACnB,wBAAgB,MAAA;AAAA,MAClB;AAAA,IACF;AAAA,EAAA,CACD;AACH;AAqBO,SAAS,eACd,QACA,MACU;AACV,SAAO,IAAI,SAAS,aAAa,QAAQ,MAAM,eAAe,GAAG;AAAA,IAC/D,GAAG;AAAA,EAAA,CACJ;AACH;"}

package/dist/esm/types.d.ts

@@ -1,4 +1,4 @@
-import { z } from 'zod';
+import { StandardJSONSchemaV1 } from '@standard-schema/spec';
 /**
  * Tool call states - track the lifecycle of a tool call
  */
@@ -9,17 +9,17 @@ export type ToolCallState = 'awaiting-input' | 'input-streaming' | 'input-comple
 export type ToolResultState = 'streaming' | 'complete' | 'error';
 /**
  * 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>;
@@ -48,19 +48,26 @@ export interface JSONSchema {
     minProperties?: number;
     maxProperties?: number;
     title?: string;
-    examples?: Array<any>;
+    examples?: Array<unknown>;
     [key: string]: any;
 }
 /**
- * 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;
     type: 'function';
@@ -234,12 +241,14 @@ export type ConstrainedModelMessage<TInputModalitiesTypes extends InputModalitie
  * 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, TName extends string = string> {
+export interface Tool<TInput extends SchemaInput = SchemaInput, TOutput extends SchemaInput = SchemaInput, TName extends string = string> {
     /**
      * Unique name of the tool (used by the model to call it).
      *
@@ -261,16 +270,16 @@ export interface Tool<TInput extends SchemaInput = z.ZodType, TOutput extends Sc
     /**
      * 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"),
@@ -278,7 +287,15 @@ export interface Tool<TInput extends SchemaInput = z.ZodType, TOutput extends Sc
      * })
      *
      * @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: {
@@ -292,15 +309,16 @@ export interface Tool<TInput extends SchemaInput = z.ZodType, TOutput extends Sc
     /**
      * 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(),
@@ -502,12 +520,13 @@ export interface TextOptions<TProviderOptionsSuperset extends Record<string, any
     modelOptions?: TProviderOptionsForModel;
     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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/ai",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "Core TanStack AI library - Open source AI SDK",
   "author": "Tanner Linsley",
   "license": "MIT",
@@ -46,13 +46,10 @@
     "@tanstack/devtools-event-client": "^0.4.0",
     "partial-json": "^0.1.7"
   },
-  "peerDependencies": {
-    "@alcyone-labs/zod-to-json-schema": "^4.0.0",
-    "zod": "^3.0.0 || ^4.0.0"
-  },
   "devDependencies": {
+    "@standard-schema/spec": "^1.1.0",
     "@vitest/coverage-v8": "4.0.14",
-    "zod": "^4.1.13"
+    "zod": "^4.2.0"
   },
   "scripts": {
     "build": "vite build",

package/src/activities/chat/index.ts

@@ -8,20 +8,25 @@
 import { aiEventClient } from '../../event-client.js'
 import { streamToText } from '../../stream-to-response.js'
 import { ToolCallManager, executeToolCalls } from './tools/tool-calls'
-import { convertZodToJsonSchema } from './tools/zod-converter'
+import {
+  convertSchemaToJsonSchema,
+  isStandardSchema,
+  parseWithStandardSchema,
+} from './tools/schema-converter'
 import { maxIterations as maxIterationsStrategy } from './agent-loop-strategies'
 import type {
   ApprovalRequest,
   ClientToolRequest,
   ToolResult,
 } from './tools/tool-calls'
-import type { z } from 'zod'
 import type { AnyTextAdapter } from './adapter'
 import type {
   AgentLoopStrategy,
   ConstrainedModelMessage,
   DoneStreamChunk,
+  InferSchemaType,
   ModelMessage,
+  SchemaInput,
   StreamChunk,
   TextOptions,
   Tool,
@@ -44,12 +49,12 @@ export const kind = 'text' as const
  * Types are extracted directly from the adapter (which has pre-resolved generics).
  *
  * @template TAdapter - The text adapter type (created by a provider function)
- * @template TSchema - Optional Zod schema for structured output
+ * @template TSchema - Optional Standard Schema for structured output
  * @template TStream - Whether to stream the output (default: true)
  */
 export interface TextActivityOptions<
   TAdapter extends AnyTextAdapter,
-  TSchema extends z.ZodType | undefined,
+  TSchema extends SchemaInput | undefined,
   TStream extends boolean,
 > {
   /** The text adapter to use (created by a provider function like openaiText('gpt-4o')) */
@@ -82,11 +87,13 @@ export interface TextActivityOptions<
   /** Unique conversation identifier for tracking */
   conversationId?: TextOptions['conversationId']
   /**
-   * Optional Zod schema for structured output.
+   * Optional Standard Schema for structured output.
    * When provided, the activity will:
    * 1. Run the full agentic loop (executing tools as needed)
    * 2. Once complete, return a Promise with the parsed output matching the schema
    *
+   * Supports any Standard Schema compliant library (Zod v4+, ArkType, Valibot, etc.)
+   *
    * @example
    * ```ts
    * const result = await chat({
@@ -104,7 +111,7 @@ export interface TextActivityOptions<
    * When false, returns a Promise<string> with the collected text content.
    *
    * Note: If outputSchema is provided, this option is ignored and the result
-   * is always a Promise<z.infer<TSchema>>.
+   * is always a Promise<InferSchemaType<TSchema>>.
    *
    * @default true
    *
@@ -140,7 +147,7 @@ export interface TextActivityOptions<
  */
 export function createChatOptions<
   TAdapter extends AnyTextAdapter,
-  TSchema extends z.ZodType | undefined = undefined,
+  TSchema extends SchemaInput | undefined = undefined,
   TStream extends boolean = true,
 >(
   options: TextActivityOptions<TAdapter, TSchema, TStream>,
@@ -154,15 +161,15 @@ export function createChatOptions<
 
 /**
  * Result type for the text activity.
- * - If outputSchema is provided: Promise<z.infer<TSchema>>
+ * - If outputSchema is provided: Promise<InferSchemaType<TSchema>>
  * - If stream is false: Promise<string>
  * - Otherwise (stream is true, default): AsyncIterable<StreamChunk>
  */
 export type TextActivityResult<
-  TSchema extends z.ZodType | undefined,
+  TSchema extends SchemaInput | undefined,
   TStream extends boolean = true,
-> = TSchema extends z.ZodType
-  ? Promise<z.infer<TSchema>>
+> = TSchema extends SchemaInput
+  ? Promise<InferSchemaType<TSchema>>
   : TStream extends false
     ? Promise<string>
     : AsyncIterable<StreamChunk>
@@ -366,14 +373,14 @@ class TextEngine<
     const { temperature, topP, maxTokens, metadata, modelOptions } = this.params
     const tools = this.params.tools
 
-    // Convert tool schemas from Zod to JSON Schema before passing to adapter
+    // Convert tool schemas to JSON Schema before passing to adapter
     const toolsWithJsonSchemas = tools?.map((tool) => ({
       ...tool,
       inputSchema: tool.inputSchema
-        ? convertZodToJsonSchema(tool.inputSchema)
+        ? convertSchemaToJsonSchema(tool.inputSchema)
         : undefined,
       outputSchema: tool.outputSchema
-        ? convertZodToJsonSchema(tool.outputSchema)
+        ? convertSchemaToJsonSchema(tool.outputSchema)
         : undefined,
     }))
 
@@ -968,7 +975,7 @@ class TextEngine<
  */
 export function chat<
   TAdapter extends AnyTextAdapter,
-  TSchema extends z.ZodType | undefined = undefined,
+  TSchema extends SchemaInput | undefined = undefined,
   TStream extends boolean = true,
 >(
   options: TextActivityOptions<TAdapter, TSchema, TStream>,
@@ -980,7 +987,7 @@ export function chat<
     return runAgenticStructuredOutput(
       options as unknown as TextActivityOptions<
         AnyTextAdapter,
-        z.ZodType,
+        SchemaInput,
         boolean
       >,
     ) as TextActivityResult<TSchema, TStream>
@@ -1046,9 +1053,9 @@ function runNonStreamingText(
  * 2. Once complete, call adapter.structuredOutput with the conversation context
  * 3. Validate and return the structured result
  */
-async function runAgenticStructuredOutput<TSchema extends z.ZodType>(
+async function runAgenticStructuredOutput<TSchema extends SchemaInput>(
   options: TextActivityOptions<AnyTextAdapter, TSchema, boolean>,
-): Promise<z.infer<TSchema>> {
+): Promise<InferSchemaType<TSchema>> {
   const { adapter, outputSchema, ...textOptions } = options
   const model = adapter.model
 
@@ -1060,8 +1067,8 @@ async function runAgenticStructuredOutput<TSchema extends z.ZodType>(
   const engine = new TextEngine({
     adapter,
     params: { ...textOptions, model } as TextOptions<
-      Record<string, any>,
-      Record<string, any>
+      Record<string, unknown>,
+      Record<string, unknown>
     >,
   })
 
@@ -1081,8 +1088,8 @@ async function runAgenticStructuredOutput<TSchema extends z.ZodType>(
     ...structuredTextOptions
   } = textOptions
 
-  // Convert the Zod schema to JSON Schema before passing to the adapter
-  const jsonSchema = convertZodToJsonSchema(outputSchema)
+  // Convert the schema to JSON Schema before passing to the adapter
+  const jsonSchema = convertSchemaToJsonSchema(outputSchema)
   if (!jsonSchema) {
     throw new Error('Failed to convert output schema to JSON Schema')
   }
@@ -1098,15 +1105,16 @@ async function runAgenticStructuredOutput<TSchema extends z.ZodType>(
     outputSchema: jsonSchema,
   })
 
-  // Validate the result against the Zod schema
-  const validationResult = outputSchema.safeParse(result.data)
-  if (!validationResult.success) {
-    throw new Error(
-      `Structured output validation failed: ${validationResult.error.message}`,
+  // Validate the result against the schema if it's a Standard Schema
+  if (isStandardSchema(outputSchema)) {
+    return parseWithStandardSchema<InferSchemaType<TSchema>>(
+      outputSchema,
+      result.data,
     )
   }
 
-  return validationResult.data
+  // For plain JSON Schema, return the data as-is
+  return result.data as InferSchemaType<TSchema>
 }
 
 // Re-export adapter types