@openrouter/sdk 0.3.16 → 0.4.0

package/esm/funcs/modelsListForUser.d.ts

@@ -10,7 +10,10 @@ import * as operations from "../models/operations/index.js";
 import { APIPromise } from "../types/async.js";
 import { Result } from "../types/fp.js";
 /**
- * List models filtered by user provider preferences
+ * List models filtered by user provider preferences, privacy settings, and guardrails
+ *
+ * @remarks
+ * List models filtered by user provider preferences, [privacy settings](https://openrouter.ai/docs/guides/privacy/logging), and [guardrails](https://openrouter.ai/docs/guides/features/guardrails). If requesting through `eu.openrouter.ai/api/v1/...` the results will be filtered to models that satisfy [EU in-region routing](https://openrouter.ai/docs/guides/privacy/logging#enterprise-eu-in-region-routing).
  */
-export declare function modelsListForUser(client: OpenRouterCore, security: operations.ListModelsUserSecurity, options?: RequestOptions): APIPromise<Result<models.ModelsListResponse, errors.UnauthorizedResponseError | errors.InternalServerResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
+export declare function modelsListForUser(client: OpenRouterCore, security: operations.ListModelsUserSecurity, options?: RequestOptions): APIPromise<Result<models.ModelsListResponse, errors.UnauthorizedResponseError | errors.NotFoundResponseError | errors.InternalServerResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
 //# sourceMappingURL=modelsListForUser.d.ts.map

package/esm/funcs/modelsListForUser.js

@@ -10,7 +10,10 @@ import * as errors from "../models/errors/index.js";
 import * as models from "../models/index.js";
 import { APIPromise } from "../types/async.js";
 /**
- * List models filtered by user provider preferences
+ * List models filtered by user provider preferences, privacy settings, and guardrails
+ *
+ * @remarks
+ * List models filtered by user provider preferences, [privacy settings](https://openrouter.ai/docs/guides/privacy/logging), and [guardrails](https://openrouter.ai/docs/guides/features/guardrails). If requesting through `eu.openrouter.ai/api/v1/...` the results will be filtered to models that satisfy [EU in-region routing](https://openrouter.ai/docs/guides/privacy/logging#enterprise-eu-in-region-routing).
  */
 export function modelsListForUser(client, security, options) {
     return new APIPromise($do(client, security, options));
@@ -54,7 +57,7 @@ async function $do(client, security, options) {
     const req = requestRes.value;
     const doResult = await client._do(req, {
         context,
-        errorCodes: ["401", "4XX", "500", "5XX"],
+        errorCodes: ["401", "404", "4XX", "500", "5XX"],
         retryConfig: context.retryConfig,
         retryCodes: context.retryCodes,
     });
@@ -65,7 +68,7 @@ async function $do(client, security, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result] = await M.match(M.json(200, models.ModelsListResponse$inboundSchema), M.jsonErr(401, errors.UnauthorizedResponseError$inboundSchema), M.jsonErr(500, errors.InternalServerResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
+    const [result] = await M.match(M.json(200, models.ModelsListResponse$inboundSchema), M.jsonErr(401, errors.UnauthorizedResponseError$inboundSchema), M.jsonErr(404, errors.NotFoundResponseError$inboundSchema), M.jsonErr(500, errors.InternalServerResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
     if (!result.ok) {
         return [result, { status: "complete", request: req, response }];
     }

package/esm/index.d.ts

@@ -14,6 +14,7 @@ export { HTTPClient } from './lib/http.js';
 export { applyNextTurnParamsToRequest, buildNextTurnParamsContext, executeNextTurnParamsFunctions, } from './lib/next-turn-params.js';
 export { finishReasonIs, hasToolCall, isStopConditionMet, maxCost, maxTokensUsed, stepCountIs, } from './lib/stop-conditions.js';
 export { extractUnsupportedContent, getUnsupportedContentSummary, hasUnsupportedContent, } from './lib/stream-transformers.js';
+export type { StreamableOutputItem } from './lib/stream-transformers.js';
 export { tool } from './lib/tool.js';
 export { hasApprovalRequiredTools, hasExecuteFunction, isGeneratorTool, isRegularExecuteTool, isToolPreliminaryResultEvent, isToolResultEvent, toolHasApprovalConfigured, ToolType, } from './lib/tool-types.js';
 export { buildTurnContext, normalizeInputToArray } from './lib/turn-context.js';

package/esm/lib/config.d.ts

@@ -45,8 +45,8 @@ export declare function serverURLFromOptions(options: SDKOptions): URL | null;
 export declare const SDK_METADATA: {
     readonly language: "typescript";
     readonly openapiDocVersion: "1.0.0";
-    readonly sdkVersion: "0.3.16";
+    readonly sdkVersion: "0.4.0";
     readonly genVersion: "2.788.4";
-    readonly userAgent: "speakeasy-sdk/typescript 0.3.16 2.788.4 1.0.0 @openrouter/sdk";
+    readonly userAgent: "speakeasy-sdk/typescript 0.4.0 2.788.4 1.0.0 @openrouter/sdk";
 };
 //# sourceMappingURL=config.d.ts.map

package/esm/lib/config.js

@@ -26,8 +26,8 @@ export function serverURLFromOptions(options) {
 export const SDK_METADATA = {
     language: "typescript",
     openapiDocVersion: "1.0.0",
-    sdkVersion: "0.3.16",
+    sdkVersion: "0.4.0",
     genVersion: "2.788.4",
-    userAgent: "speakeasy-sdk/typescript 0.3.16 2.788.4 1.0.0 @openrouter/sdk",
+    userAgent: "speakeasy-sdk/typescript 0.4.0 2.788.4 1.0.0 @openrouter/sdk",
 };
 //# sourceMappingURL=config.js.map

package/esm/lib/model-result.d.ts

@@ -3,6 +3,7 @@ import type * as models from '../models/index.js';
 import type { CallModelInput } from './async-params.js';
 import type { RequestOptions } from './sdks.js';
 import type { ConversationState, ResponseStreamEvent, InferToolEventsUnion, InferToolOutputsUnion, ParsedToolCall, StateAccessor, StopWhen, Tool, ToolStreamEvent, TurnContext } from './tool-types.js';
+import { type StreamableOutputItem } from './stream-transformers.js';
 export interface GetResponseOptions<TTools extends readonly Tool[]> {
     request: CallModelInput<TTools>;
     client: OpenRouterCore;
@@ -245,6 +246,25 @@ export declare class ModelResult<TTools extends readonly Tool[]> {
      */
     getTextStream(): AsyncIterableIterator<string>;
     /**
+     * Stream all output items cumulatively as they arrive.
+     * Items are emitted with the same ID but progressively updated content as streaming progresses.
+     * Also yields tool results (function_call_output) after tool execution completes.
+     *
+     * Item types include:
+     * - message: Assistant text responses (emitted cumulatively as text streams)
+     * - function_call: Tool calls (emitted cumulatively as arguments stream)
+     * - reasoning: Model reasoning (emitted cumulatively as thinking streams)
+     * - web_search_call: Web search operations
+     * - file_search_call: File search operations
+     * - image_generation_call: Image generation operations
+     * - function_call_output: Results from executed tools
+     */
+    getItemsStream(): AsyncIterableIterator<StreamableOutputItem>;
+    /**
+     * @deprecated Use `getItemsStream()` instead. This method only streams messages,
+     * while `getItemsStream()` streams all output item types (messages, function_calls,
+     * reasoning, etc.) with cumulative updates.
+     *
      * Stream incremental message updates as content is added in responses format.
      * Each iteration yields an updated version of the message with new content.
      * Also yields OpenResponsesFunctionCallOutput after tool execution completes.

package/esm/lib/model-result.js

@@ -3,11 +3,12 @@ import { betaResponsesSend } from '../funcs/betaResponsesSend.js';
 import { hasAsyncFunctions, resolveAsyncFunctions, } from './async-params.js';
 import { appendToMessages, createInitialState, createRejectedResult, createUnsentResult, extractTextFromResponse as extractTextFromResponseState, partitionToolCalls, unsentResultsToAPIFormat, updateState, } from './conversation-state.js';
 import { ReusableReadableStream } from './reusable-stream.js';
-import { buildResponsesMessageStream, buildToolCallStream, consumeStreamForCompletion, extractReasoningDeltas, extractResponsesMessageFromResponse, extractTextDeltas, extractTextFromResponse, extractToolCallsFromResponse, extractToolDeltas, } from './stream-transformers.js';
+import { buildItemsStream, buildResponsesMessageStream, buildToolCallStream, consumeStreamForCompletion, extractReasoningDeltas, extractResponsesMessageFromResponse, extractTextDeltas, extractTextFromResponse, extractToolCallsFromResponse, extractToolDeltas, } from './stream-transformers.js';
 import { executeTool } from './tool-executor.js';
 import { executeNextTurnParamsFunctions, applyNextTurnParamsToRequest } from './next-turn-params.js';
 import { hasExecuteFunction } from './tool-types.js';
 import { isStopConditionMet, stepCountIs } from './stop-conditions.js';
+import { isOutputMessage, isFunctionCallOutputItem, isReasoningOutputItem, isWebSearchCallOutputItem, isFileSearchCallOutputItem, isImageGenerationCallOutputItem, hasTypeProperty, } from './stream-type-guards.js';
 /**
  * Default maximum number of tool execution steps if no stopWhen is specified.
  * This prevents infinite loops in tool execution.
@@ -30,15 +31,6 @@ function isEventStream(value) {
     const maybeStream = value;
     return typeof maybeStream.toReadableStream === 'function';
 }
-/**
- * Type guard for output items with a type property
- */
-function hasTypeProperty(item) {
-    return (typeof item === 'object' &&
-        item !== null &&
-        'type' in item &&
-        typeof item.type === 'string');
-}
 /**
  * A wrapper around a streaming response that provides multiple consumption patterns.
  *
@@ -875,6 +867,55 @@ export class ModelResult {
         }.call(this);
     }
     /**
+     * Stream all output items cumulatively as they arrive.
+     * Items are emitted with the same ID but progressively updated content as streaming progresses.
+     * Also yields tool results (function_call_output) after tool execution completes.
+     *
+     * Item types include:
+     * - message: Assistant text responses (emitted cumulatively as text streams)
+     * - function_call: Tool calls (emitted cumulatively as arguments stream)
+     * - reasoning: Model reasoning (emitted cumulatively as thinking streams)
+     * - web_search_call: Web search operations
+     * - file_search_call: File search operations
+     * - image_generation_call: Image generation operations
+     * - function_call_output: Results from executed tools
+     */
+    getItemsStream() {
+        return async function* () {
+            await this.initStream();
+            if (!this.reusableStream) {
+                throw new Error('Stream not initialized');
+            }
+            // Stream all items from the API response cumulatively
+            yield* buildItemsStream(this.reusableStream);
+            // Execute tools if needed
+            await this.executeToolsIfNeeded();
+            // Yield function call outputs for each executed tool
+            for (const round of this.allToolExecutionRounds) {
+                for (const toolResult of round.toolResults) {
+                    yield toolResult;
+                }
+            }
+            // If tools were executed, yield all items from the final response
+            if (this.finalResponse && this.allToolExecutionRounds.length > 0) {
+                for (const item of this.finalResponse.output) {
+                    if (isOutputMessage(item) ||
+                        isFunctionCallOutputItem(item) ||
+                        isReasoningOutputItem(item) ||
+                        isWebSearchCallOutputItem(item) ||
+                        isFileSearchCallOutputItem(item) ||
+                        isImageGenerationCallOutputItem(item)) {
+                        yield item;
+                    }
+                }
+            }
+        }.call(this);
+    }
+    /**
+     * @deprecated Use `getItemsStream()` instead. This method only streams messages,
+     * while `getItemsStream()` streams all output item types (messages, function_calls,
+     * reasoning, etc.) with cumulative updates.
+     *
      * Stream incremental message updates as content is added in responses format.
      * Each iteration yields an updated version of the message with new content.
      * Also yields OpenResponsesFunctionCallOutput after tool execution completes.

package/esm/lib/stream-transformers.d.ts

@@ -18,6 +18,18 @@ export declare function extractToolDeltas(stream: ReusableReadableStream<models.
  * Returns ResponsesOutputMessage (assistant/responses format)
  */
 export declare function buildResponsesMessageStream(stream: ReusableReadableStream<models.OpenResponsesStreamEvent>): AsyncIterableIterator<models.ResponsesOutputMessage>;
+/**
+ * Output item types that can be streamed from a response.
+ * This is the union of all item types that appear in response output,
+ * plus function_call_output for tool results.
+ */
+export type StreamableOutputItem = models.ResponsesOutputMessage | models.ResponsesOutputItemFunctionCall | models.ResponsesOutputItemReasoning | models.ResponsesWebSearchCallOutput | models.ResponsesOutputItemFileSearchCall | models.ResponsesImageGenerationCall | models.OpenResponsesFunctionCallOutput;
+/**
+ * Build incremental output item updates from responses stream events.
+ * Yields all item types cumulatively - same item may be emitted multiple times
+ * with the same ID but progressively updated content as streaming progresses.
+ */
+export declare function buildItemsStream(stream: ReusableReadableStream<models.OpenResponsesStreamEvent>): AsyncIterableIterator<StreamableOutputItem>;
 /**
  * Build incremental message updates from responses stream events
  * Returns AssistantMessage (chat format) instead of ResponsesOutputMessage

package/esm/lib/stream-transformers.js

@@ -127,6 +127,212 @@ export async function* buildResponsesMessageStream(stream) {
         }
     }
 }
+/**
+ * Handle output_item.added event - Initialize tracking for new items
+ */
+function handleOutputItemAdded(event, itemsInProgress) {
+    if (!isOutputItemAddedEvent(event) || !event.item) {
+        return undefined;
+    }
+    const item = event.item;
+    if (isOutputMessage(item)) {
+        itemsInProgress.set(item.id, {
+            type: 'message',
+            id: item.id,
+            textContent: '',
+        });
+        return {
+            id: item.id,
+            type: 'message',
+            role: 'assistant',
+            status: 'in_progress',
+            content: [],
+        };
+    }
+    if (isFunctionCallOutputItem(item)) {
+        // Use item.id if available (matches itemId in delta events), fall back to callId
+        const itemKey = item.id ?? item.callId;
+        itemsInProgress.set(itemKey, {
+            type: 'function_call',
+            id: itemKey,
+            name: item.name,
+            callId: item.callId,
+            argumentsAccumulated: '',
+        });
+        return {
+            type: 'function_call',
+            id: item.id,
+            callId: item.callId,
+            name: item.name,
+            arguments: '',
+            status: 'in_progress',
+        };
+    }
+    if (isReasoningOutputItem(item)) {
+        itemsInProgress.set(item.id, {
+            type: 'reasoning',
+            id: item.id,
+            reasoningContent: '',
+        });
+        return {
+            type: 'reasoning',
+            id: item.id,
+            status: 'in_progress',
+            summary: [],
+        };
+    }
+    if (isWebSearchCallOutputItem(item)) {
+        return item;
+    }
+    if (isFileSearchCallOutputItem(item)) {
+        return item;
+    }
+    if (isImageGenerationCallOutputItem(item)) {
+        return item;
+    }
+    return undefined;
+}
+/**
+ * Handle text delta event for messages
+ */
+function handleTextDelta(event, itemsInProgress) {
+    if (!isOutputTextDeltaEvent(event) || !event.delta) {
+        return undefined;
+    }
+    const item = itemsInProgress.get(event.itemId);
+    if (item?.type === 'message') {
+        item.textContent += event.delta;
+        return {
+            id: item.id,
+            type: 'message',
+            role: 'assistant',
+            status: 'in_progress',
+            content: [
+                {
+                    type: 'output_text',
+                    text: item.textContent,
+                    annotations: [],
+                },
+            ],
+        };
+    }
+    return undefined;
+}
+/**
+ * Handle function call argument delta event
+ */
+function handleFunctionCallDelta(event, itemsInProgress) {
+    if (!isFunctionCallArgumentsDeltaEvent(event) || !event.delta) {
+        return undefined;
+    }
+    const item = itemsInProgress.get(event.itemId);
+    if (item?.type === 'function_call') {
+        item.argumentsAccumulated += event.delta;
+        return {
+            type: 'function_call',
+            // Include id if it differs from callId (means API provided an id)
+            id: item.id !== item.callId ? item.id : undefined,
+            callId: item.callId,
+            name: item.name,
+            arguments: item.argumentsAccumulated,
+            status: 'in_progress',
+        };
+    }
+    return undefined;
+}
+/**
+ * Handle reasoning text delta event
+ */
+function handleReasoningDelta(event, itemsInProgress) {
+    if (!isReasoningDeltaEvent(event) || !event.delta) {
+        return undefined;
+    }
+    const item = itemsInProgress.get(event.itemId);
+    if (item?.type === 'reasoning') {
+        item.reasoningContent += event.delta;
+        return {
+            type: 'reasoning',
+            id: item.id,
+            status: 'in_progress',
+            summary: [
+                {
+                    type: 'summary_text',
+                    text: item.reasoningContent,
+                },
+            ],
+        };
+    }
+    return undefined;
+}
+/**
+ * Handle output_item.done event - Yield final complete item
+ */
+function handleOutputItemDone(event, itemsInProgress) {
+    if (!isOutputItemDoneEvent(event) || !event.item) {
+        return undefined;
+    }
+    const item = event.item;
+    if (isOutputMessage(item)) {
+        itemsInProgress.delete(item.id);
+        return item;
+    }
+    if (isFunctionCallOutputItem(item)) {
+        // Use item.id if available (matches itemId in delta events), fall back to callId
+        itemsInProgress.delete(item.id ?? item.callId);
+        return item;
+    }
+    if (isReasoningOutputItem(item)) {
+        itemsInProgress.delete(item.id);
+        return item;
+    }
+    if (isWebSearchCallOutputItem(item)) {
+        return item;
+    }
+    if (isFileSearchCallOutputItem(item)) {
+        return item;
+    }
+    if (isImageGenerationCallOutputItem(item)) {
+        return item;
+    }
+    return undefined;
+}
+const itemsStreamHandlers = {
+    'response.output_item.added': handleOutputItemAdded,
+    'response.output_text.delta': handleTextDelta,
+    'response.function_call_arguments.delta': handleFunctionCallDelta,
+    'response.reasoning_text.delta': handleReasoningDelta,
+    'response.output_item.done': handleOutputItemDone,
+};
+const streamTerminationEvents = new Set([
+    'response.completed',
+    'response.failed',
+    'response.incomplete',
+]);
+//#endregion
+/**
+ * Build incremental output item updates from responses stream events.
+ * Yields all item types cumulatively - same item may be emitted multiple times
+ * with the same ID but progressively updated content as streaming progresses.
+ */
+export async function* buildItemsStream(stream) {
+    const consumer = stream.createConsumer();
+    const itemsInProgress = new Map();
+    for await (const event of consumer) {
+        if (!('type' in event)) {
+            continue;
+        }
+        if (streamTerminationEvents.has(event.type)) {
+            return;
+        }
+        const handler = itemsStreamHandlers[event.type];
+        if (handler) {
+            const result = handler(event, itemsInProgress);
+            if (result) {
+                yield result;
+            }
+        }
+    }
+}
 /**
  * Build incremental message updates from responses stream events
  * Returns AssistantMessage (chat format) instead of ResponsesOutputMessage

package/esm/lib/tool-types.d.ts

@@ -58,6 +58,7 @@ export type NextTurnParamsFunctions<TInput> = {
 export type ToolApprovalCheck<TInput> = (params: TInput, context: TurnContext) => boolean | Promise<boolean>;
 /**
  * Base tool function interface with inputSchema
+ * @template TInput - Zod schema for tool input
  */
 export interface BaseToolFunction<TInput extends $ZodObject<$ZodShape>> {
     name: string;

package/esm/models/chatgenerationparams.d.ts

@@ -163,17 +163,17 @@ export type Reasoning = {
     effort?: Effort | null | undefined;
     summary?: ReasoningSummaryVerbosity | null | undefined;
 };
-export type ChatGenerationParamsResponseFormatPython = {
+export type ResponseFormatPython = {
     type: "python";
 };
-export type ChatGenerationParamsResponseFormatJSONObject = {
+export type ResponseFormatJSONObject = {
     type: "json_object";
 };
-export type ChatGenerationParamsResponseFormatText = {
+export type ResponseFormatText = {
     type: "text";
 };
-export type ChatGenerationParamsResponseFormatUnion = ChatGenerationParamsResponseFormatText | ChatGenerationParamsResponseFormatJSONObject | ResponseFormatJSONSchema | ResponseFormatTextGrammar | ChatGenerationParamsResponseFormatPython;
-export type ChatGenerationParamsStop = string | Array<string>;
+export type ResponseFormat = ResponseFormatText | ResponseFormatJSONObject | ResponseFormatJSONSchema | ResponseFormatTextGrammar | ResponseFormatPython;
+export type Stop = string | Array<string>;
 export type Debug = {
     echoUpstreamBody?: boolean | undefined;
 };
@@ -214,7 +214,7 @@ export type ChatGenerationParams = {
     } | undefined;
     presencePenalty?: number | null | undefined;
     reasoning?: Reasoning | undefined;
-    responseFormat?: ChatGenerationParamsResponseFormatText | ChatGenerationParamsResponseFormatJSONObject | ResponseFormatJSONSchema | ResponseFormatTextGrammar | ChatGenerationParamsResponseFormatPython | undefined;
+    responseFormat?: ResponseFormatText | ResponseFormatJSONObject | ResponseFormatJSONSchema | ResponseFormatTextGrammar | ResponseFormatPython | undefined;
     seed?: number | null | undefined;
     stop?: string | Array<string> | null | undefined;
     stream?: boolean | undefined;
@@ -366,36 +366,36 @@ export type Reasoning$Outbound = {
 export declare const Reasoning$outboundSchema: z.ZodType<Reasoning$Outbound, Reasoning>;
 export declare function reasoningToJSON(reasoning: Reasoning): string;
 /** @internal */
-export type ChatGenerationParamsResponseFormatPython$Outbound = {
+export type ResponseFormatPython$Outbound = {
     type: "python";
 };
 /** @internal */
-export declare const ChatGenerationParamsResponseFormatPython$outboundSchema: z.ZodType<ChatGenerationParamsResponseFormatPython$Outbound, ChatGenerationParamsResponseFormatPython>;
-export declare function chatGenerationParamsResponseFormatPythonToJSON(chatGenerationParamsResponseFormatPython: ChatGenerationParamsResponseFormatPython): string;
+export declare const ResponseFormatPython$outboundSchema: z.ZodType<ResponseFormatPython$Outbound, ResponseFormatPython>;
+export declare function responseFormatPythonToJSON(responseFormatPython: ResponseFormatPython): string;
 /** @internal */
-export type ChatGenerationParamsResponseFormatJSONObject$Outbound = {
+export type ResponseFormatJSONObject$Outbound = {
     type: "json_object";
 };
 /** @internal */
-export declare const ChatGenerationParamsResponseFormatJSONObject$outboundSchema: z.ZodType<ChatGenerationParamsResponseFormatJSONObject$Outbound, ChatGenerationParamsResponseFormatJSONObject>;
-export declare function chatGenerationParamsResponseFormatJSONObjectToJSON(chatGenerationParamsResponseFormatJSONObject: ChatGenerationParamsResponseFormatJSONObject): string;
+export declare const ResponseFormatJSONObject$outboundSchema: z.ZodType<ResponseFormatJSONObject$Outbound, ResponseFormatJSONObject>;
+export declare function responseFormatJSONObjectToJSON(responseFormatJSONObject: ResponseFormatJSONObject): string;
 /** @internal */
-export type ChatGenerationParamsResponseFormatText$Outbound = {
+export type ResponseFormatText$Outbound = {
     type: "text";
 };
 /** @internal */
-export declare const ChatGenerationParamsResponseFormatText$outboundSchema: z.ZodType<ChatGenerationParamsResponseFormatText$Outbound, ChatGenerationParamsResponseFormatText>;
-export declare function chatGenerationParamsResponseFormatTextToJSON(chatGenerationParamsResponseFormatText: ChatGenerationParamsResponseFormatText): string;
+export declare const ResponseFormatText$outboundSchema: z.ZodType<ResponseFormatText$Outbound, ResponseFormatText>;
+export declare function responseFormatTextToJSON(responseFormatText: ResponseFormatText): string;
 /** @internal */
-export type ChatGenerationParamsResponseFormatUnion$Outbound = ChatGenerationParamsResponseFormatText$Outbound | ChatGenerationParamsResponseFormatJSONObject$Outbound | ResponseFormatJSONSchema$Outbound | ResponseFormatTextGrammar$Outbound | ChatGenerationParamsResponseFormatPython$Outbound;
+export type ResponseFormat$Outbound = ResponseFormatText$Outbound | ResponseFormatJSONObject$Outbound | ResponseFormatJSONSchema$Outbound | ResponseFormatTextGrammar$Outbound | ResponseFormatPython$Outbound;
 /** @internal */
-export declare const ChatGenerationParamsResponseFormatUnion$outboundSchema: z.ZodType<ChatGenerationParamsResponseFormatUnion$Outbound, ChatGenerationParamsResponseFormatUnion>;
-export declare function chatGenerationParamsResponseFormatUnionToJSON(chatGenerationParamsResponseFormatUnion: ChatGenerationParamsResponseFormatUnion): string;
+export declare const ResponseFormat$outboundSchema: z.ZodType<ResponseFormat$Outbound, ResponseFormat>;
+export declare function responseFormatToJSON(responseFormat: ResponseFormat): string;
 /** @internal */
-export type ChatGenerationParamsStop$Outbound = string | Array<string>;
+export type Stop$Outbound = string | Array<string>;
 /** @internal */
-export declare const ChatGenerationParamsStop$outboundSchema: z.ZodType<ChatGenerationParamsStop$Outbound, ChatGenerationParamsStop>;
-export declare function chatGenerationParamsStopToJSON(chatGenerationParamsStop: ChatGenerationParamsStop): string;
+export declare const Stop$outboundSchema: z.ZodType<Stop$Outbound, Stop>;
+export declare function stopToJSON(stop: Stop): string;
 /** @internal */
 export type Debug$Outbound = {
     echo_upstream_body?: boolean | undefined;
@@ -433,7 +433,7 @@ export type ChatGenerationParams$Outbound = {
     } | undefined;
     presence_penalty?: number | null | undefined;
     reasoning?: Reasoning$Outbound | undefined;
-    response_format?: ChatGenerationParamsResponseFormatText$Outbound | ChatGenerationParamsResponseFormatJSONObject$Outbound | ResponseFormatJSONSchema$Outbound | ResponseFormatTextGrammar$Outbound | ChatGenerationParamsResponseFormatPython$Outbound | undefined;
+    response_format?: ResponseFormatText$Outbound | ResponseFormatJSONObject$Outbound | ResponseFormatJSONSchema$Outbound | ResponseFormatTextGrammar$Outbound | ResponseFormatPython$Outbound | undefined;
     seed?: number | null | undefined;
     stop?: string | Array<string> | null | undefined;
     stream: boolean;

package/esm/models/chatgenerationparams.js

@@ -233,41 +233,44 @@ export function reasoningToJSON(reasoning) {
     return JSON.stringify(Reasoning$outboundSchema.parse(reasoning));
 }
 /** @internal */
-export const ChatGenerationParamsResponseFormatPython$outboundSchema = z.object({
+export const ResponseFormatPython$outboundSchema = z.object({
     type: z.literal("python"),
 });
-export function chatGenerationParamsResponseFormatPythonToJSON(chatGenerationParamsResponseFormatPython) {
-    return JSON.stringify(ChatGenerationParamsResponseFormatPython$outboundSchema.parse(chatGenerationParamsResponseFormatPython));
+export function responseFormatPythonToJSON(responseFormatPython) {
+    return JSON.stringify(ResponseFormatPython$outboundSchema.parse(responseFormatPython));
 }
 /** @internal */
-export const ChatGenerationParamsResponseFormatJSONObject$outboundSchema = z.object({
+export const ResponseFormatJSONObject$outboundSchema = z.object({
     type: z.literal("json_object"),
 });
-export function chatGenerationParamsResponseFormatJSONObjectToJSON(chatGenerationParamsResponseFormatJSONObject) {
-    return JSON.stringify(ChatGenerationParamsResponseFormatJSONObject$outboundSchema.parse(chatGenerationParamsResponseFormatJSONObject));
+export function responseFormatJSONObjectToJSON(responseFormatJSONObject) {
+    return JSON.stringify(ResponseFormatJSONObject$outboundSchema.parse(responseFormatJSONObject));
 }
 /** @internal */
-export const ChatGenerationParamsResponseFormatText$outboundSchema = z.object({
+export const ResponseFormatText$outboundSchema = z.object({
     type: z.literal("text"),
 });
-export function chatGenerationParamsResponseFormatTextToJSON(chatGenerationParamsResponseFormatText) {
-    return JSON.stringify(ChatGenerationParamsResponseFormatText$outboundSchema.parse(chatGenerationParamsResponseFormatText));
+export function responseFormatTextToJSON(responseFormatText) {
+    return JSON.stringify(ResponseFormatText$outboundSchema.parse(responseFormatText));
 }
 /** @internal */
-export const ChatGenerationParamsResponseFormatUnion$outboundSchema = z.union([
-    z.lazy(() => ChatGenerationParamsResponseFormatText$outboundSchema),
-    z.lazy(() => ChatGenerationParamsResponseFormatJSONObject$outboundSchema),
+export const ResponseFormat$outboundSchema = z.union([
+    z.lazy(() => ResponseFormatText$outboundSchema),
+    z.lazy(() => ResponseFormatJSONObject$outboundSchema),
     ResponseFormatJSONSchema$outboundSchema,
     ResponseFormatTextGrammar$outboundSchema,
-    z.lazy(() => ChatGenerationParamsResponseFormatPython$outboundSchema),
+    z.lazy(() => ResponseFormatPython$outboundSchema),
 ]);
-export function chatGenerationParamsResponseFormatUnionToJSON(chatGenerationParamsResponseFormatUnion) {
-    return JSON.stringify(ChatGenerationParamsResponseFormatUnion$outboundSchema.parse(chatGenerationParamsResponseFormatUnion));
+export function responseFormatToJSON(responseFormat) {
+    return JSON.stringify(ResponseFormat$outboundSchema.parse(responseFormat));
 }
 /** @internal */
-export const ChatGenerationParamsStop$outboundSchema = z.union([z.string(), z.array(z.string())]);
-export function chatGenerationParamsStopToJSON(chatGenerationParamsStop) {
-    return JSON.stringify(ChatGenerationParamsStop$outboundSchema.parse(chatGenerationParamsStop));
+export const Stop$outboundSchema = z.union([
+    z.string(),
+    z.array(z.string()),
+]);
+export function stopToJSON(stop) {
+    return JSON.stringify(Stop$outboundSchema.parse(stop));
 }
 /** @internal */
 export const Debug$outboundSchema = z.object({
@@ -314,11 +317,11 @@ export const ChatGenerationParams$outboundSchema = z.object({
     presencePenalty: z.nullable(z.number()).optional(),
     reasoning: z.lazy(() => Reasoning$outboundSchema).optional(),
     responseFormat: z.union([
-        z.lazy(() => ChatGenerationParamsResponseFormatText$outboundSchema),
-        z.lazy(() => ChatGenerationParamsResponseFormatJSONObject$outboundSchema),
+        z.lazy(() => ResponseFormatText$outboundSchema),
+        z.lazy(() => ResponseFormatJSONObject$outboundSchema),
         ResponseFormatJSONSchema$outboundSchema,
         ResponseFormatTextGrammar$outboundSchema,
-        z.lazy(() => ChatGenerationParamsResponseFormatPython$outboundSchema),
+        z.lazy(() => ResponseFormatPython$outboundSchema),
     ]).optional(),
     seed: z.nullable(z.int()).optional(),
     stop: z.nullable(z.union([z.string(), z.array(z.string())])).optional(),

package/esm/models/index.d.ts

@@ -22,11 +22,6 @@ export * from "./chatstreamingmessagechunk.js";
 export * from "./chatstreamingmessagetoolcall.js";
 export * from "./chatstreamingresponsechunk.js";
 export * from "./chatstreamoptions.js";
-export * from "./completionchoice.js";
-export * from "./completioncreateparams.js";
-export * from "./completionlogprobs.js";
-export * from "./completionresponse.js";
-export * from "./completionusage.js";
 export * from "./createchargerequest.js";
 export * from "./datacollection.js";
 export * from "./defaultparameters.js";

package/esm/models/index.js

@@ -26,11 +26,6 @@ export * from "./chatstreamingmessagechunk.js";
 export * from "./chatstreamingmessagetoolcall.js";
 export * from "./chatstreamingresponsechunk.js";
 export * from "./chatstreamoptions.js";
-export * from "./completionchoice.js";
-export * from "./completioncreateparams.js";
-export * from "./completionlogprobs.js";
-export * from "./completionresponse.js";
-export * from "./completionusage.js";
 export * from "./createchargerequest.js";
 export * from "./datacollection.js";
 export * from "./defaultparameters.js";