@openrouter/sdk 0.10.2 → 0.12.0

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

@@ -5,72 +5,94 @@ import type { ParsedToolCall, Tool } from './tool-types.js';
 /**
  * Extract text deltas from responses stream events
  */
-export declare function extractTextDeltas(stream: ReusableReadableStream<models.OpenResponsesStreamEvent>): AsyncIterableIterator<string>;
+export declare function extractTextDeltas(stream: ReusableReadableStream<models.StreamEvents>): AsyncIterableIterator<string>;
 /**
  * Extract reasoning deltas from responses stream events
  */
-export declare function extractReasoningDeltas(stream: ReusableReadableStream<models.OpenResponsesStreamEvent>): AsyncIterableIterator<string>;
+export declare function extractReasoningDeltas(stream: ReusableReadableStream<models.StreamEvents>): AsyncIterableIterator<string>;
 /**
  * Extract tool call argument deltas from responses stream events
  */
-export declare function extractToolDeltas(stream: ReusableReadableStream<models.OpenResponsesStreamEvent>): AsyncIterableIterator<string>;
+export declare function extractToolDeltas(stream: ReusableReadableStream<models.StreamEvents>): AsyncIterableIterator<string>;
 /**
  * Build incremental message updates from responses stream events
- * Returns ResponsesOutputMessage (assistant/responses format)
+ * Returns OutputMessage (assistant/responses format)
  */
-export declare function buildResponsesMessageStream(stream: ReusableReadableStream<models.OpenResponsesStreamEvent>): AsyncIterableIterator<models.ResponsesOutputMessage>;
+export declare function buildResponsesMessageStream(stream: ReusableReadableStream<models.StreamEvents>): AsyncIterableIterator<models.OutputMessage>;
 /**
  * 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;
+export type StreamableOutputItem = models.OutputMessage | models.OutputFunctionCallItem | models.OutputReasoningItem | models.OutputWebSearchCallItem | models.OutputFileSearchCallItem | models.OutputImageGenerationCallItem | models.FunctionCallOutputItem;
+/**
+ * Discriminated union for tracking items in progress.
+ * Each variant has only the fields relevant to that item type.
+ */
+export type ItemInProgress = {
+    type: 'message';
+    id: string;
+    textContent: string;
+} | {
+    type: 'function_call';
+    id: string;
+    name: string;
+    callId: string;
+    argumentsAccumulated: string;
+} | {
+    type: 'reasoning';
+    id: string;
+    reasoningContent: string;
+};
+type ItemsStreamHandler = (event: models.StreamEvents, itemsInProgress: Map<string, ItemInProgress>) => StreamableOutputItem | undefined;
+export declare const itemsStreamHandlers: Record<string, ItemsStreamHandler>;
+export declare const streamTerminationEvents: Set<string>;
 /**
  * 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>;
+export declare function buildItemsStream(stream: ReusableReadableStream<models.StreamEvents>): AsyncIterableIterator<StreamableOutputItem>;
 /**
  * Build incremental message updates from responses stream events
- * Returns AssistantMessage (chat format) instead of ResponsesOutputMessage
+ * Returns ChatAssistantMessage (chat format) instead of OutputMessage
  */
-export declare function buildMessageStream(stream: ReusableReadableStream<models.OpenResponsesStreamEvent>): AsyncIterableIterator<models.AssistantMessage>;
+export declare function buildMessageStream(stream: ReusableReadableStream<models.StreamEvents>): AsyncIterableIterator<models.ChatAssistantMessage>;
 /**
  * Consume stream until completion and return the complete response
  */
-export declare function consumeStreamForCompletion(stream: ReusableReadableStream<models.OpenResponsesStreamEvent>): Promise<models.OpenResponsesNonStreamingResponse>;
+export declare function consumeStreamForCompletion(stream: ReusableReadableStream<models.StreamEvents>): Promise<models.OpenResponsesResult>;
 /**
  * Extract the first message from a completed response (chat format)
  */
-export declare function extractMessageFromResponse(response: models.OpenResponsesNonStreamingResponse): models.AssistantMessage;
+export declare function extractMessageFromResponse(response: models.OpenResponsesResult): models.ChatAssistantMessage;
 /**
  * Extract the first message from a completed response (responses format)
  */
-export declare function extractResponsesMessageFromResponse(response: models.OpenResponsesNonStreamingResponse): models.ResponsesOutputMessage;
+export declare function extractResponsesMessageFromResponse(response: models.OpenResponsesResult): models.OutputMessage;
 /**
  * Extract text from a response, either from outputText or by concatenating message content
  */
-export declare function extractTextFromResponse(response: models.OpenResponsesNonStreamingResponse): string;
+export declare function extractTextFromResponse(response: models.OpenResponsesResult): string;
 /**
  * Extract all tool calls from a completed response
  * Returns parsed tool calls with arguments as objects (not JSON strings)
  */
-export declare function extractToolCallsFromResponse(response: models.OpenResponsesNonStreamingResponse): ParsedToolCall<Tool>[];
+export declare function extractToolCallsFromResponse(response: models.OpenResponsesResult): ParsedToolCall<Tool>[];
 /**
  * Build incremental tool call updates from responses stream events
  * Yields structured tool call objects as they're built from deltas
  */
-export declare function buildToolCallStream(stream: ReusableReadableStream<models.OpenResponsesStreamEvent>): AsyncIterableIterator<ParsedToolCall<Tool>>;
+export declare function buildToolCallStream(stream: ReusableReadableStream<models.StreamEvents>): AsyncIterableIterator<ParsedToolCall<Tool>>;
 /**
  * Check if a response contains any tool calls
  */
-export declare function responseHasToolCalls(response: models.OpenResponsesNonStreamingResponse): boolean;
+export declare function responseHasToolCalls(response: models.OpenResponsesResult): boolean;
 /**
- * Convert OpenResponsesNonStreamingResponse to ClaudeMessage format
+ * Convert OpenResponsesResult to ClaudeMessage format
  * Compatible with the Anthropic SDK BetaMessage type
  */
-export declare function convertToClaudeMessage(response: models.OpenResponsesNonStreamingResponse): ClaudeMessage;
+export declare function convertToClaudeMessage(response: models.OpenResponsesResult): ClaudeMessage;
 /**
  * Extract unsupported content by original type
  */
@@ -83,4 +105,5 @@ export declare function hasUnsupportedContent(message: ClaudeMessage): boolean;
  * Get summary of unsupported content types
  */
 export declare function getUnsupportedContentSummary(message: ClaudeMessage): Record<string, number>;
+export {};
 //# sourceMappingURL=stream-transformers.d.ts.map

package/esm/lib/stream-transformers.js

@@ -101,12 +101,12 @@ async function* buildMessageStreamCore(stream) {
 }
 /**
  * Build incremental message updates from responses stream events
- * Returns ResponsesOutputMessage (assistant/responses format)
+ * Returns OutputMessage (assistant/responses format)
  */
 export async function* buildResponsesMessageStream(stream) {
     for await (const update of buildMessageStreamCore(stream)) {
         if (update.type === 'delta' && update.text !== undefined && update.messageId !== undefined) {
-            // Yield incremental update in ResponsesOutputMessage format
+            // Yield incremental update in OutputMessage format
             yield {
                 id: update.messageId,
                 type: 'message',
@@ -296,14 +296,14 @@ function handleOutputItemDone(event, itemsInProgress) {
     }
     return undefined;
 }
-const itemsStreamHandlers = {
+export 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([
+export const streamTerminationEvents = new Set([
     'response.completed',
     'response.failed',
     'response.incomplete',
@@ -335,7 +335,7 @@ export async function* buildItemsStream(stream) {
 }
 /**
  * Build incremental message updates from responses stream events
- * Returns AssistantMessage (chat format) instead of ResponsesOutputMessage
+ * Returns ChatAssistantMessage (chat format) instead of OutputMessage
  */
 export async function* buildMessageStream(stream) {
     for await (const update of buildMessageStreamCore(stream)) {
@@ -376,7 +376,7 @@ export async function consumeStreamForCompletion(stream) {
     throw new Error('Stream ended without completion event');
 }
 /**
- * Convert ResponsesOutputMessage to AssistantMessage (chat format)
+ * Convert OutputMessage to ChatAssistantMessage (chat format)
  */
 function convertToAssistantMessage(outputMessage) {
     // Extract text content
@@ -423,9 +423,9 @@ export function extractTextFromResponse(response) {
         // No message in response (e.g., only function calls)
         return '';
     }
-    // Otherwise, extract from the first message (convert to AssistantMessage which has string content)
+    // Otherwise, extract from the first message (convert to ChatAssistantMessage which has string content)
     const message = extractMessageFromResponse(response);
-    // AssistantMessage.content is string | Array | null | undefined
+    // ChatAssistantMessage.content is string | Array | null | undefined
     if (typeof message.content === 'string') {
         return message.content;
     }
@@ -644,7 +644,7 @@ function mapStopReason(response) {
     return 'end_turn';
 }
 /**
- * Convert OpenResponsesNonStreamingResponse to ClaudeMessage format
+ * Convert OpenResponsesResult to ClaudeMessage format
  * Compatible with the Anthropic SDK BetaMessage type
  */
 export function convertToClaudeMessage(response) {

package/esm/lib/stream-type-guards.d.ts

@@ -3,21 +3,21 @@ import type * as models from '../models/index.js';
  * Type guards for OpenResponses stream events
  * These enable proper TypeScript narrowing without type casts
  */
-export declare function isOutputTextDeltaEvent(event: models.OpenResponsesStreamEvent): event is models.OpenResponsesStreamEventResponseOutputTextDelta;
-export declare function isReasoningDeltaEvent(event: models.OpenResponsesStreamEvent): event is models.OpenResponsesReasoningDeltaEvent;
-export declare function isFunctionCallArgumentsDeltaEvent(event: models.OpenResponsesStreamEvent): event is models.OpenResponsesStreamEventResponseFunctionCallArgumentsDelta;
-export declare function isOutputItemAddedEvent(event: models.OpenResponsesStreamEvent): event is models.OpenResponsesStreamEventResponseOutputItemAdded;
-export declare function isOutputItemDoneEvent(event: models.OpenResponsesStreamEvent): event is models.OpenResponsesStreamEventResponseOutputItemDone;
-export declare function isResponseCompletedEvent(event: models.OpenResponsesStreamEvent): event is models.OpenResponsesStreamEventResponseCompleted;
-export declare function isResponseFailedEvent(event: models.OpenResponsesStreamEvent): event is models.OpenResponsesStreamEventResponseFailed;
-export declare function isResponseIncompleteEvent(event: models.OpenResponsesStreamEvent): event is models.OpenResponsesStreamEventResponseIncomplete;
-export declare function isFunctionCallArgumentsDoneEvent(event: models.OpenResponsesStreamEvent): event is models.OpenResponsesStreamEventResponseFunctionCallArgumentsDone;
-export declare function isOutputMessage(item: unknown): item is models.ResponsesOutputMessage;
-export declare function isFunctionCallItem(item: unknown): item is models.ResponsesOutputItemFunctionCall;
-export declare function isReasoningOutputItem(item: unknown): item is models.ResponsesOutputItemReasoning;
-export declare function isWebSearchCallOutputItem(item: unknown): item is models.ResponsesWebSearchCallOutput;
-export declare function isFileSearchCallOutputItem(item: unknown): item is models.ResponsesOutputItemFileSearchCall;
-export declare function isImageGenerationCallOutputItem(item: unknown): item is models.ResponsesImageGenerationCall;
+export declare function isOutputTextDeltaEvent(event: models.StreamEvents): event is models.TextDeltaEvent;
+export declare function isReasoningDeltaEvent(event: models.StreamEvents): event is models.ReasoningDeltaEvent;
+export declare function isFunctionCallArgumentsDeltaEvent(event: models.StreamEvents): event is models.FunctionCallArgsDeltaEvent;
+export declare function isOutputItemAddedEvent(event: models.StreamEvents): event is models.StreamEventsResponseOutputItemAdded;
+export declare function isOutputItemDoneEvent(event: models.StreamEvents): event is models.StreamEventsResponseOutputItemDone;
+export declare function isResponseCompletedEvent(event: models.StreamEvents): event is models.StreamEventsResponseCompleted;
+export declare function isResponseFailedEvent(event: models.StreamEvents): event is models.StreamEventsResponseFailed;
+export declare function isResponseIncompleteEvent(event: models.StreamEvents): event is models.StreamEventsResponseIncomplete;
+export declare function isFunctionCallArgumentsDoneEvent(event: models.StreamEvents): event is models.FunctionCallArgsDoneEvent;
+export declare function isOutputMessage(item: unknown): item is models.OutputMessage;
+export declare function isFunctionCallItem(item: unknown): item is models.OutputFunctionCallItem;
+export declare function isReasoningOutputItem(item: unknown): item is models.OutputReasoningItem;
+export declare function isWebSearchCallOutputItem(item: unknown): item is models.OutputWebSearchCallItem;
+export declare function isFileSearchCallOutputItem(item: unknown): item is models.OutputFileSearchCallItem;
+export declare function isImageGenerationCallOutputItem(item: unknown): item is models.OutputImageGenerationCallItem;
 export declare function isOutputTextPart(part: unknown): part is models.ResponseOutputText;
 export declare function isRefusalPart(part: unknown): part is models.OpenAIResponsesRefusalContent;
 export declare function isFileCitationAnnotation(annotation: unknown): annotation is models.FileCitation;

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

@@ -10,10 +10,10 @@ export interface ToolExecutionOptions {
  * Result of the tool execution loop
  */
 export interface ToolOrchestrationResult {
-    finalResponse: models.OpenResponsesNonStreamingResponse;
-    allResponses: models.OpenResponsesNonStreamingResponse[];
+    finalResponse: models.OpenResponsesResult;
+    allResponses: models.OpenResponsesResult[];
     toolExecutionResults: ToolExecutionResult<Tool>[];
-    conversationInput: models.OpenResponsesInputUnion;
+    conversationInput: models.InputsUnion;
 }
 /**
  * Execute tool calls and manage multi-turn conversations
@@ -27,7 +27,7 @@ export interface ToolOrchestrationResult {
  * @param options - Execution options
  * @returns Result containing final response and all execution data
  */
-export declare function executeToolLoop(sendRequest: (input: models.OpenResponsesInputUnion, tools: APITool[]) => Promise<models.OpenResponsesNonStreamingResponse>, initialInput: models.OpenResponsesInputUnion, initialRequest: models.OpenResponsesRequest, tools: Tool[], apiTools: APITool[], options?: ToolExecutionOptions): Promise<ToolOrchestrationResult>;
+export declare function executeToolLoop(sendRequest: (input: models.InputsUnion, tools: APITool[]) => Promise<models.OpenResponsesResult>, initialInput: models.InputsUnion, initialRequest: models.ResponsesRequest, tools: Tool[], apiTools: APITool[], options?: ToolExecutionOptions): Promise<ToolOrchestrationResult>;
 /**
  * Convert tool execution results to a map for easy lookup
  */

package/esm/lib/tool-orchestrator.js

@@ -65,7 +65,7 @@ export async function executeToolLoop(sendRequest, initialInput, initialRequest,
             if (!rawToolCall) {
                 throw new Error(`Could not find raw tool call for ${toolCall.id}`);
             }
-            // Convert to OpenResponsesFunctionToolCall format
+            // Convert to FunctionCallItem format
             const openResponsesToolCall = {
                 type: 'function_call',
                 callId: rawToolCall.callId,

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

@@ -1,6 +1,6 @@
 import type { $ZodObject, $ZodShape, $ZodType, infer as zodInfer } from 'zod/v4/core';
 import type * as models from '../models/index.js';
-import type { OpenResponsesStreamEvent } from '../models/index.js';
+import type { StreamEvents } from '../models/index.js';
 import type { ModelResult } from './model-result.js';
 /**
  * Tool type enum for enhanced tools
@@ -14,11 +14,11 @@ export declare enum ToolType {
  */
 export interface TurnContext {
     /** The specific tool call being executed (only available during tool execution) */
-    toolCall?: models.OpenResponsesFunctionToolCall;
+    toolCall?: models.FunctionCallItem;
     /** Number of tool execution turns so far (1-indexed: first turn = 1, 0 = initial request) */
     numberOfTurns: number;
     /** The full request being sent to the API (only available during tool execution) */
-    turnRequest?: models.OpenResponsesRequest;
+    turnRequest?: models.ResponsesRequest;
 }
 /**
  * Extract context schema type from a tool definition
@@ -83,7 +83,7 @@ export declare const SHARED_CONTEXT_KEY: "shared";
  */
 export type NextTurnParamsContext = {
     /** Current input (messages) */
-    input: models.OpenResponsesInputUnion;
+    input: models.InputsUnion;
     /** Current model selection */
     model: string;
     /** Current models array */
@@ -315,8 +315,8 @@ export interface StepResult<TTools extends readonly Tool[] = readonly Tool[]> {
     readonly text: string;
     readonly toolCalls: TypedToolCallUnion<TTools>[];
     readonly toolResults: ToolExecutionResultUnion<TTools>[];
-    readonly response: models.OpenResponsesNonStreamingResponse;
-    readonly usage?: models.OpenResponsesUsage | null | undefined;
+    readonly response: models.OpenResponsesResult;
+    readonly usage?: models.Usage | null | undefined;
     readonly finishReason?: string | undefined;
     readonly warnings?: Warning[] | undefined;
     readonly experimental_providerMetadata?: Record<string, unknown> | undefined;
@@ -347,7 +347,7 @@ export interface ExecuteToolsResult<TTools extends readonly Tool[]> {
 }
 /**
  * Standard tool format for OpenRouter API (JSON Schema based)
- * Matches OpenResponsesRequestToolFunction structure
+ * Matches ResponsesRequestToolFunction structure
  */
 export interface APITool {
     type: 'function';
@@ -381,6 +381,16 @@ export type ToolResultEvent<TResult = unknown, TPreliminaryResults = unknown> =
     timestamp: number;
     preliminaryResults?: TPreliminaryResults[];
 };
+/**
+ * Tool call output event carrying the fully-formed FunctionCallOutputItem.
+ * Broadcast by executeToolRound so passive consumers (getItemsStream) can yield
+ * tool results in real-time without owning tool execution.
+ */
+export type ToolCallOutputEvent = {
+    type: 'tool.call_output';
+    output: models.FunctionCallOutputItem;
+    timestamp: number;
+};
 /**
  * Turn start event emitted at the beginning of each API turn
  * Turn 0 is the initial request, subsequent turns follow tool execution
@@ -400,12 +410,12 @@ export type TurnEndEvent = {
 };
 /**
  * Enhanced stream event types for getFullResponsesStream
- * Extends OpenResponsesStreamEvent with tool preliminary results, tool results,
+ * Extends StreamEvents with tool preliminary results, tool results,
  * and turn delimiter events for multi-turn streaming
  * @template TEvent - The event type from generator tools
  * @template TResult - The result type from tool execution
  */
-export type ResponseStreamEvent<TEvent = unknown, TResult = unknown> = OpenResponsesStreamEvent | ToolPreliminaryResultEvent<TEvent> | ToolResultEvent<TResult, TEvent> | TurnStartEvent | TurnEndEvent;
+export type ResponseStreamEvent<TEvent = unknown, TResult = unknown> = StreamEvents | ToolPreliminaryResultEvent<TEvent> | ToolResultEvent<TResult, TEvent> | ToolCallOutputEvent | TurnStartEvent | TurnEndEvent;
 /**
  * Type guard to check if an event is a tool preliminary result event
  */
@@ -414,6 +424,10 @@ export declare function isToolPreliminaryResultEvent<TEvent = unknown>(event: Re
  * Type guard to check if an event is a tool result event
  */
 export declare function isToolResultEvent<TResult = unknown, TPreliminaryResults = unknown>(event: ResponseStreamEvent<TPreliminaryResults, TResult>): event is ToolResultEvent<TResult, TPreliminaryResults>;
+/**
+ * Type guard to check if an event is a tool call output event
+ */
+export declare function isToolCallOutputEvent(event: ResponseStreamEvent): event is ToolCallOutputEvent;
 /**
  * Type guard to check if an event is a turn start event
  */
@@ -445,14 +459,14 @@ export type ChatStreamEvent<TEvent = unknown> = {
     delta: string;
 } | {
     type: 'message.complete';
-    response: models.OpenResponsesNonStreamingResponse;
+    response: models.OpenResponsesResult;
 } | {
     type: 'tool.preliminary_result';
     toolCallId: string;
     result: TEvent;
 } | {
     type: string;
-    event: OpenResponsesStreamEvent;
+    event: StreamEvents;
 };
 /**
  * Result of a tool execution that hasn't been sent to the model yet
@@ -491,7 +505,7 @@ export interface ConversationState<TTools extends readonly Tool[] = readonly Too
     /** Unique identifier for this conversation */
     id: string;
     /** Full message history */
-    messages: models.OpenResponsesInputUnion;
+    messages: models.InputsUnion;
     /** Previous response ID for chaining (OpenRouter server-side optimization) */
     previousResponseId?: string;
     /** Tool calls awaiting human approval */

package/esm/lib/tool-types.js

@@ -46,6 +46,12 @@ export function isToolPreliminaryResultEvent(event) {
 export function isToolResultEvent(event) {
     return event.type === 'tool.result';
 }
+/**
+ * Type guard to check if an event is a tool call output event
+ */
+export function isToolCallOutputEvent(event) {
+    return event.type === 'tool.call_output';
+}
 /**
  * Type guard to check if an event is a turn start event
  */

package/esm/lib/turn-context.d.ts

@@ -7,9 +7,9 @@ export interface BuildTurnContextOptions {
     /** Number of turns so far (1-indexed for tool execution, 0 for initial request) */
     numberOfTurns: number;
     /** The specific tool call being executed (optional for initial/async resolution contexts) */
-    toolCall?: models.OpenResponsesFunctionToolCall;
+    toolCall?: models.FunctionCallItem;
     /** The full request being sent to the API (optional for initial/async resolution contexts) */
-    turnRequest?: models.OpenResponsesRequest;
+    turnRequest?: models.ResponsesRequest;
 }
 /**
  * Build a turn context for tool execution or async parameter resolution
@@ -46,5 +46,5 @@ export declare function buildTurnContext(options: BuildTurnContextOptions): Turn
  * // Returns: [{ role: "user", content: "Hello!" }]
  * ```
  */
-export declare function normalizeInputToArray(input: models.OpenResponsesInputUnion): Array<models.OpenResponsesInputUnion1>;
+export declare function normalizeInputToArray(input: models.InputsUnion): Array<models.BaseInputsUnion>;
 //# sourceMappingURL=turn-context.d.ts.map

package/esm/lib/turn-context.js

@@ -49,7 +49,7 @@ export function normalizeInputToArray(input) {
     if (typeof input === 'string') {
         // Construct object with all required fields - type is optional
         const message = {
-            role: models.OpenResponsesEasyInputMessageRoleUser.User,
+            role: models.EasyInputMessageRoleUser.User,
             content: input,
         };
         return [message];

package/esm/lib/url.js

@@ -6,7 +6,8 @@ const hasOwn = Object.prototype.hasOwnProperty;
 export function pathToFunc(pathPattern, options) {
     const paramRE = /\{([a-zA-Z0-9_][a-zA-Z0-9_-]*?)\}/g;
     return function buildURLPath(params = {}) {
-        return pathPattern.replace(paramRE, function (_, placeholder) {
+        return pathPattern
+            .replace(paramRE, function (_, placeholder) {
             if (!hasOwn.call(params, placeholder)) {
                 throw new Error(`Parameter '${placeholder}' is required`);
             }
@@ -17,7 +18,8 @@ export function pathToFunc(pathPattern, options) {
             return options?.charEncoding === "percent"
                 ? encodeURIComponent(`${value}`)
                 : `${value}`;
-        });
+        })
+            .replace(/^\/+/, "");
     };
 }
 //# sourceMappingURL=url.js.map

package/esm/models/activityitem.d.ts

@@ -2,10 +2,22 @@ import * as z from "zod/v4";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 export type ActivityItem = {
+    /**
+     * BYOK inference cost in USD (external credits spent)
+     */
+    byokUsageInference: number;
+    /**
+     * Total completion tokens generated
+     */
+    completionTokens: number;
     /**
      * Date of the activity (YYYY-MM-DD format)
      */
     date: string;
+    /**
+     * Unique identifier for the endpoint
+     */
+    endpointId: string;
     /**
      * Model slug (e.g., "openai/gpt-4.1")
      */
@@ -15,37 +27,25 @@ export type ActivityItem = {
      */
     modelPermaslug: string;
     /**
-     * Unique identifier for the endpoint
+     * Total prompt tokens used
      */
-    endpointId: string;
+    promptTokens: number;
     /**
      * Name of the provider serving this endpoint
      */
     providerName: string;
     /**
-     * Total cost in USD (OpenRouter credits spent)
-     */
-    usage: number;
-    /**
-     * BYOK inference cost in USD (external credits spent)
+     * Total reasoning tokens used
      */
-    byokUsageInference: number;
+    reasoningTokens: number;
     /**
      * Number of requests made
      */
     requests: number;
     /**
-     * Total prompt tokens used
-     */
-    promptTokens: number;
-    /**
-     * Total completion tokens generated
-     */
-    completionTokens: number;
-    /**
-     * Total reasoning tokens used
+     * Total cost in USD (OpenRouter credits spent)
      */
-    reasoningTokens: number;
+    usage: number;
 };
 /** @internal */
 export declare const ActivityItem$inboundSchema: z.ZodType<ActivityItem, unknown>;

package/esm/models/activityitem.js

@@ -8,25 +8,25 @@ import { safeParse } from "../lib/schemas.js";
 /** @internal */
 export const ActivityItem$inboundSchema = z
     .object({
+    byok_usage_inference: z.number(),
+    completion_tokens: z.int(),
     date: z.string(),
+    endpoint_id: z.string(),
     model: z.string(),
     model_permaslug: z.string(),
-    endpoint_id: z.string(),
+    prompt_tokens: z.int(),
     provider_name: z.string(),
+    reasoning_tokens: z.int(),
+    requests: z.int(),
     usage: z.number(),
-    byok_usage_inference: z.number(),
-    requests: z.number(),
-    prompt_tokens: z.number(),
-    completion_tokens: z.number(),
-    reasoning_tokens: z.number(),
 }).transform((v) => {
     return remap$(v, {
-        "model_permaslug": "modelPermaslug",
-        "endpoint_id": "endpointId",
-        "provider_name": "providerName",
         "byok_usage_inference": "byokUsageInference",
-        "prompt_tokens": "promptTokens",
         "completion_tokens": "completionTokens",
+        "endpoint_id": "endpointId",
+        "model_permaslug": "modelPermaslug",
+        "prompt_tokens": "promptTokens",
+        "provider_name": "providerName",
         "reasoning_tokens": "reasoningTokens",
     });
 });

package/esm/models/activityresponse.d.ts

@@ -0,0 +1,14 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { ActivityItem } from "./activityitem.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export type ActivityResponse = {
+    /**
+     * List of activity items
+     */
+    data: Array<ActivityItem>;
+};
+/** @internal */
+export declare const ActivityResponse$inboundSchema: z.ZodType<ActivityResponse, unknown>;
+export declare function activityResponseFromJSON(jsonString: string): SafeParseResult<ActivityResponse, SDKValidationError>;
+//# sourceMappingURL=activityresponse.d.ts.map

package/esm/models/activityresponse.js

@@ -0,0 +1,15 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: c535306a4318
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+import { ActivityItem$inboundSchema } from "./activityitem.js";
+/** @internal */
+export const ActivityResponse$inboundSchema = z.object({
+    data: z.array(ActivityItem$inboundSchema),
+});
+export function activityResponseFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ActivityResponse$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ActivityResponse' from JSON`);
+}
+//# sourceMappingURL=activityresponse.js.map

package/esm/models/annotationaddedevent.d.ts

@@ -0,0 +1,20 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { OpenAIResponsesAnnotation } from "./openairesponsesannotation.js";
+/**
+ * Event emitted when a text annotation is added to output
+ */
+export type AnnotationAddedEvent = {
+    annotation: OpenAIResponsesAnnotation;
+    annotationIndex: number;
+    contentIndex: number;
+    itemId: string;
+    outputIndex: number;
+    sequenceNumber: number;
+    type: "response.output_text.annotation.added";
+};
+/** @internal */
+export declare const AnnotationAddedEvent$inboundSchema: z.ZodType<AnnotationAddedEvent, unknown>;
+export declare function annotationAddedEventFromJSON(jsonString: string): SafeParseResult<AnnotationAddedEvent, SDKValidationError>;
+//# sourceMappingURL=annotationaddedevent.d.ts.map

package/esm/models/annotationaddedevent.js

@@ -0,0 +1,30 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: e5c5f2adf5f6
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { OpenAIResponsesAnnotation$inboundSchema, } from "./openairesponsesannotation.js";
+/** @internal */
+export const AnnotationAddedEvent$inboundSchema = z.object({
+    annotation: OpenAIResponsesAnnotation$inboundSchema,
+    annotation_index: z.int(),
+    content_index: z.int(),
+    item_id: z.string(),
+    output_index: z.int(),
+    sequence_number: z.int(),
+    type: z.literal("response.output_text.annotation.added"),
+}).transform((v) => {
+    return remap$(v, {
+        "annotation_index": "annotationIndex",
+        "content_index": "contentIndex",
+        "item_id": "itemId",
+        "output_index": "outputIndex",
+        "sequence_number": "sequenceNumber",
+    });
+});
+export function annotationAddedEventFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => AnnotationAddedEvent$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AnnotationAddedEvent' from JSON`);
+}
+//# sourceMappingURL=annotationaddedevent.js.map