@tanstack/ai 0.35.0 → 0.36.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/ai",
-  "version": "0.35.0",
+  "version": "0.36.0",
   "description": "Type-safe TypeScript AI SDK for streaming chat, tool calling, agents, structured outputs, and multimodal generation.",
   "author": "Tanner Linsley",
   "license": "MIT",
@@ -76,7 +76,7 @@
     "@ag-ui/core": "^0.0.52",
     "@standard-schema/spec": "^1.1.0",
     "partial-json": "^0.1.7",
-    "@tanstack/ai-event-client": "0.6.6",
+    "@tanstack/ai-event-client": "0.6.7",
     "@tanstack/ai-utils": "0.3.0"
   },
   "peerDependencies": {

package/skills/ai-core/tool-calling/SKILL.md

@@ -360,7 +360,7 @@ const compareProducts = compareProductsDef.server(async ({ productIds }) => {
 export async function POST(request: Request) {
   const { messages } = await request.json()
   const stream = chat({
-    adapter: openaiText('gpt-4o'),
+    adapter: openaiText('gpt-5.5'),
     messages,
     tools: [getProducts, compareProducts],
     agentLoopStrategy: maxIterations(20),
@@ -375,6 +375,31 @@ gets the full schema, then calls `compareProducts` directly.
 Once discovered, a tool stays available for the conversation.
 When all lazy tools are discovered, the discovery tool is removed automatically.
 
+### Tuning the lazy catalog with `lazyToolsConfig`
+
+By default the discovery-tool catalog lists only bare names (`'none'`). Pass
+`lazyToolsConfig` to `chat()` to include more context:
+
+```typescript
+const stream = chat({
+  adapter: openaiText('gpt-5.5'),
+  messages,
+  tools: [getProducts, compareProducts],
+  agentLoopStrategy: maxIterations(20),
+  lazyToolsConfig: { includeDescription: 'first-sentence' },
+})
+```
+
+`includeDescription` values:
+
+| Value              | Catalog entry                                                                            | When to use                                                                        |
+| ------------------ | ---------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------- |
+| `'none'` (default) | `compareProducts`                                                                        | Smallest prompt; model discovers by name                                           |
+| `'first-sentence'` | `compareProducts — Compare two or more products side by side.`                           | Helps the model decide whether to discover without extra tokens                    |
+| `'full'`           | `compareProducts — Compare two or more products side by side. Accepts productIds array.` | Use when descriptions are short or the model needs full context to route correctly |
+
+The post-discovery payload always returns the full description and schema regardless of this setting.
+
 ## MCP Tools
 
 `@tanstack/ai-mcp` lets a server-side `chat()` call discover and invoke tools

package/src/activities/chat/index.ts

@@ -47,6 +47,7 @@ import type {
   CustomEvent,
   InferSchemaType,
   JSONSchema,
+  LazyToolsConfig,
   ModelMessage,
   RunFinishedEvent,
   SchemaInput,
@@ -235,6 +236,12 @@ export interface TextActivityOptions<
   abortController?: TextOptions['abortController']
   /** Strategy for controlling the agent loop */
   agentLoopStrategy?: TextOptions['agentLoopStrategy']
+  /**
+   * Optional configuration for lazy-tool discovery (tools marked `lazy: true`).
+   * Tunes how much of each lazy tool's description appears in the discovery
+   * catalog. Optional — defaults to `{ includeDescription: 'none' }`.
+   */
+  lazyToolsConfig?: LazyToolsConfig
   /** Unique conversation identifier for tracking */
   conversationId?: TextOptions['conversationId']
   /** Thread/conversation ID for AG-UI protocol. Auto-generated if not provided. */
@@ -606,6 +613,7 @@ class TextEngine<
     this.lazyToolManager = new LazyToolManager(
       config.params.tools || [],
       this.messages,
+      config.params.lazyToolsConfig,
     )
     this.tools = this.lazyToolManager.getActiveTools()
     this.toolCallManager = new ToolCallManager<

package/src/activities/chat/tools/lazy-tool-manager.ts

@@ -1,5 +1,6 @@
 import { convertSchemaToJsonSchema } from './schema-converter'
-import type { AnyTool, Tool } from '../../../types'
+import { renderLazyCatalogEntry } from './lazy-tools'
+import type { AnyTool, LazyToolsConfig, Tool } from '../../../types'
 
 /**
  * Name of the synthetic tool the LLM calls to discover lazy tools.
@@ -23,6 +24,7 @@ export class LazyToolManager {
   private readonly discoveredTools: Set<string>
   private hasNewDiscoveries: boolean
   private readonly discoveryTool: Tool | null
+  private readonly lazyToolsConfig: LazyToolsConfig
 
   constructor(
     tools: ReadonlyArray<Tool>,
@@ -36,7 +38,9 @@ export class LazyToolManager {
       }>
       toolCallId?: string
     }>,
+    lazyToolsConfig: LazyToolsConfig = {},
   ) {
+    this.lazyToolsConfig = lazyToolsConfig
     const eager: Array<Tool> = []
     this.lazyToolMap = new Map()
     this.discoveredTools = new Set()
@@ -224,9 +228,13 @@ export class LazyToolManager {
 
     const lazyToolMap = this.lazyToolMap
 
-    // Build the static description with all lazy tool names
-    const allLazyNames = Array.from(this.lazyToolMap.keys())
-    const description = `You have access to additional tools that can be discovered. Available tools: [${allLazyNames.join(', ')}]. Call this tool with a list of tool names to discover their full descriptions and argument schemas before using them.`
+    // Build the static description, rendering each entry per includeDescription.
+    // With the default 'none' this is byte-identical to the legacy output.
+    const include = this.lazyToolsConfig.includeDescription ?? 'none'
+    const allLazyEntries = Array.from(this.lazyToolMap.values()).map((t) =>
+      renderLazyCatalogEntry(t.name, t.description, include),
+    )
+    const description = `You have access to additional tools that can be discovered. Available tools: [${allLazyEntries.join(', ')}]. Call this tool with a list of tool names to discover their full descriptions and argument schemas before using them.`
 
     // Use the arrow function to capture `this` context
     const manager = this

package/src/activities/chat/tools/lazy-tools.ts

@@ -0,0 +1,33 @@
+import type { LazyToolsConfig } from '../../../types'
+
+/**
+ * Extract the first sentence of a description (up to the first ., !, or ?
+ * followed by whitespace or end-of-string). Falls back to the whole trimmed
+ * string when there is no sentence terminator.
+ */
+export function firstSentence(text: string): string {
+  const trimmed = text.trim()
+  if (!trimmed) return ''
+  const match = trimmed.match(/^.*?[.!?](?=\s|$)/)
+  return (match ? match[0] : trimmed).trim()
+}
+
+/**
+ * Render one entry in a lazy-tool catalog according to `includeDescription`.
+ * - 'none' (default) → bare name (preserves legacy chat behavior)
+ * - 'first-sentence' → `name — <first sentence>`
+ * - 'full' → `name — <full description>`
+ * Falls back to the bare name when there is no description.
+ */
+export function renderLazyCatalogEntry(
+  name: string,
+  description: string,
+  includeDescription: LazyToolsConfig['includeDescription'] = 'none',
+): string {
+  if (includeDescription === 'none' || !description.trim()) return name
+  const desc =
+    includeDescription === 'first-sentence'
+      ? firstSentence(description)
+      : description.trim()
+  return desc ? `${name} — ${desc}` : name
+}

package/src/index.ts

@@ -154,6 +154,11 @@ export type {
 // All types
 export * from './types'
 
+export {
+  firstSentence,
+  renderLazyCatalogEntry,
+} from './activities/chat/tools/lazy-tools'
+
 // Usage utilities
 export { buildBaseUsage, type BaseUsageInput } from './utilities/usage'
 

package/src/types.ts

@@ -654,13 +654,29 @@ export interface Tool<
   /** If true, tool execution requires user approval before running. Works with both server and client tools. */
   needsApproval?: boolean
 
-  /** If true, this tool is lazy and will only be sent to the LLM after being discovered via the lazy tool discovery mechanism. Only meaningful when used with chat(). */
+  /** If true, this tool is lazy and will only be sent to the LLM after being discovered via the lazy tool discovery mechanism. Works with both chat() (the synthetic discovery tool) and Code Mode (kept out of the system prompt and revealed via discover_tools). */
   lazy?: boolean
 
   /** Additional metadata for adapters or custom extensions */
   metadata?: Record<string, any> | undefined
 }
 
+/**
+ * Configuration for the lazy-tool discovery catalog, shared by chat() and
+ * Code Mode. Optional in both — lazy behavior is triggered purely by tools
+ * marked `lazy: true`; this only tunes how much of each lazy tool's
+ * description appears in the pre-discovery catalog. The post-discovery payload
+ * always returns the full description + schema.
+ */
+export interface LazyToolsConfig {
+  /**
+   * How much of each lazy tool's description appears in the pre-discovery
+   * catalog (the names list shown before the model discovers the tool).
+   * @default 'none'
+   */
+  includeDescription?: 'full' | 'first-sentence' | 'none'
+}
+
 export type AnyTool = Omit<Tool<any, any, any, any>, 'execute'> & {
   execute?: ((args: any, context?: any) => any) | undefined
 }
@@ -819,6 +835,12 @@ export interface TextOptions<
    */
   systemPrompts?: Array<SystemPrompt>
   agentLoopStrategy?: AgentLoopStrategy
+  /**
+   * Optional configuration for lazy-tool discovery (tools marked `lazy: true`).
+   * Tunes how much of each lazy tool's description appears in the discovery
+   * catalog. Optional — defaults to `{ includeDescription: 'none' }`.
+   */
+  lazyToolsConfig?: LazyToolsConfig
   /**
    * Observability metadata attached to this call. Surfaced to middleware,
    * devtools, and the event client; values may be arbitrarily structured

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

@@ -1,163 +0,0 @@
-import { DefaultMessageMetadataByModality, JSONSchema, Modality, StreamChunk, TextOptions, TokenUsage } from '../../types.js';
-import { CapabilityHandle } from './middleware/capabilities.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.
- *
- * The internal logger is threaded through `chatOptions.logger` (inherited from
- * `TextOptions`). Adapter implementations must call `logger.request()` before
- * SDK calls, `logger.provider()` for each chunk received, and `logger.errors()`
- * in catch blocks.
- */
-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;
-    /** Token usage information (if provided by the adapter) */
-    usage?: TokenUsage;
-}
-/**
- * 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)
- * - TToolCapabilities: Tuple of tool-kind strings supported by this model, resolved from `supports.tools`
- * - TToolCallMetadata: Metadata type that round-trips with tool calls (e.g. Gemini's `thoughtSignature`)
- * - TSystemPromptMetadata: Provider-typed metadata accepted on each
- *   `systemPrompts[i]` entry (e.g. Anthropic `cache_control`). Defaults to
- *   `never` — adapters without per-prompt metadata reject the `metadata`
- *   field at the call site.
- */
-export interface TextAdapter<TModel extends string, TProviderOptions extends Record<string, any>, TInputModalities extends ReadonlyArray<Modality>, TMessageMetadataByModality extends DefaultMessageMetadataByModality, TToolCapabilities extends ReadonlyArray<string> = ReadonlyArray<string>, TToolCallMetadata = unknown, TSystemPromptMetadata = never> {
-    /** 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;
-    /**
-     * Capabilities this adapter requires at runtime. `chat()` validates that the
-     * configured middleware provides each one. Model adapters omit this; harness
-     * adapters (e.g. a future `claudeCode()`) declare e.g. `[sandboxCapability]`.
-     * Runtime access to capabilities from inside the adapter is not yet wired —
-     * this is the declaration/validation surface only.
-     */
-    readonly requires?: ReadonlyArray<CapabilityHandle>;
-    /**
-     * @internal Type-only properties for inference. Not assigned at runtime.
-     */
-    '~types': {
-        providerOptions: TProviderOptions;
-        inputModalities: TInputModalities;
-        messageMetadataByModality: TMessageMetadataByModality;
-        toolCapabilities: TToolCapabilities;
-        toolCallMetadata: TToolCallMetadata;
-        systemPromptMetadata: TSystemPromptMetadata;
-    };
-    /**
-     * 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>>;
-    /**
-     * Stream structured output using the provider's native streaming structured
-     * output API (stream + response_format json_schema in a single request).
-     *
-     * Optional — adapters without native streaming JSON omit this method and the
-     * activity layer synthesizes a stream around the non-streaming
-     * `structuredOutput` call.
-     *
-     * Implementations must emit standard AG-UI lifecycle events (RUN_STARTED,
-     * TEXT_MESSAGE_*, RUN_FINISHED) carrying raw JSON text deltas, plus a final
-     * `CUSTOM` event named `structured-output.complete` whose `value` is
-     * `{ object, raw, reasoning? }`.
-     */
-    structuredOutputStream?: (options: StructuredOutputOptions<TProviderOptions>) => AsyncIterable<StreamChunk>;
-    /**
-     * Declares whether the adapter supports combining `tools` and a
-     * schema-constrained final answer in a single streaming request.
-     *
-     * When `true`, the engine wires `outputSchema` into the regular
-     * `chatStream()` call and skips the separate `runStructuredFinalization`
-     * round-trip. The model's natural final turn carries the
-     * schema-constrained JSON text and the engine harvests it from the agent
-     * loop's accumulated content.
-     *
-     * When `false`, `undefined`, or the method is omitted, the engine runs
-     * the agent loop without `outputSchema` and then issues a separate
-     * `structuredOutput` / `structuredOutputStream` call against the JSON
-     * schema for finalization (the legacy path).
-     *
-     * The method receives the per-call `modelOptions` so providers whose
-     * support depends on the resolved upstream model (e.g. OpenRouter) can
-     * answer per-request. Most adapters can return a constant.
-     */
-    supportsCombinedToolsAndSchema?: (modelOptions?: TProviderOptions | undefined) => boolean;
-}
-/**
- * A TextAdapter with any/unknown type parameters.
- * Useful as a constraint in generic functions and interfaces.
- */
-export type AnyTextAdapter = TextAdapter<any, any, any, 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, TToolCapabilities extends ReadonlyArray<string> = ReadonlyArray<string>, TToolCallMetadata = unknown, TSystemPromptMetadata = never> implements TextAdapter<TModel, TProviderOptions, TInputModalities, TMessageMetadataByModality, TToolCapabilities, TToolCallMetadata, TSystemPromptMetadata> {
-    readonly kind: "text";
-    abstract readonly name: string;
-    readonly model: TModel;
-    readonly requires?: ReadonlyArray<CapabilityHandle>;
-    '~types': {
-        providerOptions: TProviderOptions;
-        inputModalities: TInputModalities;
-        messageMetadataByModality: TMessageMetadataByModality;
-        toolCapabilities: TToolCapabilities;
-        toolCallMetadata: TToolCallMetadata;
-        systemPromptMetadata: TSystemPromptMetadata;
-    };
-    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

@@ -1,17 +0,0 @@
-class BaseTextAdapter {
-  kind = "text";
-  model;
-  requires = void 0;
-  config;
-  constructor(config = {}, model) {
-    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

@@ -1 +0,0 @@
-{"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  TokenUsage,\n} from '../../types'\nimport type { CapabilityHandle } from './middleware/capabilities'\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 *\n * The internal logger is threaded through `chatOptions.logger` (inherited from\n * `TextOptions`). Adapter implementations must call `logger.request()` before\n * SDK calls, `logger.provider()` for each chunk received, and `logger.errors()`\n * in catch blocks.\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  /** Token usage information (if provided by the adapter) */\n  usage?: TokenUsage\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 * - TToolCapabilities: Tuple of tool-kind strings supported by this model, resolved from `supports.tools`\n * - TToolCallMetadata: Metadata type that round-trips with tool calls (e.g. Gemini's `thoughtSignature`)\n * - TSystemPromptMetadata: Provider-typed metadata accepted on each\n *   `systemPrompts[i]` entry (e.g. Anthropic `cache_control`). Defaults to\n *   `never` — adapters without per-prompt metadata reject the `metadata`\n *   field at the call site.\n */\nexport interface TextAdapter<\n  TModel extends string,\n  TProviderOptions extends Record<string, any>,\n  TInputModalities extends ReadonlyArray<Modality>,\n  TMessageMetadataByModality extends DefaultMessageMetadataByModality,\n  TToolCapabilities extends ReadonlyArray<string> = ReadonlyArray<string>,\n  TToolCallMetadata = unknown,\n  TSystemPromptMetadata = never,\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   * Capabilities this adapter requires at runtime. `chat()` validates that the\n   * configured middleware provides each one. Model adapters omit this; harness\n   * adapters (e.g. a future `claudeCode()`) declare e.g. `[sandboxCapability]`.\n   * Runtime access to capabilities from inside the adapter is not yet wired —\n   * this is the declaration/validation surface only.\n   */\n  readonly requires?: ReadonlyArray<CapabilityHandle>\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    toolCapabilities: TToolCapabilities\n    toolCallMetadata: TToolCallMetadata\n    systemPromptMetadata: TSystemPromptMetadata\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   * Stream structured output using the provider's native streaming structured\n   * output API (stream + response_format json_schema in a single request).\n   *\n   * Optional — adapters without native streaming JSON omit this method and the\n   * activity layer synthesizes a stream around the non-streaming\n   * `structuredOutput` call.\n   *\n   * Implementations must emit standard AG-UI lifecycle events (RUN_STARTED,\n   * TEXT_MESSAGE_*, RUN_FINISHED) carrying raw JSON text deltas, plus a final\n   * `CUSTOM` event named `structured-output.complete` whose `value` is\n   * `{ object, raw, reasoning? }`.\n   */\n  structuredOutputStream?: (\n    options: StructuredOutputOptions<TProviderOptions>,\n  ) => AsyncIterable<StreamChunk>\n\n  /**\n   * Declares whether the adapter supports combining `tools` and a\n   * schema-constrained final answer in a single streaming request.\n   *\n   * When `true`, the engine wires `outputSchema` into the regular\n   * `chatStream()` call and skips the separate `runStructuredFinalization`\n   * round-trip. The model's natural final turn carries the\n   * schema-constrained JSON text and the engine harvests it from the agent\n   * loop's accumulated content.\n   *\n   * When `false`, `undefined`, or the method is omitted, the engine runs\n   * the agent loop without `outputSchema` and then issues a separate\n   * `structuredOutput` / `structuredOutputStream` call against the JSON\n   * schema for finalization (the legacy path).\n   *\n   * The method receives the per-call `modelOptions` so providers whose\n   * support depends on the resolved upstream model (e.g. OpenRouter) can\n   * answer per-request. Most adapters can return a constant.\n   */\n  supportsCombinedToolsAndSchema?: (\n    modelOptions?: TProviderOptions | undefined,\n  ) => boolean\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, 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  TToolCapabilities extends ReadonlyArray<string> = ReadonlyArray<string>,\n  TToolCallMetadata = unknown,\n  TSystemPromptMetadata = never,\n> implements TextAdapter<\n  TModel,\n  TProviderOptions,\n  TInputModalities,\n  TMessageMetadataByModality,\n  TToolCapabilities,\n  TToolCallMetadata,\n  TSystemPromptMetadata\n> {\n  readonly kind = 'text' as const\n  abstract readonly name: string\n  readonly model: TModel\n  readonly requires?: ReadonlyArray<CapabilityHandle> = undefined\n\n  // Type-only property - never assigned at runtime\n  declare '~types': {\n    providerOptions: TProviderOptions\n    inputModalities: TInputModalities\n    messageMetadataByModality: TMessageMetadataByModality\n    toolCapabilities: TToolCapabilities\n    toolCallMetadata: TToolCallMetadata\n    systemPromptMetadata: TSystemPromptMetadata\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":"AA+KO,MAAe,gBAgBpB;AAAA,EACS,OAAO;AAAA,EAEP;AAAA,EACA,WAA6C;AAAA,EAY5C;AAAA,EAEV,YAAY,SAA4B,CAAA,GAAI,OAAe;AACzD,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/activities/chat/agent-loop-strategies.d.ts

@@ -1,59 +0,0 @@
-import { AgentLoopStrategy } from '../../types.js';
-/**
- * Creates a strategy that continues for a maximum number of iterations
- *
- * @param max - Maximum number of iterations to allow
- * @returns AgentLoopStrategy that stops after max iterations
- *
- * @example
- * ```typescript
- * const stream = chat({
- *   adapter: openaiText(),
- *   model: "gpt-4o",
- *   messages: [...],
- *   tools: [weatherTool],
- *   agentLoopStrategy: maxIterations(3), // Max 3 iterations
- * });
- * ```
- */
-export declare function maxIterations(max: number): AgentLoopStrategy;
-/**
- * Creates a strategy that continues until a specific finish reason is encountered
- *
- * @param stopReasons - Finish reasons that should stop the loop
- * @returns AgentLoopStrategy that stops on specific finish reasons
- *
- * @example
- * ```typescript
- * const stream = chat({
- *   adapter: openaiText(),
- *   model: "gpt-4o",
- *   messages: [...],
- *   tools: [weatherTool],
- *   agentLoopStrategy: untilFinishReason(["stop", "length"]),
- * });
- * ```
- */
-export declare function untilFinishReason(stopReasons: Array<string>): AgentLoopStrategy;
-/**
- * Creates a strategy that combines multiple strategies with AND logic
- * All strategies must return true to continue
- *
- * @param strategies - Array of strategies to combine
- * @returns AgentLoopStrategy that continues only if all strategies return true
- *
- * @example
- * ```typescript
- * const stream = chat({
- *   adapter: openaiText(),
- *   model: "gpt-4o",
- *   messages: [...],
- *   tools: [weatherTool],
- *   agentLoopStrategy: combineStrategies([
- *     maxIterations(10),
- *     ({ messages }) => messages.length < 100,
- *   ]),
- * });
- * ```
- */
-export declare function combineStrategies(strategies: Array<AgentLoopStrategy>): AgentLoopStrategy;

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

@@ -1,23 +0,0 @@
-function maxIterations(max) {
-  return ({ iterationCount }) => iterationCount < max;
-}
-function untilFinishReason(stopReasons) {
-  return ({ finishReason, iterationCount }) => {
-    if (iterationCount === 0) return true;
-    if (finishReason && stopReasons.includes(finishReason)) {
-      return false;
-    }
-    return true;
-  };
-}
-function combineStrategies(strategies) {
-  return (state) => {
-    return strategies.every((strategy) => strategy(state));
-  };
-}
-export {
-  combineStrategies,
-  maxIterations,
-  untilFinishReason
-};
-//# sourceMappingURL=agent-loop-strategies.js.map

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

@@ -1 +0,0 @@
-{"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;"}