packages/typescript/ai-openai/package.json (1)

43-52:Verify dual listing of @tanstack/ai in both dependencies and peerDependencies.

Similar to the Anthropic adapter package, this package lists@tanstack/ai in bothdependencies (line 43) andpeerDependencies (line 51). Clarify whether this dual listing is intentional or if@tanstack/ai should be exclusively in one section.

packages/typescript/ai-ollama/package.json (1)

44-53:Verify dual listing of @tanstack/ai in both dependencies and peerDependencies.

Consistent with the Anthropic and OpenAI adapter packages, this package lists@tanstack/ai in bothdependencies (line 44) andpeerDependencies (line 52). This pattern appears across all adapter packages in this PR, suggesting it may be intentional, but it warrants verification.

examples/ts-react-chat/src/routes/api.tanchat.ts-116-116 (1)

116-116:Stream type cast toany is unnecessary with proper adapter typing.

The stream returned fromai() is cast toany before passing totoStreamResponse(). When the text adapter is properly typed,ai() returnsAsyncIterable<StreamChunk> by default (matchingtoStreamResponse()'s parameter type exactly). This cast is a workaround for the adapter being cast toany on line 102 and would be eliminated by fixing the root adapter type issue.

packages/typescript/ai-ollama/src/adapters/embed.ts-40-73 (1)

40-73:OllamaEmbedAdapterOptions.host is unused (misleading public API)

Right nowhost inOllamaEmbedAdapterOptions is never read; onlyhostOrClient affects the client. Either removehost from the options type, or honor it whenhostOrClient isn’t provided.

Proposed fix (honoroptions.host):

 export class OllamaEmbedAdapter implements EmbeddingAdapter<   typeof OllamaEmbeddingModels,   OllamaEmbedProviderOptions > {@@   constructor(     hostOrClient?: string | Ollama,     options: OllamaEmbedAdapterOptions = {},   ) {     if (typeof hostOrClient === 'string' || hostOrClient === undefined) {-      this.client = createOllamaClient({ host: hostOrClient })+      const host = typeof hostOrClient === 'string' ? hostOrClient : options.host+      this.client = createOllamaClient({ host })     } else {       this.client = hostOrClient     }     this.defaultModel = options.model ?? 'nomic-embed-text'   }@@ export function createOllamaEmbed(   host?: string,   options?: OllamaEmbedAdapterOptions, ): OllamaEmbedAdapter {   return new OllamaEmbedAdapter(host, options) }

Also applies to: 114-129

packages/typescript/ai-ollama/src/adapters/text.ts-100-131 (1)

100-131:OllamaTextAdapterOptions.host is unused (misleading public API)
Same as the other adapters: either removehost from options or honor it whenhostOrClient is undefined.

Also applies to: 391-406

packages/typescript/ai-ollama/src/adapters/summarize.ts-55-88 (1)

55-88:OllamaSummarizeAdapterOptions.host is unused (misleading public API)
Same issue asembed.ts: either removehost from options or honor it whenhostOrClient is undefined.

Also applies to: 152-167

packages/typescript/ai-ollama/src/adapters/text.ts-189-281 (1)

189-281:Tool callindex is not provided by ollama's streamed responses; derive it deterministically from array position

Ollama's OpenAI-compatible streamed tool-call responses do not include theindex field onfunction, making the unsafe cast to{ index: number } unreliable. This breaks consumers that depend on ordering or reconciliation. Use the loop index when iterating tool calls instead.

-      const handleToolCall = (toolCall: ToolCall): StreamChunk => {+      const handleToolCall = (toolCall: ToolCall, index: number): StreamChunk => {         const actualToolCall = toolCall as ToolCall & {           id: string-          function: { index: number }+          function: { index?: number }         }         return {@@-          index: actualToolCall.function.index,+          index,         }       }@@         if (chunk.message.tool_calls && chunk.message.tool_calls.length > 0) {-          for (const toolCall of chunk.message.tool_calls) {-            yield handleToolCall(toolCall)+          for (const [i, toolCall] of chunk.message.tool_calls.entries()) {+            yield handleToolCall(toolCall, i)             hasEmittedToolCalls = true           }@@       if (chunk.message.tool_calls && chunk.message.tool_calls.length > 0) {-        for (const toolCall of chunk.message.tool_calls) {-          yield handleToolCall(toolCall)+        for (const [i, toolCall] of chunk.message.tool_calls.entries()) {+          yield handleToolCall(toolCall, i)           hasEmittedToolCalls = true         }       }

packages/typescript/ai-ollama/src/adapters/summarize.ts-90-118 (1)

90-118:Provider options interface is unused; SummarizationOptions framework limitation prevents implementation

OllamaSummarizeProviderOptions is defined but cannot be applied becauseSummarizationOptions (from@tanstack/ai) does not include aproviderOptions field—unlikeTextOptions which supports generic, type-safe provider options. Thesummarize() method hardcodestemperature: 0.3 andnum_predict, leaving model tuning parameters likenum_ctx,top_p, andrepeat_penalty inaccessible to callers.

To fix this, extendSummarizationOptions to includeproviderOptions similar toTextOptions, then update the adapter to extract and merge them:

  async summarize(options: SummarizationOptions): Promise<SummarizationResult> {    const model = options.model || this.defaultModel    const prompt = this.buildSummarizationPrompt(options)+   const providerOptions = options.providerOptions as+     | OllamaSummarizeProviderOptions+     | undefined    const response = await this.client.generate({      model,      prompt,      options: {        temperature: 0.3,        num_predict: options.maxLength ?? 500,+       ...providerOptions,      },      stream: false,    })

Committable suggestion skipped: line range outside the PR's diff.

packages/typescript/ai-ollama/src/adapters/text.ts-147-187 (1)

147-187:structuredOutput() should validate with Zod after JSON parsing

The method converts theoutputSchema to JSON Schema and passes it to Ollama'sformat parameter (correct), but then only callsJSON.parse() without validating the result against the original schema. This means callers can receive structurally-invalid data even though they provided a schema.

AddoutputSchema.safeParse() after JSON parsing to ensure the response matches the intended schema:

      let parsed: unknown      try {        parsed = JSON.parse(rawText)      } catch {        throw new Error(          `Failed to parse structured output as JSON. Content: ${rawText.slice(0, 200)}${rawText.length > 200 ? '...' : ''}`,        )      }+     // Runtime validation with Zod+     const validated = outputSchema.safeParse(parsed)+     if (!validated.success) {+       throw new Error(+         `Structured output did not match schema: ${validated.error.message}`,+       )+     }      return {-       data: parsed,+       data: validated.data,         rawText,       }

packages/typescript/ai-ollama/src/adapters/embed.ts-75-108 (1)

75-108:Pass provider options through embeddings request + use generateId for IDs

ThecreateEmbeddings method ignoresoptions.providerOptions and usesDate.now() for ID generation, creating two issues:

1. Callers cannot pass provider-specific options (e.g.,num_gpu,num_thread) since they're not forwarded to the Ollama embeddings request.
2. id: \embed-${Date.now()}`can collide under concurrency; other adapters usegenerateId()` instead.

ImportgenerateId and apply:

 import {   createOllamaClient,   estimateTokens,   getOllamaHostFromEnv,+  generateId, } from '../utils'

   async createEmbeddings(options: EmbeddingOptions): Promise<EmbeddingResult> {     const model = options.model || this.defaultModel+    const providerOptions = options.providerOptions as+      | OllamaEmbedProviderOptions+      | undefined      for (const input of inputs) {       const response = await this.client.embeddings({         model,         prompt: input,+        options: providerOptions,       })

     return {-      id: `embed-${Date.now()}`,+      id: generateId('emb'),       model,       embeddings,

Committable suggestion skipped: line range outside the PR's diff.

packages/typescript/ai-openai/src/audio/tts-provider-options.ts-1-31 (1)

1-31:Remove "verse" voice option and clarify theinstructions parameter limitation.

The voice "verse" is not available in the current OpenAI TTS API and should be removed. Theinstructions parameter comment is incomplete—while it correctly notes that instructions do not work withtts-1 ortts-1-hd, it should clarify that instructions are supported bygpt-4o-mini-tts. The audio formats listed (mp3, opus, aac, flac, wav, pcm) are correct.

packages/typescript/ai-gemini/src/utils/schema-converter.ts-8-15 (1)

8-15:Remove reliance on internal Zod APIschema.def.type for object detection; use JSON Schema structure instead.
Theschema.def.type property is not part of Zod's public API and may be undefined or removed in future versions, making this converter fragile at runtime. The JSON Schema structure-based checks (checking forproperties key, empty objects) are more stable alternatives.

-    const isZodObject =-      typeof schema === 'object' &&-      'def' in schema &&-      schema.def.type === 'object'--    if (isZodObject && !result.type) {-      result.type = 'object'-    }--    if (Object.keys(result).length === 0) {+    if (Object.keys(result).length === 0) {       result.type = 'object'     }      if ('properties' in result && !result.type) {       result.type = 'object'     }

Also applies to: packages/typescript/ai-ollama/src/utils/schema-converter.ts, packages/typescript/ai-anthropic/src/utils/schema-converter.ts, packages/typescript/ai-openai/src/utils/schema-converter.ts

packages/typescript/ai-gemini/src/utils/client.ts-38-43 (1)

38-43:Extract duplicatedgenerateId to a shared utility.

ThegenerateId function is duplicated across multiple providers (Anthropic, OpenAI, Ollama, and now Gemini). This violates the DRY principle and creates maintenance overhead.

Consider extracting this to a shared utility package (e.g.,@tanstack/ai-utils or within the core@tanstack/ai package) that all provider packages can import. This ensures consistent ID generation and reduces code duplication.

Example location:packages/typescript/ai-utils/src/id-generator.ts orpackages/typescript/ai/src/utils/id-generator.ts

// Shared utilityexportfunctiongenerateId(prefix:string):string{return`${prefix}-${Date.now()}-${Math.random().toString(36).substring(7)}`}

Then import in each provider:

+import { generateId } from '@tanstack/ai-utils'-export function generateId(prefix: string): string {-  return `${prefix}-${Date.now()}-${Math.random().toString(36).substring(7)}`-}

Based on learnings, tree-shakeable architecture is preferred, so ensure the shared utility is properly exported.

packages/typescript/ai-openai/src/adapters/image.ts-59-92 (1)

59-92:Don’t letproviderOptions override validated request fields (n,size, etc.).

Right now...providerOptions is last, so a caller can bypass validation by supplying conflicting values insideproviderOptions. Prefer applyingproviderOptions first, then writing the normalized/validated fields last.

   private buildRequest(     options: ImageGenerationOptions<OpenAIImageProviderOptions>,   ): OpenAI_SDK.Images.ImageGenerateParams {     const { model, prompt, numberOfImages, size, providerOptions } = options     return {-      model,-      prompt,-      n: numberOfImages ?? 1,-      size: size as OpenAI_SDK.Images.ImageGenerateParams['size'],-      ...providerOptions,+      ...providerOptions,+      model,+      prompt,+      n: numberOfImages ?? 1,+      size: size as OpenAI_SDK.Images.ImageGenerateParams['size'],     }   }

packages/typescript/ai-gemini/src/adapters/tts.ts-73-85 (1)

73-85:Either support or explicitly rejectvoice /format /speed from TTSOptions.
Right now they’re silently ignored, which is confusing. Consider throwing if provided, or document “Gemini TTS ignores these” in JSDoc.

packages/typescript/ai-anthropic/src/adapters/text.ts-130-167 (1)

130-167:Useclient.beta.messages.create() for structured output instead of non-betaclient.messages.create().

Tool-based structured outputs andtool_choice are beta-only features in the Anthropic SDK. The streaming implementation correctly usesclient.beta.messages.create(), but thestructuredOutput() method calls the non-betaclient.messages.create(), which does not have full tool support. Change lines 155–162 to usethis.client.beta.messages.create() to ensure both endpoints use the same compatible API contract.

packages/typescript/ai-anthropic/src/adapters/text.ts-341-426 (1)

341-426:Add explicit guard forrole: 'tool' messages withouttoolCallId.

Currently, arole: 'tool' message withouttoolCallId falls through to the generic fallback and is converted to{ role: 'user', ... }, corrupting the conversation. Although the framework never creates such messages, there is no explicit validation. Add an error throw or explicit log to reject this invalid state rather than silently mishandling it.

packages/typescript/ai-anthropic/src/adapters/text.ts-504-522 (1)

504-522:Add block type check tocontent_block_stop handling to prevent duplicate empty-args emissions.

The current code yields empty arguments when a tool call has no input, but doesn't verify that the stopped block is actually atool_use block. A subsequentcontent_block_stop event (for text or thinking blocks) will reference the samecurrentToolIndex, potentially re-emitting the empty args for the last tool block. Use the event's block type or index to ensure only actual tool_use block completions trigger this emission.

packages/typescript/ai-anthropic/src/adapters/text.ts-482-502 (1)

482-502:Emit accumulated tool arguments instead of delta fragments to match content/thinking pattern and prevent data loss.

Duringinput_json_delta events, you accumulate intoexisting.input but yield onlyevent.delta.partial_json. This inconsistency causes consumers to lose non-empty tool call arguments—unlike content and thinking streams which emit both delta and accumulated state. The diff correctly changesarguments to useexisting.input for consistency and completeness.

           } else if (event.delta.type === 'input_json_delta') {             const existing = toolCallsMap.get(currentToolIndex)             if (existing) {               existing.input += event.delta.partial_json               yield {                 type: 'tool_call',                 id: genId(),                 model: model,                 timestamp,                 toolCall: {                   id: existing.id,                   type: 'function',                   function: {                     name: existing.name,-                    arguments: event.delta.partial_json,+                    arguments: existing.input,                   },                 },                 index: currentToolIndex,               }             }           }

packages/typescript/ai-openai/src/adapters/embed.ts-22-27 (1)

22-27:OpenAIEmbedProviderOptions are defined but never forwarded to the OpenAI API.
TheencodingFormat anduser options have no effect unless extracted from the options parameter and passed to the embeddings request asencoding_format anduser. Additionally, consider usingOPENAI_EMBEDDING_MODELS[0] instead of hardcoding'text-embedding-ada-002' for consistency with the model definitions.

 export class OpenAIEmbedAdapter extends BaseEmbeddingAdapter<   typeof OPENAI_EMBEDDING_MODELS,   OpenAIEmbedProviderOptions > {   async createEmbeddings(options: EmbeddingOptions): Promise<EmbeddingResult> {+    const providerOptions = (options as EmbeddingOptions & {+      providerOptions?: OpenAIEmbedProviderOptions+    }).providerOptions+     const response = await this.client.embeddings.create({-      model: options.model || 'text-embedding-ada-002',+      model: options.model || OPENAI_EMBEDDING_MODELS[0],       input: options.input,       dimensions: options.dimensions,+      encoding_format: providerOptions?.encodingFormat,+      user: providerOptions?.user,     })

Also applies to lines 50–55.

packages/typescript/ai-gemini/src/adapters/embed.ts-20-29 (1)

20-29:Wire GeminiEmbedProviderOptions into embedContent request and throw on missing embeddings.

The adapter definesGeminiEmbedProviderOptions withtaskType,title, andoutputDimensionality but never uses them in the API request. Additionally, ifresponse.embeddings?.[0]?.values is missing, the embedding is silently dropped, causing the returned embeddings array to have fewer entries than the input array (index misalignment).

Fix this by:

1. ExtractingproviderOptions from options
2. PassingtaskType,title, andoutputDimensionality to the embedContent config
3. Throwing an error instead of silently dropping missing embeddings

  async createEmbeddings(options: EmbeddingOptions): Promise<EmbeddingResult> {    const model = options.model || this.defaultModel+   const providerOptions = (options as any).providerOptions as+     | GeminiEmbedProviderOptions+     | undefined    // Ensure input is an array    const inputs = Array.isArray(options.input)      ? options.input      : [options.input]    const embeddings: Array<Array<number>> = []-   for (const input of inputs) {+   for (const [idx, input] of inputs.entries()) {      const response = await this.client.models.embedContent({        model,        contents: [{ role: 'user', parts: [{ text: input }] }],        config: {-         outputDimensionality: options.dimensions,+         outputDimensionality:+           providerOptions?.outputDimensionality ?? (options as any).dimensions,+         taskType: providerOptions?.taskType,+         title: providerOptions?.title,        },      })-     if (response.embeddings?.[0]?.values) {-       embeddings.push(response.embeddings[0].values)-     }+     const values = response.embeddings?.[0]?.values+     if (!values) {+       throw new Error(+         `Gemini embedContent returned no embedding values (model=${model}, index=${idx})`,+       )+     }+     embeddings.push(values)    }

Committable suggestion skipped: line range outside the PR's diff.

packages/typescript/ai-openai/src/adapters/video.ts-78-112 (1)

78-112:Validate the actual size you send (providerOptions.size can bypass validation).

createVideoJob() validatesvalidateVideoSize(model, size) wheresize = options.size, butbuildRequest() will fall back toproviderOptions.size whenoptions.size is undefined. That means an invalidproviderOptions.size can slip through and hit the API.

Suggested fix:

- const { model, size, duration, providerOptions } = options+ const { model, size, duration, providerOptions } = options+ const resolvedSize = size ?? providerOptions?.size- validateVideoSize(model, size)+ validateVideoSize(model, resolvedSize)

(And useresolvedSize consistently when building the request.)

Also applies to: 275-301

packages/typescript/ai-gemini/src/adapters/text.ts-205-255 (1)

205-255:UsenextToolIndex to generate unique tool call IDs.

When the same function is called multiple times in a stream,const toolCallId = functionCall.name creates collisions intoolCallMap, causing separate tool calls to merge their arguments. Use a stable synthetic ID likeconst toolCallId = functionCall.name ||${++callIndex}; // or any monotonic counter approach to ensure each call gets a unique identifier and preserves its own arguments.

packages/typescript/ai-openai/src/adapters/video.ts-92-110 (1)

92-110:Heavy reliance onany for OpenAI “videos” API needs a compatibility gate and clearer failure modes.

Right now the adapter assumesclient.videos.create/retrieve/... exist and have certain response shapes. If the SDK differs, this becomes runtime-unsafe. Consider feature-detectingclient.videos once (constructor) and throwing a clear “SDK does not support videos in this version” error before runtime calls.

Also applies to: 132-154, 171-272

packages/typescript/ai-gemini/src/adapters/summarize.ts-26-40 (1)

26-40:Provider options interface defined but non-functional due to missing framework support.

GeminiSummarizeProviderOptions definesgenerationConfig andsafetySettings, butSummarizationOptions (the method parameter type) has noproviderOptions field to pass them through. Additionally, thegenerateContent() call at lines 86-99 only appliessystemInstruction to config, ignoring temperature, topP, topK, maxOutputTokens, stopSequences, and safety settings entirely.

Requires two-part fix: (1) extendSummarizationOptions in the framework to supportproviderOptions, and (2) mapoptions.providerOptions.generationConfig.* andsafetySettings into the SDK config object.

packages/typescript/ai-gemini/src/adapters/text.ts-382-439 (1)

382-439:Store function name with tool call results for proper Gemini API attribution.

functionResponse: { name: msg.toolCallId, ... } violates Gemini's API contract. According to the Gemini API specification,functionResponse.name must be the function's declared name (e.g., "get_current_weather"), not the toolCallId. Tool results won't be correctly attributed to their function calls. TheModelMessage structure for tool role messages needs to preserve the function name from the original tool call, or the adapter must have a way to maptoolCallId back to the function name.

packages/typescript/ai-gemini/src/image/image-provider-options.ts-160-174 (1)

160-174:Aspect ratio mappings appear incorrect for some sizes.

Several mappings don't match the actual aspect ratios:

• '1536x1024': '3:4' — 1536/1024 ≈ 1.5, which is closer to 3:2 (landscape), not 3:4 (portrait).
• '1024x1536': '4:3' — 1024/1536 ≈ 0.67, which is 2:3 (portrait), not 4:3 (landscape).

The comments acknowledge these are "approximate mappings," but users relying on these mappings may get unexpected results.

 export const GEMINI_SIZE_TO_ASPECT_RATIO: Record<string, GeminiAspectRatio> = {   // Square   '1024x1024': '1:1',   '512x512': '1:1',   // Landscape   '1024x768': '4:3',-  '1536x1024': '3:4', // Actually this is portrait, but matching common dimensions+  '1536x1024': '3:4', // Note: 1536x1024 is actually ~3:2, mapped to closest supported ratio   '1792x1024': '16:9',   '1920x1080': '16:9',   // Portrait   '768x1024': '3:4',-  '1024x1536': '4:3', // Inverted+  '1024x1536': '3:4', // Portrait dimensions, using 3:4 portrait ratio   '1024x1792': '9:16',   '1080x1920': '9:16', }

packages/typescript/ai-devtools/src/store/ai-context.tsx-1309-1309 (1)

1309-1309:Update comment to reflect new event namespace.

The comment references "Chat Events" but the event listeners below use thetext:* namespace. Update the comment for consistency.

Apply this diff:

-    // ============= Chat Events (for usage tracking) =============+    // ============= Text Events (for usage tracking) =============

examples/ts-vue-chat/vite.config.ts-5-10 (1)

5-10:Consolidate the duplicate@tanstack/ai import.

The@tanstack/ai package is imported twice—once on line 5 and again on line 10. MovetoolDefinition to the first import statement:

-import { ai, maxIterations, toStreamResponse } from '@tanstack/ai'+import { ai, maxIterations, toStreamResponse, toolDefinition } from '@tanstack/ai' import { openaiText } from '@tanstack/ai-openai' import { anthropicText } from '@tanstack/ai-anthropic' import { geminiText } from '@tanstack/ai-gemini' import { ollamaText } from '@tanstack/ai-ollama'-import { toolDefinition } from '@tanstack/ai'

packages/typescript/ai-ollama/src/utils/client.ts-39-41 (1)

39-41:Potential for short/empty random suffix in ID generation.

Math.random().toString(36).substring(7) can produce strings of varying length (0-6 characters) depending on the random value. For more consistent IDs, consider usingsubstring(2, 9) or a fixed-length approach.

 export function generateId(prefix: string = 'msg'): string {-  return `${prefix}-${Date.now()}-${Math.random().toString(36).substring(7)}`+  return `${prefix}-${Date.now()}-${Math.random().toString(36).substring(2, 9)}` }

packages/typescript/ai-ollama/src/adapters/summarize.ts-120-146 (1)

120-146:maxLength mixes “words” in the prompt with “tokens” innum_predict
The prompt says “under N words”, but you treatmaxLength as tokens fornum_predict. Either (a) rename semantics in the prompt to “tokens”, or (b) keep it as words and translate to an approximate token budget.

packages/typescript/ai-ollama/src/adapters/text.ts-283-386 (1)

283-386:Add explanatory comments for image source handling or implement explicit format conversion

The current code treatsdata and non-data image sources identically by pushingsource.value directly. While the ollama-js SDK accepts multiple image formats (base64, URLs, file paths, bytes) and handles conversion internally, the previous implementation included clarifying comments that "URL-based images [are] not directly supported" and "Ollama may need the image to be fetched externally." These comments should be restored to document the current behavior and any limitations, or the code should explicitly handle format conversion for consistency with how other adapters differentiate source types.

docs/adapters/ollama.md-126-126 (1)

126-126:Fix hyphenation in compound modifier.

The phrase should use a hyphen: "tool-calling support" instead of "tool calling support" when used as a compound adjective modifying "support."

Apply this diff:

-**Note:** Tool support varies by model. Models like `llama3`, `mistral`, and `qwen2` generally have good tool calling support.+**Note:** Tool support varies by model. Models like `llama3`, `mistral`, and `qwen2` generally have good tool-calling support.

packages/typescript/ai-gemini/src/tools/tool-converter.ts-79-82 (1)

79-82:Wrap variable declaration in block to prevent leakage.

ThejsonSchema variable is declared in a switch case without a surrounding block. This can cause the variable to be accessible in other case clauses, leading to unexpected behavior.

Apply this diff to wrap the declaration in a block:

       default:+        {         // Collect function declarations to group together         // Description is required for Gemini function declarations         if (!tool.description) {           throw new Error(             `Tool ${tool.name} requires a description for Gemini adapter`,           )         }         // Convert Zod schema to Gemini-compatible JSON Schema         const jsonSchema = tool.inputSchema           ? convertZodToGeminiSchema(tool.inputSchema)           : { type: 'object', properties: {}, required: [] }         functionDeclarations.push({           name: tool.name,           description: tool.description,           parameters: jsonSchema,         })         break+        }

Based on static analysis hints.

docs/reference/type-aliases/TextStreamOptionsForModel.md-14-16 (1)

14-16:Update comment to reflect renamed type.

Line 14 still refers to "Chat options" but should be "Text options" to match the renamed typeTextStreamOptionsForModel.

Apply this diff:

-Chat options constrained by a specific model's capabilities.+Text options constrained by a specific model's capabilities.

docs/config.json-189-196 (1)

189-196:Consider adding redirects/aliases for renamed function reference routes (chat→text).
If the docs site supports redirects, keeping legacy routes working avoids breaking deep links from older blog posts / READMEs.

docs/config.json-484-490 (1)

484-490:Same redirect/alias concern for renamed type-alias pages (ChatStream→TextStream).
Worth preserving legacy URLs if feasible.

packages/typescript/ai-openai/src/adapters/tts.ts-71-79 (1)

71-79:Ensureinstructions is only passed to compatible models.
Theinstructions field is supported inSpeechCreateParams, but only works withgpt-4o-mini-tts; passing it totts-1 ortts-1-hd will fail at runtime. Validate the model before spreadingproviderOptions or document this constraint.

packages/typescript/ai-openai/src/adapters/summarize.ts-57-66 (1)

57-66:Handle emptychoices explicitly (avoid silently returning '').
Returning'' can mask upstream failures; consider throwing whenchoices[0] is missing.

packages/typescript/ai-anthropic/src/adapters/summarize.ts-55-68 (1)

55-68:Guard against missingresponse.usage / unexpected content blocks.
If the SDK can omitusage (or include non-text blocks), consider null-safe access + clearer erroring when summary ends up empty unexpectedly.

packages/typescript/ai-gemini/src/image/image-provider-options.ts-208-226 (1)

208-226:Comment/implementation mismatch for image count limits.

The comment states "Imagen models support 1-8 images per request (varies by model)" but the implementation hardcodesmaxImages = 4. Themodel parameter is accepted but not used for model-specific validation.

Consider either:

1. Using themodel parameter to apply model-specific limits, or
2. Updating the comment to reflect the actual hardcoded limit.

 export function validateNumberOfImages(   model: string,   numberOfImages: number | undefined, ): void {   if (numberOfImages === undefined) return-  // Most Imagen models support 1-4 images, some support up to 8-  const maxImages = 4+  // All Imagen models currently support up to 4 images per request+  const maxImages = 4 // TODO: Implement model-specific limits if needed   if (numberOfImages < 1 || numberOfImages > maxImages) {

packages/typescript/ai-openai/src/adapters/text.ts-226-226 (1)

226-226:Dead code:eventTypeCounts map is never populated.

TheeventTypeCounts map is declared at line 226 but never updated during stream processing. The error handler at lines 479-486 logs it, but it will always be empty.

Either populate the map during processing:

       for await (const chunk of stream) {         chunkCount+++        eventTypeCounts.set(chunk.type, (eventTypeCounts.get(chunk.type) || 0) + 1)

Or remove the unused declaration:

-    const eventTypeCounts = new Map<string, number>()

Committable suggestion skipped: line range outside the PR's diff.