@tanstack/ai 0.20.0 → 0.20.1

package/src/activities/chat/index.ts

@@ -95,14 +95,16 @@ export interface TextActivityOptions<
    *
    * The three shapes can be mixed in a single array (e.g., when forwarding a wire payload that includes both anchor UIMessages and AG-UI fan-out ModelMessages).
    */
-  messages?: Array<
-    | UIMessage
-    | ModelMessage
-    | ConstrainedModelMessage<{
-        inputModalities: TAdapter['~types']['inputModalities']
-        messageMetadataByModality: TAdapter['~types']['messageMetadataByModality']
-      }>
-  >
+  messages?:
+    | Array<
+        | UIMessage
+        | ModelMessage
+        | ConstrainedModelMessage<{
+            inputModalities: TAdapter['~types']['inputModalities']
+            messageMetadataByModality: TAdapter['~types']['messageMetadataByModality']
+          }>
+      >
+    | undefined
   /**
    * System prompts to prepend to the conversation.
    *
@@ -112,9 +114,9 @@ export interface TextActivityOptions<
    * caching), providers without per-prompt metadata reject the field
    * entirely.
    */
-  systemPrompts?: Array<
-    SystemPrompt<TAdapter['~types']['systemPromptMetadata']>
-  >
+  systemPrompts?:
+    | Array<SystemPrompt<TAdapter['~types']['systemPromptMetadata']>>
+    | undefined
   /**
    * Tools for function calling (auto-executed when called).
    *
@@ -125,10 +127,12 @@ export interface TextActivityOptions<
    *    `supports.tools` list. Passing an unsupported tool produces a
    *    compile-time error on the array element.
    */
-  tools?: Array<
-    | (Tool & { readonly '~toolKind'?: never })
-    | ProviderTool<string, TAdapter['~types']['toolCapabilities'][number]>
-  >
+  tools?:
+    | Array<
+        | (Tool & { readonly '~toolKind'?: never })
+        | ProviderTool<string, TAdapter['~types']['toolCapabilities'][number]>
+      >
+    | undefined
   /** 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. */
@@ -323,7 +327,7 @@ class TextEngine<
     []
   private currentThinkingContent = ''
   private currentThinkingSignature = ''
-  private eventOptions?: Record<string, unknown>
+  private eventOptions?: Record<string, unknown> | undefined
   private eventToolNames?: Array<string>
   private finishedEvent: RunFinishedEvent | null = null
   private earlyTermination = false
@@ -334,16 +338,16 @@ class TextEngine<
   private readonly initialClientToolResults: Map<string, any>
 
   // AG-UI protocol IDs
-  private threadId: string
-  private runIdOverride?: string
-  private parentRunIdOverride?: string
+  private readonly threadId: string
+  private readonly runIdOverride?: string
+  private readonly parentRunIdOverride?: string
 
   // Middleware support
   private readonly middlewareRunner: MiddlewareRunner
   private readonly middlewareCtx: ChatMiddlewareContext
   private readonly deferredPromises: Array<Promise<unknown>> = []
   private abortReason?: string
-  private middlewareAbortController?: AbortController
+  private readonly middlewareAbortController?: AbortController
   private terminalHookCalled = false
 
   private readonly logger: InternalLogger
@@ -402,8 +406,11 @@ class TextEngine<
     // handleStreamChunk processes raw chunks BEFORE middleware, so internal
     // state management sees extended fields (finishReason, delta, toolCallName, etc.).
     // The strip middleware ensures the yielded public stream is AG-UI spec-compliant.
-    const allMiddleware = [
-      devtoolsMiddleware(),
+    // `devtoolsMiddleware()` returns a structurally compatible
+    // `DevtoolsChatMiddleware` (defined in `@tanstack/ai-event-client` to
+    // avoid a circular dep). Cast it to `ChatMiddleware` for the runner.
+    const allMiddleware: Array<ChatMiddleware> = [
+      devtoolsMiddleware() as ChatMiddleware,
       ...(config.middleware || []),
       stripToSpecMiddleware(),
     ]
@@ -703,6 +710,7 @@ class TextEngine<
   }
 
   private handleStreamChunk(chunk: StreamChunk): void {
+    // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check -- AG-UI EventType enum members vs string-literal case labels; default branch handles untraced events.
     switch (chunk.type) {
       // AG-UI Events
       case 'TEXT_MESSAGE_CONTENT':
@@ -1001,11 +1009,10 @@ class TextEngine<
       return true
     })
 
-    if (undiscoveredLazyResults.length > 0) {
-      const finishEvt = this.finishedEvent!
+    if (undiscoveredLazyResults.length > 0 && this.finishedEvent) {
       for (const chunk of this.buildToolResultChunks(
         undiscoveredLazyResults,
-        finishEvt,
+        this.finishedEvent,
       )) {
         yield* this.pipeThroughMiddleware(chunk)
       }
@@ -1702,8 +1709,9 @@ async function* runStreamingText(
 function runNonStreamingText(
   options: TextActivityOptions<AnyTextAdapter, undefined, false>,
 ): Promise<string> {
-  // Run the streaming text and collect all text using streamToText
+  // Run the streaming text and collect all text using streamToText.
   const stream = runStreamingText(
+    // eslint-disable-next-line no-restricted-syntax -- generic-stream remap: caller is non-streaming (false), but runStreamingText is invoked internally to collect text; concrete `false`→`true` literals don't structurally overlap.
     options as unknown as TextActivityOptions<AnyTextAdapter, undefined, true>,
   )
 

package/src/activities/chat/messages.ts

@@ -463,12 +463,13 @@ export function modelMessagesToUIMessages(
     if (msg.role === 'tool') {
       // Tool result - merge into the last assistant message if possible
       if (
+        msg.toolCallId !== undefined &&
         currentAssistantMessage &&
         currentAssistantMessage.role === 'assistant'
       ) {
         currentAssistantMessage.parts.push({
           type: 'tool-result',
-          toolCallId: msg.toolCallId!,
+          toolCallId: msg.toolCallId,
           content: getTextContent(msg.content),
           state: 'complete',
         })

package/src/activities/chat/middleware/types.ts

@@ -79,9 +79,9 @@ export interface ChatMiddlewareContext {
   /** Names of configured tools, if any */
   toolNames?: Array<string>
   /** Flattened generation options (temperature, topP, maxTokens, metadata) */
-  options?: Record<string, unknown>
+  options?: Record<string, unknown> | undefined
   /** Provider-specific model options */
-  modelOptions?: Record<string, unknown>
+  modelOptions?: Record<string, unknown> | undefined
 
   // --- Computed info ---
 
@@ -121,8 +121,8 @@ export interface ChatMiddlewareConfig {
   temperature?: number
   topP?: number
   maxTokens?: number
-  metadata?: Record<string, unknown>
-  modelOptions?: Record<string, unknown>
+  metadata?: Record<string, unknown> | undefined
+  modelOptions?: Record<string, unknown> | undefined
 }
 
 // ===========================
@@ -257,11 +257,13 @@ export interface FinishInfo {
   /** Final accumulated text content */
   content: string
   /** Final usage totals, if available */
-  usage?: {
-    promptTokens: number
-    completionTokens: number
-    totalTokens: number
-  }
+  usage?:
+    | {
+        promptTokens: number
+        completionTokens: number
+        totalTokens: number
+      }
+    | undefined
 }
 
 /**

package/src/activities/chat/stream/processor.ts

@@ -133,25 +133,25 @@ export interface StreamProcessorOptions {
  * @see docs/chat-architecture.md#adapter-contract — What this class expects from adapters
  */
 export class StreamProcessor {
-  private chunkStrategy: ChunkStrategy
-  private events: StreamProcessorEvents
-  private jsonParser: { parse: (jsonString: string) => any }
+  private readonly chunkStrategy: ChunkStrategy
+  private readonly events: StreamProcessorEvents
+  private readonly jsonParser: { parse: (jsonString: string) => any }
   private recordingEnabled: boolean
 
   // Message state
   private messages: Array<UIMessage> = []
 
   // Per-message stream state
-  private messageStates: Map<string, MessageStreamState> = new Map()
-  private activeMessageIds: Set<string> = new Set()
-  private toolCallToMessage: Map<string, string> = new Map()
+  private readonly messageStates: Map<string, MessageStreamState> = new Map()
+  private readonly activeMessageIds: Set<string> = new Set()
+  private readonly toolCallToMessage: Map<string, string> = new Map()
   private pendingManualMessageId: string | null = null
   private pendingThinkingStepId: string | null = null
 
-  private structuredMessageIds: Set<string> = new Set()
+  private readonly structuredMessageIds: Set<string> = new Set()
 
   // Run tracking (for concurrent run safety)
-  private activeRuns = new Set<string>()
+  private readonly activeRuns = new Set<string>()
 
   // Shared stream state
   private finishReason: string | null = null
@@ -480,6 +480,7 @@ export class StreamProcessor {
     // Cast needed: @ag-ui/core Zod passthrough types add `& { [k: string]: unknown }`
     // which prevents TypeScript from narrowing the `type` discriminant in switch.
     const c = chunk as StreamChunk & { type: string }
+    // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check -- AG-UI EventType enum members vs string-literal case labels; default branch handles untraced events.
     switch (c.type) {
       // AG-UI Events
       case 'TEXT_MESSAGE_START':
@@ -645,10 +646,9 @@ export class StreamProcessor {
    * Used as fallback for events that don't include a messageId.
    */
   private getActiveAssistantMessageId(): string | null {
-    // Set iteration is insertion-order; convert to array and search from the end
-    const ids = Array.from(this.activeMessageIds)
-    for (let i = ids.length - 1; i >= 0; i--) {
-      const id = ids[i]!
+    // Set iteration is insertion-order; reverse-iterate to search from the end
+    const ids = Array.from(this.activeMessageIds).reverse()
+    for (const id of ids) {
       const state = this.messageStates.get(id)
       if (state && state.role === 'assistant') {
         return id
@@ -679,8 +679,8 @@ export class StreamProcessor {
     // Try active assistant message
     const activeId = this.getActiveAssistantMessageId()
     if (activeId) {
-      const state = this.getMessageState(activeId)!
-      return { messageId: activeId, state }
+      const state = this.getMessageState(activeId)
+      if (state) return { messageId: activeId, state }
     }
 
     // Check if a message with preferredId already exists (reconnect/resume case).
@@ -781,10 +781,10 @@ export class StreamProcessor {
     const existingMsg = this.messages.find((m) => m.id === messageId)
     if (existingMsg) {
       this.activeMessageIds.add(messageId)
-      if (!this.messageStates.has(messageId)) {
+      const existingState = this.messageStates.get(messageId)
+      if (!existingState) {
         this.createMessageState(messageId, uiRole)
       } else {
-        const existingState = this.messageStates.get(messageId)!
         // If tool calls happened since last text, this TEXT_MESSAGE_START
         // signals a new text segment — reset segment accumulation
         if (existingState.hasToolCallsSinceTextStart) {
@@ -845,7 +845,7 @@ export class StreamProcessor {
   ): void {
     this.resetStreamState()
     // AG-UI Message[] is compatible with UIMessage[] at runtime
-    this.messages = [...chunk.messages] as unknown as Array<UIMessage>
+    this.messages = [...chunk.messages] as Array<UIMessage>
     this.emitMessagesChange()
   }
 
@@ -1365,7 +1365,7 @@ export class StreamProcessor {
       state.currentThinkingStepId = stepId
     }
 
-    const previous = state.thinkingSteps.get(stepId)!
+    const previous = state.thinkingSteps.get(stepId) ?? ''
     let nextThinking = previous
 
     // Prefer delta over content
@@ -1900,7 +1900,7 @@ export function createReplayStream(
   recording: ChunkRecording,
 ): AsyncIterable<StreamChunk> {
   return {
-    // eslint-disable-next-line @typescript-eslint/require-await
+    // eslint-disable-next-line @typescript-eslint/require-await -- async generator required by AsyncIterable contract; body has no await
     async *[Symbol.asyncIterator]() {
       for (const { chunk } of recording.chunks) {
         yield chunk

package/src/activities/chat/stream/strategies.ts

@@ -20,7 +20,7 @@ export class ImmediateStrategy implements ChunkStrategy {
  * Useful for natural text flow in UI
  */
 export class PunctuationStrategy implements ChunkStrategy {
-  private punctuation = /[.,!?;:\n]/
+  private readonly punctuation = /[.,!?;:\n]/
 
   shouldEmit(chunk: string, _accumulated: string): boolean {
     return this.punctuation.test(chunk)
@@ -34,7 +34,7 @@ export class PunctuationStrategy implements ChunkStrategy {
 export class BatchStrategy implements ChunkStrategy {
   private chunkCount = 0
 
-  constructor(private batchSize: number = 5) {}
+  constructor(private readonly batchSize: number = 5) {}
 
   shouldEmit(_chunk: string, _accumulated: string): boolean {
     this.chunkCount++
@@ -66,7 +66,7 @@ export class WordBoundaryStrategy implements ChunkStrategy {
  * Emits if ANY strategy says to emit
  */
 export class CompositeStrategy implements ChunkStrategy {
-  constructor(private strategies: Array<ChunkStrategy>) {}
+  constructor(private readonly strategies: Array<ChunkStrategy>) {}
 
   shouldEmit(chunk: string, accumulated: string): boolean {
     return this.strategies.some((s) => s.shouldEmit(chunk, accumulated))

package/src/activities/chat/tools/schema-converter.ts

@@ -1,11 +1,29 @@
-/* eslint-disable @typescript-eslint/no-unnecessary-condition */
-
 import type {
   StandardJSONSchemaV1,
   StandardSchemaV1,
 } from '@standard-schema/spec'
 import type { JSONSchema, SchemaInput } from '../../../types'
 
+/**
+ * Build a JSONSchema object from any plain key/value source. The `JSONSchema`
+ * interface's `[key: string]: any` index signature makes every property
+ * assignable through bracket access without a type cast — copying keys here
+ * lets us narrow either `Record<string, unknown>` (returned by
+ * `~standard.jsonSchema.input()`) or a `JSONSchema` (from the SchemaInput
+ * pass-through arm) into the typed view used by the rest of this module.
+ *
+ * Accepts `object` so callers don't need a cast when narrowing from union
+ * types like `SchemaInput`.
+ */
+function toJsonSchema(obj: object): JSONSchema {
+  const result: JSONSchema = {}
+  for (const [key, value] of Object.entries(obj)) {
+    if (key === '$schema') continue // not needed by LLM providers
+    result[key] = value
+  }
+  return result
+}
+
 /**
  * Check if a value is a Standard JSON Schema compliant schema.
  * Standard JSON Schema compliant libraries (Zod v4+, ArkType, Valibot with toStandardJsonSchema, etc.)
@@ -19,6 +37,7 @@ export function isStandardJSONSchema(
     schema !== null &&
     '~standard' in schema &&
     typeof (schema as StandardJSONSchemaV1)['~standard'] === 'object' &&
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- runtime guard for caller-provided unknown; type assertion narrows but doesn't validate the wire payload
     (schema as StandardJSONSchemaV1)['~standard'].version === 1 &&
     typeof (schema as StandardJSONSchemaV1)['~standard'].jsonSchema ===
       'object' &&
@@ -37,9 +56,9 @@ export function isStandardSchema(schema: unknown): schema is StandardSchemaV1 {
     schema !== null &&
     '~standard' in schema &&
     typeof schema['~standard'] === 'object' &&
-    schema !== null &&
     schema['~standard'] !== null &&
     'version' in schema['~standard'] &&
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- runtime guard for caller-provided unknown; in-operator narrows but doesn't validate the wire payload
     schema['~standard'].version === 1 &&
     'validate' in schema['~standard'] &&
     typeof schema['~standard'].validate === 'function'
@@ -58,19 +77,20 @@ export function isStandardSchema(schema: unknown): schema is StandardSchemaV1 {
  * @returns Transformed schema compatible with OpenAI structured output
  */
 function makeStructuredOutputCompatible(
-  schema: Record<string, any>,
+  schema: JSONSchema,
   originalRequired: Array<string> = [],
-): Record<string, any> {
-  const result = { ...schema }
+): JSONSchema {
+  const result: JSONSchema = { ...schema }
 
   // Handle object types
   if (result.type === 'object' && result.properties) {
-    const properties = { ...result.properties }
+    const properties: Record<string, JSONSchema> = { ...result.properties }
     const allPropertyNames = Object.keys(properties)
 
     // Transform each property
     for (const propName of allPropertyNames) {
       const prop = properties[propName]
+      if (!prop) continue
       const wasOptional = !originalRequired.includes(propName)
 
       // Recursively transform nested objects/arrays
@@ -83,12 +103,12 @@ function makeStructuredOutputCompatible(
           ? { ...transformed, type: ['object', 'null'] }
           : transformed
       } else if (prop.type === 'array' && prop.items) {
-        const transformed = {
+        const items = Array.isArray(prop.items) ? prop.items[0] : prop.items
+        const transformed: JSONSchema = {
           ...prop,
-          items: makeStructuredOutputCompatible(
-            prop.items,
-            prop.items.required || [],
-          ),
+          items: items
+            ? makeStructuredOutputCompatible(items, items.required || [])
+            : prop.items,
         }
         properties[propName] = wasOptional
           ? { ...transformed, type: ['array', 'null'] }
@@ -118,10 +138,10 @@ function makeStructuredOutputCompatible(
 
   // Handle array types with object items
   if (result.type === 'array' && result.items) {
-    result.items = makeStructuredOutputCompatible(
-      result.items,
-      result.items.required || [],
-    )
+    const items = Array.isArray(result.items) ? result.items[0] : result.items
+    if (items) {
+      result.items = makeStructuredOutputCompatible(items, items.required || [])
+    }
   }
 
   return result
@@ -216,42 +236,33 @@ export function convertSchemaToJsonSchema(
       target: 'draft-07',
     })
 
-    let result = jsonSchema
-
-    if (typeof result === 'object' && '$schema' in result) {
-      // Remove $schema property as it's not needed for LLM providers
-      const { $schema, ...rest } = result
-      result = rest
-    }
+    // Rebuild structurally so the typed JSONSchema view is acquired without
+    // a `Record<string, unknown> as JSONSchema` cast; `toJsonSchema()` also
+    // drops the `$schema` key which LLM providers don't need.
+    let result: JSONSchema = toJsonSchema(jsonSchema)
 
     // Ensure object schemas always have type: "object"
+    // If it has properties (even empty), it should be an object type
+    if ('properties' in result && !result.type) {
+      result.type = 'object'
+    }
 
-    if (typeof result === 'object') {
-      // If it has properties (even empty), it should be an object type
-      if ('properties' in result && !result.type) {
-        result.type = 'object'
-      }
-
-      // Ensure properties exists for object types (even if empty)
-      if (result.type === 'object' && !('properties' in result)) {
-        result.properties = {}
-      }
+    // Ensure properties exists for object types (even if empty)
+    if (result.type === 'object' && !('properties' in result)) {
+      result.properties = {}
+    }
 
-      // Ensure required exists for object types (even if empty array)
-      if (result.type === 'object' && !('required' in result)) {
-        result.required = []
-      }
+    // Ensure required exists for object types (even if empty array)
+    if (result.type === 'object' && !('required' in result)) {
+      result.required = []
+    }
 
-      // Apply structured output transformation if requested
-      if (forStructuredOutput) {
-        result = makeStructuredOutputCompatible(
-          result,
-          (result.required as Array<string>) || [],
-        )
-      }
+    // Apply structured output transformation if requested
+    if (forStructuredOutput) {
+      result = makeStructuredOutputCompatible(result, result.required || [])
     }
 
-    return result as JSONSchema
+    return result
   }
 
   // Detect Standard Schema validators (Zod, ArkType, Valibot, …) that don't
@@ -271,14 +282,25 @@ export function convertSchemaToJsonSchema(
   // If it's not a Standard JSON Schema, assume it's already a JSONSchema and pass through
   // Still apply structured output transformation if requested
 
-  if (forStructuredOutput && typeof schema === 'object') {
-    return makeStructuredOutputCompatible(
-      schema as Record<string, any>,
-      ((schema as JSONSchema).required as Array<string>) || [],
-    ) as JSONSchema
+  // At this branch, `schema` is the plain `JSONSchema` arm of `SchemaInput`
+  // (the two `~standard` arms were handled above). When no transformation
+  // is requested we pass the schema through by reference to preserve
+  // identity for callers that compare via `===`.
+  if (typeof schema !== 'object') {
+    // The SchemaInput union is object-shaped on every arm; if we ever hit a
+    // non-object here, propagate it untouched and let the downstream
+    // provider error loudly rather than silently widen.
+    return schema
   }
 
-  return schema as JSONSchema
+  if (forStructuredOutput) {
+    // Build a typed view structurally so we don't need a SchemaInput→JSONSchema
+    // cast on the transformation path.
+    const typedView = toJsonSchema(schema)
+    return makeStructuredOutputCompatible(typedView, typedView.required || [])
+  }
+
+  return schema
 }
 
 /**
@@ -293,7 +315,10 @@ export async function validateWithStandardSchema<T>(
   data: unknown,
 ): Promise<
   | { success: true; data: T }
-  | { success: false; issues: Array<{ message: string; path?: Array<string> }> }
+  | {
+      success: false
+      issues: Array<{ message: string; path?: Array<string> | undefined }>
+    }
 > {
   if (!isStandardSchema(schema)) {
     // If it's not a Standard Schema, just return the data as-is

package/src/activities/chat/tools/tool-calls.ts

@@ -81,8 +81,8 @@ export class MiddlewareAbortError extends Error {
  * ```
  */
 export class ToolCallManager {
-  private toolCallsMap = new Map<number, ToolCall>()
-  private tools: ReadonlyArray<Tool>
+  private readonly toolCallsMap = new Map<number, ToolCall>()
+  private readonly tools: ReadonlyArray<Tool>
 
   constructor(tools: ReadonlyArray<Tool>) {
     this.tools = tools
@@ -320,14 +320,16 @@ async function* executeWithEventPolling<T>(
     ])
 
     // Flush any pending events
-    while (pendingEvents.length > 0) {
-      yield pendingEvents.shift()!
+    let event: CustomEvent | undefined
+    while ((event = pendingEvents.shift()) !== undefined) {
+      yield event
     }
   }
 
   // Final flush in case events were emitted right at completion
-  while (pendingEvents.length > 0) {
-    yield pendingEvents.shift()!
+  let event: CustomEvent | undefined
+  while ((event = pendingEvents.shift()) !== undefined) {
+    yield event
   }
 
   return state.result
@@ -404,13 +406,17 @@ async function* executeServerTool(
 ): AsyncGenerator<CustomEvent, void, void> {
   const startTime = Date.now()
   try {
-    const executionPromise = Promise.resolve(tool.execute!(input, context))
+    if (!tool.execute) {
+      throw new Error(`Tool ${toolName} has no execute() implementation`)
+    }
+    const executionPromise = Promise.resolve(tool.execute(input, context))
     let result = yield* executeWithEventPolling(executionPromise, pendingEvents)
     const duration = Date.now() - startTime
 
     // Flush remaining events
-    while (pendingEvents.length > 0) {
-      yield pendingEvents.shift()!
+    let pendingEvent: CustomEvent | undefined
+    while ((pendingEvent = pendingEvents.shift()) !== undefined) {
+      yield pendingEvent
     }
 
     // Validate output against outputSchema if provided
@@ -448,8 +454,9 @@ async function* executeServerTool(
     const duration = Date.now() - startTime
 
     // Flush remaining events
-    while (pendingEvents.length > 0) {
-      yield pendingEvents.shift()!
+    let pendingEvent: CustomEvent | undefined
+    while ((pendingEvent = pendingEvents.shift()) !== undefined) {
+      yield pendingEvent
     }
 
     if (error instanceof MiddlewareAbortError) {

package/src/activities/chat/tools/tool-definition.ts

@@ -29,6 +29,11 @@ export interface ClientTool<
   __toolSide: 'client'
   name: TName
   description: string
+  // Note: `inputSchema` / `outputSchema` stay as bare optionals (not
+  // widened to `| undefined`). They participate in inference via
+  // `InferToolInput` / `InferToolOutput` — widening with `| undefined`
+  // breaks the `infer TInput extends StandardJSONSchemaV1<...>` chain
+  // because `undefined` doesn't extend the schema constraint.
   inputSchema?: TInput
   outputSchema?: TOutput
   needsApproval?: boolean
@@ -215,7 +220,7 @@ export function toolDefinition<
       return {
         __toolSide: 'client',
         ...config,
-        execute,
+        ...(execute !== undefined && { execute }),
       }
     },
   }

package/src/activities/generateAudio/index.ts

@@ -27,10 +27,11 @@ export const kind = 'audio' as const
 /**
  * Extract provider options from an AudioAdapter via ~types.
  */
-export type AudioProviderOptions<TAdapter> =
-  TAdapter extends AudioAdapter<any, any>
-    ? TAdapter['~types']['providerOptions']
-    : object
+export type AudioProviderOptions<TAdapter> = TAdapter extends {
+  '~types': { providerOptions: infer P extends object }
+}
+  ? P
+  : object
 
 // ===========================
 // Activity Options Type

package/src/activities/generateImage/index.ts

@@ -227,6 +227,11 @@ async function runGenerateImage<
       requestId,
       provider: adapter.name,
       model,
+      // GeneratedImage is a discriminated `{ url } | { b64Json }` union, but the
+      // wire shape on the devtools event is a plain optional pair. Use
+      // conditional spreads so the emitted record only sets the field actually
+      // present — `exactOptionalPropertyTypes` rejects `field: undefined`
+      // against `field?: string` targets.
       images: result.images.map((image) => ({
         url: image.url,
         b64Json: image.b64Json,