@tanstack/ai 0.0.3 → 0.2.0

package/README.md

@@ -38,7 +38,9 @@
 A powerful, type-safe AI SDK for building AI-powered applications.
 
 - Provider-agnostic adapters (OpenAI, Anthropic, Gemini, Ollama, etc.)
+- **Tree-shakeable adapters** - Import only what you need for smaller bundles
 - **Multimodal content support** - Send images, audio, video, and documents
+- **Image generation** - Generate images with OpenAI DALL-E/GPT-Image and Gemini Imagen
 - Chat completion, streaming, and agent loop strategies
 - Headless chat state management with adapters (SSE, HTTP stream, custom)
 - Isomorphic type-safe tools with server/client execution
@@ -46,6 +48,30 @@ A powerful, type-safe AI SDK for building AI-powered applications.
 
 ### <a href="https://tanstack.com/ai">Read the docs →</b></a>
 
+## Tree-Shakeable Adapters
+
+Import only the functionality you need for smaller bundle sizes:
+
+```typescript
+// Only chat functionality - no summarization code bundled
+import { openaiText } from '@tanstack/ai-openai/adapters'
+import { generate } from '@tanstack/ai'
+
+const textAdapter = openaiText()
+
+const result = generate({
+  adapter: textAdapter,
+  model: 'gpt-4o',
+  messages: [{ role: 'user', content: [{ type: 'text', content: 'Hello!' }] }],
+})
+
+for await (const chunk of result) {
+  console.log(chunk)
+}
+```
+
+Available adapters: `openaiText`, `openaiEmbed`, `openaiSummarize`, `anthropicText`, `geminiText`, `ollamaText`, and more.
+
 ## Bonus: TanStack Start Integration
 
 TanStack AI works with **any** framework (Next.js, Express, Remix, etc.).

package/dist/esm/activities/chat/adapter.d.ts

@@ -0,0 +1,100 @@
+import { DefaultMessageMetadataByModality, JSONSchema, Modality, StreamChunk, TextOptions } from '../../types.js';
+/**
+ * Configuration for adapter instances
+ */
+export interface TextAdapterConfig {
+    apiKey?: string;
+    baseUrl?: string;
+    timeout?: number;
+    maxRetries?: number;
+    headers?: Record<string, string>;
+}
+/**
+ * Options for structured output generation
+ */
+export interface StructuredOutputOptions<TProviderOptions extends object> {
+    /** Text options for the request */
+    chatOptions: TextOptions<TProviderOptions>;
+    /** JSON Schema for structured output - already converted from Zod in the ai layer */
+    outputSchema: JSONSchema;
+}
+/**
+ * Result from structured output generation
+ */
+export interface StructuredOutputResult<T = unknown> {
+    /** The parsed data conforming to the schema */
+    data: T;
+    /** The raw text response from the model before parsing */
+    rawText: string;
+}
+/**
+ * Text adapter interface with pre-resolved generics.
+ *
+ * An adapter is created by a provider function: `provider('model')` → `adapter`
+ * All type resolution happens at the provider call site, not in this interface.
+ *
+ * Generic parameters:
+ * - TModel: The specific model name (e.g., 'gpt-4o')
+ * - TProviderOptions: Provider-specific options for this model (already resolved)
+ * - TInputModalities: Supported input modalities for this model (already resolved)
+ * - TMessageMetadata: Metadata types for content parts (already resolved)
+ */
+export interface TextAdapter<TModel extends string, TProviderOptions extends Record<string, any>, TInputModalities extends ReadonlyArray<Modality>, TMessageMetadataByModality extends DefaultMessageMetadataByModality> {
+    /** Discriminator for adapter kind */
+    readonly kind: 'text';
+    /** Provider name identifier (e.g., 'openai', 'anthropic') */
+    readonly name: string;
+    /** The model this adapter is configured for */
+    readonly model: TModel;
+    /**
+     * @internal Type-only properties for inference. Not assigned at runtime.
+     */
+    '~types': {
+        providerOptions: TProviderOptions;
+        inputModalities: TInputModalities;
+        messageMetadataByModality: TMessageMetadataByModality;
+    };
+    /**
+     * Stream text completions from the model
+     */
+    chatStream: (options: TextOptions<TProviderOptions>) => AsyncIterable<StreamChunk>;
+    /**
+     * Generate structured output using the provider's native structured output API.
+     * This method uses stream: false and sends the JSON schema to the provider
+     * to ensure the response conforms to the expected structure.
+     *
+     * @param options - Structured output options containing chat options and JSON schema
+     * @returns Promise with the raw data (validation is done in the chat function)
+     */
+    structuredOutput: (options: StructuredOutputOptions<TProviderOptions>) => Promise<StructuredOutputResult<unknown>>;
+}
+/**
+ * A TextAdapter with any/unknown type parameters.
+ * Useful as a constraint in generic functions and interfaces.
+ */
+export type AnyTextAdapter = TextAdapter<any, any, any, any>;
+/**
+ * Abstract base class for text adapters.
+ * Extend this class to implement a text adapter for a specific provider.
+ *
+ * Generic parameters match TextAdapter - all pre-resolved by the provider function.
+ */
+export declare abstract class BaseTextAdapter<TModel extends string, TProviderOptions extends Record<string, any>, TInputModalities extends ReadonlyArray<Modality>, TMessageMetadataByModality extends DefaultMessageMetadataByModality> implements TextAdapter<TModel, TProviderOptions, TInputModalities, TMessageMetadataByModality> {
+    readonly kind: "text";
+    abstract readonly name: string;
+    readonly model: TModel;
+    '~types': {
+        providerOptions: TProviderOptions;
+        inputModalities: TInputModalities;
+        messageMetadataByModality: TMessageMetadataByModality;
+    };
+    protected config: TextAdapterConfig;
+    constructor(config: TextAdapterConfig | undefined, model: TModel);
+    abstract chatStream(options: TextOptions<TProviderOptions>): AsyncIterable<StreamChunk>;
+    /**
+     * Generate structured output using the provider's native structured output API.
+     * Concrete implementations should override this to use provider-specific structured output.
+     */
+    abstract structuredOutput(options: StructuredOutputOptions<TProviderOptions>): Promise<StructuredOutputResult<unknown>>;
+    protected generateId(): string;
+}

package/dist/esm/activities/chat/adapter.js

@@ -0,0 +1,14 @@
+class BaseTextAdapter {
+  constructor(config = {}, model) {
+    this.kind = "text";
+    this.config = config;
+    this.model = model;
+  }
+  generateId() {
+    return `${this.name}-${Date.now()}-${Math.random().toString(36).substring(7)}`;
+  }
+}
+export {
+  BaseTextAdapter
+};
+//# sourceMappingURL=adapter.js.map

package/dist/esm/activities/chat/adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.js","sources":["../../../../src/activities/chat/adapter.ts"],"sourcesContent":["import type {\n  DefaultMessageMetadataByModality,\n  JSONSchema,\n  Modality,\n  StreamChunk,\n  TextOptions,\n} from '../../types'\n\n/**\n * Configuration for adapter instances\n */\nexport interface TextAdapterConfig {\n  apiKey?: string\n  baseUrl?: string\n  timeout?: number\n  maxRetries?: number\n  headers?: Record<string, string>\n}\n\n/**\n * Options for structured output generation\n */\nexport interface StructuredOutputOptions<TProviderOptions extends object> {\n  /** Text options for the request */\n  chatOptions: TextOptions<TProviderOptions>\n  /** JSON Schema for structured output - already converted from Zod in the ai layer */\n  outputSchema: JSONSchema\n}\n\n/**\n * Result from structured output generation\n */\nexport interface StructuredOutputResult<T = unknown> {\n  /** The parsed data conforming to the schema */\n  data: T\n  /** The raw text response from the model before parsing */\n  rawText: string\n}\n\n/**\n * Text adapter interface with pre-resolved generics.\n *\n * An adapter is created by a provider function: `provider('model')` → `adapter`\n * All type resolution happens at the provider call site, not in this interface.\n *\n * Generic parameters:\n * - TModel: The specific model name (e.g., 'gpt-4o')\n * - TProviderOptions: Provider-specific options for this model (already resolved)\n * - TInputModalities: Supported input modalities for this model (already resolved)\n * - TMessageMetadata: Metadata types for content parts (already resolved)\n */\nexport interface TextAdapter<\n  TModel extends string,\n  TProviderOptions extends Record<string, any>,\n  TInputModalities extends ReadonlyArray<Modality>,\n  TMessageMetadataByModality extends DefaultMessageMetadataByModality,\n> {\n  /** Discriminator for adapter kind */\n  readonly kind: 'text'\n  /** Provider name identifier (e.g., 'openai', 'anthropic') */\n  readonly name: string\n  /** The model this adapter is configured for */\n  readonly model: TModel\n\n  /**\n   * @internal Type-only properties for inference. Not assigned at runtime.\n   */\n  '~types': {\n    providerOptions: TProviderOptions\n    inputModalities: TInputModalities\n    messageMetadataByModality: TMessageMetadataByModality\n  }\n\n  /**\n   * Stream text completions from the model\n   */\n  chatStream: (\n    options: TextOptions<TProviderOptions>,\n  ) => AsyncIterable<StreamChunk>\n\n  /**\n   * Generate structured output using the provider's native structured output API.\n   * This method uses stream: false and sends the JSON schema to the provider\n   * to ensure the response conforms to the expected structure.\n   *\n   * @param options - Structured output options containing chat options and JSON schema\n   * @returns Promise with the raw data (validation is done in the chat function)\n   */\n  structuredOutput: (\n    options: StructuredOutputOptions<TProviderOptions>,\n  ) => Promise<StructuredOutputResult<unknown>>\n}\n\n/**\n * A TextAdapter with any/unknown type parameters.\n * Useful as a constraint in generic functions and interfaces.\n */\nexport type AnyTextAdapter = TextAdapter<any, any, any, any>\n\n/**\n * Abstract base class for text adapters.\n * Extend this class to implement a text adapter for a specific provider.\n *\n * Generic parameters match TextAdapter - all pre-resolved by the provider function.\n */\nexport abstract class BaseTextAdapter<\n  TModel extends string,\n  TProviderOptions extends Record<string, any>,\n  TInputModalities extends ReadonlyArray<Modality>,\n  TMessageMetadataByModality extends DefaultMessageMetadataByModality,\n> implements TextAdapter<\n  TModel,\n  TProviderOptions,\n  TInputModalities,\n  TMessageMetadataByModality\n> {\n  readonly kind = 'text' as const\n  abstract readonly name: string\n  readonly model: TModel\n\n  // Type-only property - never assigned at runtime\n  declare '~types': {\n    providerOptions: TProviderOptions\n    inputModalities: TInputModalities\n    messageMetadataByModality: TMessageMetadataByModality\n  }\n\n  protected config: TextAdapterConfig\n\n  constructor(config: TextAdapterConfig = {}, model: TModel) {\n    this.config = config\n    this.model = model\n  }\n\n  abstract chatStream(\n    options: TextOptions<TProviderOptions>,\n  ): AsyncIterable<StreamChunk>\n\n  /**\n   * Generate structured output using the provider's native structured output API.\n   * Concrete implementations should override this to use provider-specific structured output.\n   */\n  abstract structuredOutput(\n    options: StructuredOutputOptions<TProviderOptions>,\n  ): Promise<StructuredOutputResult<unknown>>\n\n  protected generateId(): string {\n    return `${this.name}-${Date.now()}-${Math.random().toString(36).substring(7)}`\n  }\n}\n"],"names":[],"mappings":"AAyGO,MAAe,gBAUpB;AAAA,EAcA,YAAY,SAA4B,CAAA,GAAI,OAAe;AAb3D,SAAS,OAAO;AAcd,SAAK,SAAS;AACd,SAAK,QAAQ;AAAA,EACf;AAAA,EAcU,aAAqB;AAC7B,WAAO,GAAG,KAAK,IAAI,IAAI,KAAK,KAAK,IAAI,KAAK,OAAA,EAAS,SAAS,EAAE,EAAE,UAAU,CAAC,CAAC;AAAA,EAC9E;AACF;"}

package/dist/esm/{utilities → activities/chat}/agent-loop-strategies.d.ts

@@ -1,4 +1,4 @@
-import { AgentLoopStrategy } from '../types.js';
+import { AgentLoopStrategy } from '../../types.js';
 /**
  * Creates a strategy that continues for a maximum number of iterations
  *
@@ -8,7 +8,7 @@ import { AgentLoopStrategy } from '../types.js';
  * @example
  * ```typescript
  * const stream = chat({
- *   adapter: openai(),
+ *   adapter: openaiText(),
  *   model: "gpt-4o",
  *   messages: [...],
  *   tools: [weatherTool],
@@ -26,7 +26,7 @@ export declare function maxIterations(max: number): AgentLoopStrategy;
  * @example
  * ```typescript
  * const stream = chat({
- *   adapter: openai(),
+ *   adapter: openaiText(),
  *   model: "gpt-4o",
  *   messages: [...],
  *   tools: [weatherTool],
@@ -45,7 +45,7 @@ export declare function untilFinishReason(stopReasons: Array<string>): AgentLoop
  * @example
  * ```typescript
  * const stream = chat({
- *   adapter: openai(),
+ *   adapter: openaiText(),
  *   model: "gpt-4o",
  *   messages: [...],
  *   tools: [weatherTool],

package/dist/esm/activities/chat/agent-loop-strategies.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-loop-strategies.js","sources":["../../../../src/activities/chat/agent-loop-strategies.ts"],"sourcesContent":["import type { AgentLoopStrategy } from '../../types'\n\n/**\n * Creates a strategy that continues for a maximum number of iterations\n *\n * @param max - Maximum number of iterations to allow\n * @returns AgentLoopStrategy that stops after max iterations\n *\n * @example\n * ```typescript\n * const stream = chat({\n *   adapter: openaiText(),\n *   model: \"gpt-4o\",\n *   messages: [...],\n *   tools: [weatherTool],\n *   agentLoopStrategy: maxIterations(3), // Max 3 iterations\n * });\n * ```\n */\nexport function maxIterations(max: number): AgentLoopStrategy {\n  return ({ iterationCount }) => iterationCount < max\n}\n\n/**\n * Creates a strategy that continues until a specific finish reason is encountered\n *\n * @param stopReasons - Finish reasons that should stop the loop\n * @returns AgentLoopStrategy that stops on specific finish reasons\n *\n * @example\n * ```typescript\n * const stream = chat({\n *   adapter: openaiText(),\n *   model: \"gpt-4o\",\n *   messages: [...],\n *   tools: [weatherTool],\n *   agentLoopStrategy: untilFinishReason([\"stop\", \"length\"]),\n * });\n * ```\n */\nexport function untilFinishReason(\n  stopReasons: Array<string>,\n): AgentLoopStrategy {\n  return ({ finishReason, iterationCount }) => {\n    // Always allow at least one iteration\n    if (iterationCount === 0) return true\n\n    // Stop if we hit a stop reason\n    if (finishReason && stopReasons.includes(finishReason)) {\n      return false\n    }\n\n    // Otherwise continue\n    return true\n  }\n}\n\n/**\n * Creates a strategy that combines multiple strategies with AND logic\n * All strategies must return true to continue\n *\n * @param strategies - Array of strategies to combine\n * @returns AgentLoopStrategy that continues only if all strategies return true\n *\n * @example\n * ```typescript\n * const stream = chat({\n *   adapter: openaiText(),\n *   model: \"gpt-4o\",\n *   messages: [...],\n *   tools: [weatherTool],\n *   agentLoopStrategy: combineStrategies([\n *     maxIterations(10),\n *     ({ messages }) => messages.length < 100,\n *   ]),\n * });\n * ```\n */\nexport function combineStrategies(\n  strategies: Array<AgentLoopStrategy>,\n): AgentLoopStrategy {\n  return (state) => {\n    return strategies.every((strategy) => strategy(state))\n  }\n}\n"],"names":[],"mappings":"AAmBO,SAAS,cAAc,KAAgC;AAC5D,SAAO,CAAC,EAAE,qBAAqB,iBAAiB;AAClD;AAmBO,SAAS,kBACd,aACmB;AACnB,SAAO,CAAC,EAAE,cAAc,qBAAqB;AAE3C,QAAI,mBAAmB,EAAG,QAAO;AAGjC,QAAI,gBAAgB,YAAY,SAAS,YAAY,GAAG;AACtD,aAAO;AAAA,IACT;AAGA,WAAO;AAAA,EACT;AACF;AAuBO,SAAS,kBACd,YACmB;AACnB,SAAO,CAAC,UAAU;AAChB,WAAO,WAAW,MAAM,CAAC,aAAa,SAAS,KAAK,CAAC;AAAA,EACvD;AACF;"}

package/dist/esm/activities/chat/index.d.ts

@@ -0,0 +1,166 @@
+import { AnyTextAdapter } from './adapter.js';
+import { ConstrainedModelMessage, InferSchemaType, SchemaInput, StreamChunk, TextOptions } from '../../types.js';
+/** The adapter kind this activity handles */
+export declare const kind: "text";
+/**
+ * Options for the text activity.
+ * 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 Standard Schema for structured output
+ * @template TStream - Whether to stream the output (default: true)
+ */
+export interface TextActivityOptions<TAdapter extends AnyTextAdapter, TSchema extends SchemaInput | undefined, TStream extends boolean> {
+    /** The text adapter to use (created by a provider function like openaiText('gpt-4o')) */
+    adapter: TAdapter;
+    /** Conversation messages - content types are constrained by the adapter's input modalities and metadata */
+    messages?: Array<ConstrainedModelMessage<{
+        inputModalities: TAdapter['~types']['inputModalities'];
+        messageMetadataByModality: TAdapter['~types']['messageMetadataByModality'];
+    }>>;
+    /** System prompts to prepend to the conversation */
+    systemPrompts?: TextOptions['systemPrompts'];
+    /** Tools for function calling (auto-executed when called) */
+    tools?: TextOptions['tools'];
+    /** Controls the randomness of the output. Higher values make output more random. Range: [0.0, 2.0] */
+    temperature?: TextOptions['temperature'];
+    /** Nucleus sampling parameter. The model considers tokens with topP probability mass. */
+    topP?: TextOptions['topP'];
+    /** The maximum number of tokens to generate in the response. */
+    maxTokens?: TextOptions['maxTokens'];
+    /** Additional metadata to attach to the request. */
+    metadata?: TextOptions['metadata'];
+    /** Model-specific provider options (type comes from adapter) */
+    modelOptions?: TAdapter['~types']['providerOptions'];
+    /** AbortController for cancellation */
+    abortController?: TextOptions['abortController'];
+    /** Strategy for controlling the agent loop */
+    agentLoopStrategy?: TextOptions['agentLoopStrategy'];
+    /** Unique conversation identifier for tracking */
+    conversationId?: TextOptions['conversationId'];
+    /**
+     * 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({
+     *   adapter: openaiText('gpt-4o'),
+     *   messages: [{ role: 'user', content: 'Generate a person' }],
+     *   outputSchema: z.object({ name: z.string(), age: z.number() })
+     * })
+     * // result is { name: string, age: number }
+     * ```
+     */
+    outputSchema?: TSchema;
+    /**
+     * Whether to stream the text result.
+     * When true (default), returns an AsyncIterable<StreamChunk> for streaming output.
+     * 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<InferSchemaType<TSchema>>.
+     *
+     * @default true
+     *
+     * @example Non-streaming text
+     * ```ts
+     * const text = await chat({
+     *   adapter: openaiText('gpt-4o'),
+     *   messages: [{ role: 'user', content: 'Hello!' }],
+     *   stream: false
+     * })
+     * // text is a string with the full response
+     * ```
+     */
+    stream?: TStream;
+}
+/**
+ * Create typed options for the chat() function without executing.
+ * This is useful for pre-defining configurations with full type inference.
+ *
+ * @example
+ * ```ts
+ * const chatOptions = createChatOptions({
+ *   adapter: anthropicText('claude-sonnet-4-5'),
+ * })
+ *
+ * const stream = chat({ ...chatOptions, messages })
+ * ```
+ */
+export declare function createChatOptions<TAdapter extends AnyTextAdapter, TSchema extends SchemaInput | undefined = undefined, TStream extends boolean = true>(options: TextActivityOptions<TAdapter, TSchema, TStream>): TextActivityOptions<TAdapter, TSchema, TStream>;
+/**
+ * Result type for the text activity.
+ * - 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 SchemaInput | undefined, TStream extends boolean = true> = TSchema extends SchemaInput ? Promise<InferSchemaType<TSchema>> : TStream extends false ? Promise<string> : AsyncIterable<StreamChunk>;
+/**
+ * Text activity - handles agentic text generation, one-shot text generation, and agentic structured output.
+ *
+ * This activity supports four modes:
+ * 1. **Streaming agentic text**: Stream responses with automatic tool execution
+ * 2. **Streaming one-shot text**: Simple streaming request/response without tools
+ * 3. **Non-streaming text**: Returns collected text as a string (stream: false)
+ * 4. **Agentic structured output**: Run tools, then return structured data
+ *
+ * @example Full agentic text (streaming with tools)
+ * ```ts
+ * import { chat } from '@tanstack/ai'
+ * import { openaiText } from '@tanstack/ai-openai'
+ *
+ * for await (const chunk of chat({
+ *   adapter: openaiText('gpt-4o'),
+ *   messages: [{ role: 'user', content: 'What is the weather?' }],
+ *   tools: [weatherTool]
+ * })) {
+ *   if (chunk.type === 'content') {
+ *     console.log(chunk.delta)
+ *   }
+ * }
+ * ```
+ *
+ * @example One-shot text (streaming without tools)
+ * ```ts
+ * for await (const chunk of chat({
+ *   adapter: openaiText('gpt-4o'),
+ *   messages: [{ role: 'user', content: 'Hello!' }]
+ * })) {
+ *   console.log(chunk)
+ * }
+ * ```
+ *
+ * @example Non-streaming text (stream: false)
+ * ```ts
+ * const text = await chat({
+ *   adapter: openaiText('gpt-4o'),
+ *   messages: [{ role: 'user', content: 'Hello!' }],
+ *   stream: false
+ * })
+ * // text is a string with the full response
+ * ```
+ *
+ * @example Agentic structured output (tools + structured response)
+ * ```ts
+ * import { z } from 'zod'
+ *
+ * const result = await chat({
+ *   adapter: openaiText('gpt-4o'),
+ *   messages: [{ role: 'user', content: 'Research and summarize the topic' }],
+ *   tools: [researchTool, analyzeTool],
+ *   outputSchema: z.object({
+ *     summary: z.string(),
+ *     keyPoints: z.array(z.string())
+ *   })
+ * })
+ * // result is { summary: string, keyPoints: string[] }
+ * ```
+ */
+export declare function chat<TAdapter extends AnyTextAdapter, TSchema extends SchemaInput | undefined = undefined, TStream extends boolean = true>(options: TextActivityOptions<TAdapter, TSchema, TStream>): TextActivityResult<TSchema, TStream>;
+export type { TextAdapter, TextAdapterConfig, StructuredOutputOptions, StructuredOutputResult, } from './adapter.js';
+export { BaseTextAdapter } from './adapter.js';

package/dist/esm/{core/chat.js → activities/chat/index.js}

@@ -1,7 +1,13 @@
-import { aiEventClient } from "../event-client.js";
-import { ToolCallManager, executeToolCalls } from "../tools/tool-calls.js";
-import { maxIterations } from "../utilities/agent-loop-strategies.js";
-class ChatEngine {
+import { aiEventClient } from "../../event-client.js";
+import { streamToText } from "../../stream-to-response.js";
+import { ToolCallManager, executeToolCalls } from "./tools/tool-calls.js";
+import { convertSchemaToJsonSchema, isStandardSchema, parseWithStandardSchema } from "./tools/schema-converter.js";
+import { maxIterations } from "./agent-loop-strategies.js";
+const kind = "text";
+function createChatOptions(options) {
+  return options;
+}
+class TextEngine {
   constructor(config) {
     this.iterationCount = 0;
     this.lastFinishReason = null;
@@ -13,7 +19,7 @@ class ChatEngine {
     this.shouldEmitStreamEnd = true;
     this.earlyTermination = false;
     this.toolPhase = "continue";
-    this.cyclePhase = "processChat";
+    this.cyclePhase = "processText";
     this.adapter = config.adapter;
     this.params = config.params;
     this.systemPrompts = config.params.systemPrompts || [];
@@ -27,8 +33,16 @@ class ChatEngine {
     this.effectiveRequest = config.params.abortController ? { signal: config.params.abortController.signal } : void 0;
     this.effectiveSignal = config.params.abortController?.signal;
   }
-  async *chat() {
-    this.beforeChat();
+  /** Get the accumulated content after the chat loop completes */
+  getAccumulatedContent() {
+    return this.accumulatedContent;
+  }
+  /** Get the final messages array after the chat loop completes */
+  getMessages() {
+    return this.messages;
+  }
+  async *run() {
+    this.beforeRun();
     try {
       const pendingPhase = yield* this.checkForPendingToolCalls();
       if (pendingPhase === "wait") {
@@ -39,7 +53,7 @@ class ChatEngine {
           return;
         }
         this.beginCycle();
-        if (this.cyclePhase === "processChat") {
+        if (this.cyclePhase === "processText") {
           yield* this.streamModelResponse();
         } else {
           yield* this.processToolCalls();
@@ -47,13 +61,27 @@ class ChatEngine {
         this.endCycle();
       } while (this.shouldContinue());
     } finally {
-      this.afterChat();
+      this.afterRun();
     }
   }
-  beforeChat() {
+  beforeRun() {
     this.streamStartTime = Date.now();
-    const { model, tools, options, providerOptions, conversationId } = this.params;
-    aiEventClient.emit("chat:started", {
+    const {
+      model,
+      tools,
+      temperature,
+      topP,
+      maxTokens,
+      metadata,
+      modelOptions,
+      conversationId
+    } = this.params;
+    const options = {};
+    if (temperature !== void 0) options.temperature = temperature;
+    if (topP !== void 0) options.topP = topP;
+    if (maxTokens !== void 0) options.maxTokens = maxTokens;
+    if (metadata !== void 0) options.metadata = metadata;
+    aiEventClient.emit("text:started", {
       requestId: this.requestId,
       streamId: this.streamId,
       model,
@@ -64,8 +92,8 @@ class ChatEngine {
       timestamp: Date.now(),
       clientId: conversationId,
       toolNames: tools?.map((t) => t.name),
-      options,
-      providerOptions
+      options: Object.keys(options).length > 0 ? options : void 0,
+      modelOptions
     });
     aiEventClient.emit("stream:started", {
       streamId: this.streamId,
@@ -74,12 +102,12 @@ class ChatEngine {
       timestamp: Date.now()
     });
   }
-  afterChat() {
+  afterRun() {
     if (!this.shouldEmitStreamEnd) {
       return;
     }
     const now = Date.now();
-    aiEventClient.emit("chat:completed", {
+    aiEventClient.emit("text:completed", {
       requestId: this.requestId,
       streamId: this.streamId,
       model: this.params.model,
@@ -98,16 +126,16 @@ class ChatEngine {
     });
   }
   beginCycle() {
-    if (this.cyclePhase === "processChat") {
+    if (this.cyclePhase === "processText") {
       this.beginIteration();
     }
   }
   endCycle() {
-    if (this.cyclePhase === "processChat") {
+    if (this.cyclePhase === "processText") {
       this.cyclePhase = "executeToolCalls";
       return;
     }
-    this.cyclePhase = "processChat";
+    this.cyclePhase = "processText";
     this.iterationCount++;
   }
   beginIteration() {
@@ -116,16 +144,23 @@ class ChatEngine {
     this.doneChunk = null;
   }
   async *streamModelResponse() {
-    const adapterOptions = this.params.options || {};
-    const providerOptions = this.params.providerOptions;
+    const { temperature, topP, maxTokens, metadata, modelOptions } = this.params;
     const tools = this.params.tools;
+    const toolsWithJsonSchemas = tools?.map((tool) => ({
+      ...tool,
+      inputSchema: tool.inputSchema ? convertSchemaToJsonSchema(tool.inputSchema) : void 0,
+      outputSchema: tool.outputSchema ? convertSchemaToJsonSchema(tool.outputSchema) : void 0
+    }));
     for await (const chunk of this.adapter.chatStream({
       model: this.params.model,
       messages: this.messages,
-      tools,
-      options: adapterOptions,
+      tools: toolsWithJsonSchemas,
+      temperature,
+      topP,
+      maxTokens,
+      metadata,
       request: this.effectiveRequest,
-      providerOptions,
+      modelOptions,
       systemPrompts: this.systemPrompts
     })) {
       if (this.isAborted()) {
@@ -259,7 +294,7 @@ class ChatEngine {
       return "continue";
     }
     const doneChunk = this.createSyntheticDoneChunk();
-    aiEventClient.emit("chat:iteration", {
+    aiEventClient.emit("text:iteration", {
       requestId: this.requestId,
       streamId: this.streamId,
       iterationNumber: this.iterationCount + 1,
@@ -310,7 +345,7 @@ class ChatEngine {
       this.setToolPhase("stop");
       return;
     }
-    aiEventClient.emit("chat:iteration", {
+    aiEventClient.emit("text:iteration", {
       requestId: this.requestId,
       streamId: this.streamId,
       iterationNumber: this.iterationCount + 1,
@@ -517,17 +552,80 @@ class ChatEngine {
     return `${prefix}-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
   }
 }
-async function* chat(options) {
-  const { adapter, ...chatOptions } = options;
-  const engine = new ChatEngine({
+function chat(options) {
+  const { outputSchema, stream } = options;
+  if (outputSchema) {
+    return runAgenticStructuredOutput(
+      options
+    );
+  }
+  if (stream === false) {
+    return runNonStreamingText(
+      options
+    );
+  }
+  return runStreamingText(
+    options
+  );
+}
+async function* runStreamingText(options) {
+  const { adapter, ...textOptions } = options;
+  const model = adapter.model;
+  const engine = new TextEngine({
     adapter,
-    params: chatOptions
+    params: { ...textOptions, model }
   });
-  for await (const chunk of engine.chat()) {
+  for await (const chunk of engine.run()) {
     yield chunk;
   }
 }
+function runNonStreamingText(options) {
+  const stream = runStreamingText(
+    options
+  );
+  return streamToText(stream);
+}
+async function runAgenticStructuredOutput(options) {
+  const { adapter, outputSchema, ...textOptions } = options;
+  const model = adapter.model;
+  if (!outputSchema) {
+    throw new Error("outputSchema is required for structured output");
+  }
+  const engine = new TextEngine({
+    adapter,
+    params: { ...textOptions, model }
+  });
+  for await (const _chunk of engine.run()) {
+  }
+  const finalMessages = engine.getMessages();
+  const {
+    tools: _tools,
+    agentLoopStrategy: _als,
+    ...structuredTextOptions
+  } = textOptions;
+  const jsonSchema = convertSchemaToJsonSchema(outputSchema);
+  if (!jsonSchema) {
+    throw new Error("Failed to convert output schema to JSON Schema");
+  }
+  const result = await adapter.structuredOutput({
+    chatOptions: {
+      ...structuredTextOptions,
+      model,
+      messages: finalMessages
+    },
+    outputSchema: jsonSchema
+  });
+  if (isStandardSchema(outputSchema)) {
+    return parseWithStandardSchema(
+      outputSchema,
+      result.data
+    );
+  }
+  return result.data;
+}
 export {
-  chat
+  chat,
+  createChatOptions,
+  kind
 };
-//# sourceMappingURL=chat.js.map
+//# sourceMappingURL=index.js.map