@yourgpt/llm-sdk 2.6.0-beta.0 → 2.6.0-beta.2

package/dist/audio-BBSwnjo8.d.mts

@@ -0,0 +1,92 @@
+/** Audio models are independent of chat models and chat streaming events. */
+type SpeechFormat = "mp3" | "opus" | "aac" | "flac" | "wav" | "pcm";
+interface AudioResponseMetadata {
+    provider: string;
+    modelId: string;
+    requestId?: string;
+    status?: number;
+}
+interface AudioWarning {
+    code: string;
+    message: string;
+}
+interface SpeechOptions {
+    text: string;
+    voice?: string;
+    outputFormat?: SpeechFormat;
+    speed?: number;
+    instructions?: string;
+    signal?: AbortSignal;
+    providerOptions?: Record<string, Record<string, unknown>>;
+}
+interface GeneratedSpeech {
+    audio: {
+        uint8Array: Uint8Array;
+        readonly base64: string;
+        mediaType: string;
+        format: SpeechFormat;
+    };
+    response: AudioResponseMetadata;
+    warnings: AudioWarning[];
+    usage?: Record<string, unknown>;
+}
+interface SpeechModel {
+    readonly provider: string;
+    readonly modelId: string;
+    doGenerate(options: SpeechOptions): Promise<GeneratedSpeech>;
+}
+interface TranscriptionOptions {
+    /** Recorded file bytes, base64, or a Blob. URLs and raw PCM are not fetched/decoded. */
+    audio: Uint8Array | ArrayBuffer | Blob | string;
+    mediaType?: string;
+    filename?: string;
+    language?: string;
+    prompt?: string;
+    signal?: AbortSignal;
+    providerOptions?: Record<string, Record<string, unknown>>;
+}
+interface TranscriptSegment {
+    text: string;
+    start: number;
+    end: number;
+    speaker?: string;
+}
+interface TranscriptionResult {
+    text: string;
+    language?: string;
+    durationSeconds?: number;
+    segments?: TranscriptSegment[];
+    words?: Array<{
+        word: string;
+        start: number;
+        end: number;
+    }>;
+    response: AudioResponseMetadata;
+    warnings: AudioWarning[];
+    usage?: Record<string, unknown>;
+    /** Provider-supplied extras, including log probabilities when requested. */
+    providerMetadata?: Record<string, unknown>;
+}
+interface TranscriptionModel {
+    readonly provider: string;
+    readonly modelId: string;
+    doTranscribe(options: TranscriptionOptions): Promise<TranscriptionResult>;
+}
+declare const audioErrorMarker: unique symbol;
+declare class AudioAPIError extends Error {
+    readonly code: "invalid_input" | "unsupported_option" | "provider_error" | "invalid_response" | "network_error";
+    readonly status?: number | undefined;
+    readonly requestId?: string | undefined;
+    readonly [audioErrorMarker] = true;
+    static [Symbol.hasInstance](value: unknown): boolean;
+    readonly name = "AudioAPIError";
+    constructor(message: string, code: "invalid_input" | "unsupported_option" | "provider_error" | "invalid_response" | "network_error", status?: number | undefined, requestId?: string | undefined);
+}
+declare function generateSpeech({ model, ...options }: SpeechOptions & {
+    model: SpeechModel;
+}): Promise<GeneratedSpeech>;
+declare function transcribe({ model, ...options }: TranscriptionOptions & {
+    model: TranscriptionModel;
+}): Promise<TranscriptionResult>;
+
+export { AudioAPIError as A, type GeneratedSpeech as G, type SpeechModel as S, type TranscriptionModel as T, type SpeechOptions as a, type TranscriptionOptions as b, type TranscriptionResult as c, type SpeechFormat as d, type TranscriptSegment as e, type AudioResponseMetadata as f, generateSpeech as g, type AudioWarning as h, transcribe as t };

package/dist/audio-BBSwnjo8.d.ts

@@ -0,0 +1,92 @@
+/** Audio models are independent of chat models and chat streaming events. */
+type SpeechFormat = "mp3" | "opus" | "aac" | "flac" | "wav" | "pcm";
+interface AudioResponseMetadata {
+    provider: string;
+    modelId: string;
+    requestId?: string;
+    status?: number;
+}
+interface AudioWarning {
+    code: string;
+    message: string;
+}
+interface SpeechOptions {
+    text: string;
+    voice?: string;
+    outputFormat?: SpeechFormat;
+    speed?: number;
+    instructions?: string;
+    signal?: AbortSignal;
+    providerOptions?: Record<string, Record<string, unknown>>;
+}
+interface GeneratedSpeech {
+    audio: {
+        uint8Array: Uint8Array;
+        readonly base64: string;
+        mediaType: string;
+        format: SpeechFormat;
+    };
+    response: AudioResponseMetadata;
+    warnings: AudioWarning[];
+    usage?: Record<string, unknown>;
+}
+interface SpeechModel {
+    readonly provider: string;
+    readonly modelId: string;
+    doGenerate(options: SpeechOptions): Promise<GeneratedSpeech>;
+}
+interface TranscriptionOptions {
+    /** Recorded file bytes, base64, or a Blob. URLs and raw PCM are not fetched/decoded. */
+    audio: Uint8Array | ArrayBuffer | Blob | string;
+    mediaType?: string;
+    filename?: string;
+    language?: string;
+    prompt?: string;
+    signal?: AbortSignal;
+    providerOptions?: Record<string, Record<string, unknown>>;
+}
+interface TranscriptSegment {
+    text: string;
+    start: number;
+    end: number;
+    speaker?: string;
+}
+interface TranscriptionResult {
+    text: string;
+    language?: string;
+    durationSeconds?: number;
+    segments?: TranscriptSegment[];
+    words?: Array<{
+        word: string;
+        start: number;
+        end: number;
+    }>;
+    response: AudioResponseMetadata;
+    warnings: AudioWarning[];
+    usage?: Record<string, unknown>;
+    /** Provider-supplied extras, including log probabilities when requested. */
+    providerMetadata?: Record<string, unknown>;
+}
+interface TranscriptionModel {
+    readonly provider: string;
+    readonly modelId: string;
+    doTranscribe(options: TranscriptionOptions): Promise<TranscriptionResult>;
+}
+declare const audioErrorMarker: unique symbol;
+declare class AudioAPIError extends Error {
+    readonly code: "invalid_input" | "unsupported_option" | "provider_error" | "invalid_response" | "network_error";
+    readonly status?: number | undefined;
+    readonly requestId?: string | undefined;
+    readonly [audioErrorMarker] = true;
+    static [Symbol.hasInstance](value: unknown): boolean;
+    readonly name = "AudioAPIError";
+    constructor(message: string, code: "invalid_input" | "unsupported_option" | "provider_error" | "invalid_response" | "network_error", status?: number | undefined, requestId?: string | undefined);
+}
+declare function generateSpeech({ model, ...options }: SpeechOptions & {
+    model: SpeechModel;
+}): Promise<GeneratedSpeech>;
+declare function transcribe({ model, ...options }: TranscriptionOptions & {
+    model: TranscriptionModel;
+}): Promise<TranscriptionResult>;
+
+export { AudioAPIError as A, type GeneratedSpeech as G, type SpeechModel as S, type TranscriptionModel as T, type SpeechOptions as a, type TranscriptionOptions as b, type TranscriptionResult as c, type SpeechFormat as d, type TranscriptSegment as e, type AudioResponseMetadata as f, generateSpeech as g, type AudioWarning as h, transcribe as t };

package/dist/{base-tNgbBaSo.d.mts → base-BICaQaRS.d.mts}

@@ -1,10 +1,12 @@
-import { M as Message, A as ActionDefinition, d as ToolDefinition, R as ResponseFormat, W as WebSearchConfig, P as ProviderToolRuntimeOptions, g as StreamEvent, J as TokenUsage, X as LLMConfig, a6 as MessageAttachment } from './types-BkQCSiIt.mjs';
+import { M as Message, A as ActionDefinition, e as ToolDefinition, O as OpenAITransportOptions, h as OpenAIReasoningEffort, R as ResponseFormat, W as WebSearchConfig, l as ProviderToolRuntimeOptions, i as StreamEvent, P as ProviderMetadata, V as TokenUsage, $ as LLMConfig, c as ToolModelOutput, af as MessageAttachment } from './types-Dg1Bcg1k.mjs';
 
 /**
  * Request-level LLM configuration overrides
  */
 interface RequestLLMConfig {
+    openai?: OpenAITransportOptions;
     model?: string;
+    reasoningEffort?: OpenAIReasoningEffort;
     temperature?: number;
     maxTokens?: number;
     responseFormat?: ResponseFormat;
@@ -45,6 +47,7 @@ interface ChatCompletionRequest {
  * Non-streaming completion result
  */
 interface CompletionResult {
+    providerMetadata?: ProviderMetadata;
     /** Text content */
     content: string;
     /** Tool calls */
@@ -207,7 +210,7 @@ type AnthropicToolUseBlock = {
 type AnthropicToolResultBlock = {
     type: "tool_result";
     tool_use_id: string;
-    content: string;
+    content: string | Array<Record<string, unknown>>;
 };
 type AnthropicMessageContent = string | Array<AnthropicContentBlock | AnthropicToolUseBlock | AnthropicToolResultBlock>;
 /**
@@ -236,6 +239,7 @@ type OpenAIMessage = {
     content: string | OpenAIContentBlock[];
 } | {
     role: "assistant";
+    providerMetadata?: ProviderMetadata;
     content: string | null;
     tool_calls?: Array<{
         id: string;
@@ -249,11 +253,12 @@ type OpenAIMessage = {
     role: "tool";
     content: string;
     tool_call_id: string;
+    modelOutput?: ToolModelOutput;
 };
 /**
  * Format messages for OpenAI with full tool support
  * Handles: text, images, tool_calls, and tool results
  */
-declare function formatMessagesForOpenAI(messages: Message[], systemPrompt?: string): OpenAIMessage[];
+declare function formatMessagesForOpenAI(messages: Message[], systemPrompt?: string, preserveProviderMetadata?: boolean): OpenAIMessage[];
 
 export { type AdapterFactory as A, type ChatCompletionRequest as C, type LLMAdapter as L, type OpenAIContentBlock as O, type CompletionResult as a, formatTools as b, formatMessagesForAnthropic as c, formatMessagesForOpenAI as d, messageToOpenAIContent as e, formatMessages as f, hasMediaAttachments as g, hasImageAttachments as h, attachmentToAnthropicImage as i, attachmentToAnthropicDocument as j, attachmentToOpenAIImage as k, type AnthropicContentBlock as l, messageToAnthropicContent as m };

package/dist/{base-C58Dsr9p.d.ts → base-CpRPB8u8.d.ts}

@@ -1,10 +1,12 @@
-import { M as Message, A as ActionDefinition, d as ToolDefinition, R as ResponseFormat, W as WebSearchConfig, P as ProviderToolRuntimeOptions, g as StreamEvent, J as TokenUsage, X as LLMConfig, a6 as MessageAttachment } from './types-BkQCSiIt.js';
+import { M as Message, A as ActionDefinition, e as ToolDefinition, O as OpenAITransportOptions, h as OpenAIReasoningEffort, R as ResponseFormat, W as WebSearchConfig, l as ProviderToolRuntimeOptions, i as StreamEvent, P as ProviderMetadata, V as TokenUsage, $ as LLMConfig, c as ToolModelOutput, af as MessageAttachment } from './types-Dg1Bcg1k.js';
 
 /**
  * Request-level LLM configuration overrides
  */
 interface RequestLLMConfig {
+    openai?: OpenAITransportOptions;
     model?: string;
+    reasoningEffort?: OpenAIReasoningEffort;
     temperature?: number;
     maxTokens?: number;
     responseFormat?: ResponseFormat;
@@ -45,6 +47,7 @@ interface ChatCompletionRequest {
  * Non-streaming completion result
  */
 interface CompletionResult {
+    providerMetadata?: ProviderMetadata;
     /** Text content */
     content: string;
     /** Tool calls */
@@ -207,7 +210,7 @@ type AnthropicToolUseBlock = {
 type AnthropicToolResultBlock = {
     type: "tool_result";
     tool_use_id: string;
-    content: string;
+    content: string | Array<Record<string, unknown>>;
 };
 type AnthropicMessageContent = string | Array<AnthropicContentBlock | AnthropicToolUseBlock | AnthropicToolResultBlock>;
 /**
@@ -236,6 +239,7 @@ type OpenAIMessage = {
     content: string | OpenAIContentBlock[];
 } | {
     role: "assistant";
+    providerMetadata?: ProviderMetadata;
     content: string | null;
     tool_calls?: Array<{
         id: string;
@@ -249,11 +253,12 @@ type OpenAIMessage = {
     role: "tool";
     content: string;
     tool_call_id: string;
+    modelOutput?: ToolModelOutput;
 };
 /**
  * Format messages for OpenAI with full tool support
  * Handles: text, images, tool_calls, and tool results
  */
-declare function formatMessagesForOpenAI(messages: Message[], systemPrompt?: string): OpenAIMessage[];
+declare function formatMessagesForOpenAI(messages: Message[], systemPrompt?: string, preserveProviderMetadata?: boolean): OpenAIMessage[];
 
 export { type AdapterFactory as A, type ChatCompletionRequest as C, type LLMAdapter as L, type OpenAIContentBlock as O, type CompletionResult as a, formatTools as b, formatMessagesForAnthropic as c, formatMessagesForOpenAI as d, messageToOpenAIContent as e, formatMessages as f, hasMediaAttachments as g, hasImageAttachments as h, attachmentToAnthropicImage as i, attachmentToAnthropicDocument as j, attachmentToOpenAIImage as k, type AnthropicContentBlock as l, messageToAnthropicContent as m };

package/dist/fallback/index.d.mts

@@ -1,7 +1,7 @@
-import { L as LLMAdapter } from '../base-tNgbBaSo.mjs';
-import { F as FallbackChainConfig, c as FallbackFailure, R as RoutingStore } from '../types-B6dhnguR.mjs';
-export { d as FallbackInfo, b as RetryBackoff, e as RetryInfo, a as RoutingStrategy } from '../types-B6dhnguR.mjs';
-import '../types-BkQCSiIt.mjs';
+import { L as LLMAdapter } from '../base-BICaQaRS.mjs';
+import { F as FallbackChainConfig, c as FallbackFailure, R as RoutingStore } from '../types-C3RgRbEC.mjs';
+export { d as FallbackInfo, b as RetryBackoff, e as RetryInfo, a as RoutingStrategy } from '../types-C3RgRbEC.mjs';
+import '../types-Dg1Bcg1k.mjs';
 import 'zod';
 
 /**

package/dist/fallback/index.d.ts

@@ -1,7 +1,7 @@
-import { L as LLMAdapter } from '../base-C58Dsr9p.js';
-import { F as FallbackChainConfig, c as FallbackFailure, R as RoutingStore } from '../types-CCxPmkmK.js';
-export { d as FallbackInfo, b as RetryBackoff, e as RetryInfo, a as RoutingStrategy } from '../types-CCxPmkmK.js';
-import '../types-BkQCSiIt.js';
+import { L as LLMAdapter } from '../base-CpRPB8u8.js';
+import { F as FallbackChainConfig, c as FallbackFailure, R as RoutingStore } from '../types-DCFqkJAy.js';
+export { d as FallbackInfo, b as RetryBackoff, e as RetryInfo, a as RoutingStrategy } from '../types-DCFqkJAy.js';
+import '../types-Dg1Bcg1k.js';
 import 'zod';
 
 /**

package/dist/fallback/index.js

@@ -1,5 +1,28 @@
 'use strict';
 
+// src/core/provider-error.ts
+function errorFromEvent(event) {
+  if (event.cause instanceof Error) return event.cause;
+  return Object.assign(new Error(event.message), {
+    status: event.status,
+    code: event.providerCode ?? event.code,
+    param: event.param,
+    request_id: event.requestId
+  });
+}
+function throwIfAborted(signal) {
+  if (!signal?.aborted) return;
+  const error = new Error("The operation was aborted");
+  error.name = "AbortError";
+  throw error;
+}
+function isAbortError(error) {
+  if (!(error instanceof Error)) return false;
+  return error.name === "AbortError" || error.constructor.name === "APIUserAbortError" || /^(aborted|the operation was aborted|the user aborted a request)/i.test(
+    error.message
+  );
+}
+
 // src/fallback/errors.ts
 var FallbackExhaustedError = class extends Error {
   constructor(failures) {
@@ -74,8 +97,24 @@ function calcDelay(base, attempt, backoff) {
   if (backoff === "fixed") return base;
   return base * Math.pow(2, attempt - 1);
 }
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+function sleep(ms, signal) {
+  throwIfAborted(signal);
+  return new Promise((resolve, reject) => {
+    const onAbort = () => {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", onAbort);
+      try {
+        throwIfAborted(signal);
+      } catch (error) {
+        reject(error);
+      }
+    };
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
 }
 var FallbackChain = class {
   constructor(config) {
@@ -91,7 +130,8 @@ var FallbackChain = class {
       retryBackoff: config.retryBackoff ?? "exponential",
       onFallback: config.onFallback,
       onRetry: config.onRetry,
-      retryableErrors: config.retryableErrors
+      retryableErrors: config.retryableErrors,
+      fallbackErrors: config.fallbackErrors
     };
   }
   get provider() {
@@ -111,8 +151,12 @@ var FallbackChain = class {
     await this._config.store.set(ROUND_ROBIN_KEY, next);
   }
   _isRetryable(error) {
+    if (isAbortError(error)) return false;
     return this._config.retryableErrors ? this._config.retryableErrors(error) : defaultIsRetryable(error);
   }
+  _canFallback(error) {
+    return !isAbortError(error) && (this._isRetryable(error) || this._config.fallbackErrors?.(error) === true);
+  }
   /**
    * Try streaming from a single adapter, with per-model retries.
    *
@@ -125,65 +169,52 @@ var FallbackChain = class {
    */
   async *_streamWithRetries(adapter, request, out) {
     const { retries, retryDelay, retryBackoff, onRetry } = this._config;
-    const maxAttempts = retries + 1;
-    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-      let contentStarted = false;
-      let failureError = null;
+    for (let attempt = 0; attempt <= retries; attempt++) {
+      throwIfAborted(request.signal);
+      out.retriesAttempted = attempt;
       try {
         for await (const chunk of adapter.stream(request)) {
-          if (chunk.type === "error") {
-            if (!contentStarted) {
-              const msg = chunk.message ?? "Unknown error";
-              failureError = new Error(msg);
-              break;
-            }
-            yield chunk;
-            return;
-          }
+          throwIfAborted(request.signal);
+          if (chunk.type === "error") throw errorFromEvent(chunk);
           if (chunk.type === "message:start") continue;
-          contentStarted = true;
+          out.contentStarted = true;
           yield chunk;
         }
+        throwIfAborted(request.signal);
+        return;
       } catch (error) {
-        if (contentStarted) throw error;
-        if (!this._isRetryable(error)) throw error;
-        failureError = error instanceof Error ? error : new Error(String(error));
-      }
-      if (failureError === null) return;
-      if (!this._isRetryable(failureError)) throw failureError;
-      out.retriesAttempted = attempt - 1;
-      if (attempt < maxAttempts) {
-        const delayMs = calcDelay(retryDelay, attempt, retryBackoff);
-        const retryInfo = {
+        throwIfAborted(request.signal);
+        if (out.contentStarted || !this._isRetryable(error) || attempt === retries)
+          throw error;
+        const delayMs = calcDelay(retryDelay, attempt + 1, retryBackoff);
+        onRetry?.({
           model: adapter.model,
           provider: adapter.provider,
-          error: failureError,
-          retryAttempt: attempt,
+          error: error instanceof Error ? error : new Error(String(error)),
+          retryAttempt: attempt + 1,
           maxRetries: retries,
           delayMs
-        };
-        onRetry?.(retryInfo);
-        await sleep(delayMs);
-        continue;
+        });
+        await sleep(delayMs, request.signal);
       }
-      out.retriesAttempted = retries;
-      throw failureError;
     }
   }
   async *stream(request) {
     const { models, onFallback } = this._config;
+    throwIfAborted(request.signal);
     const startIndex = await this._startIndex();
     const failures = [];
     for (let i = 0; i < models.length; i++) {
       const index = (startIndex + i) % models.length;
       const adapter = models[index];
-      const out = { retriesAttempted: 0 };
+      const out = { retriesAttempted: 0, contentStarted: false };
       try {
         yield* this._streamWithRetries(adapter, request, out);
         await this._advanceIndex(index);
         return;
       } catch (error) {
-        if (!this._isRetryable(error)) throw error;
+        throwIfAborted(request.signal);
+        if (out.contentStarted || !this._canFallback(error)) throw error;
         const failure = {
           model: adapter.model,
           provider: adapter.provider,
@@ -208,6 +239,7 @@ var FallbackChain = class {
   }
   async complete(request) {
     const { models, onFallback, retries, retryDelay, retryBackoff, onRetry } = this._config;
+    throwIfAborted(request.signal);
     const startIndex = await this._startIndex();
     const failures = [];
     for (let i = 0; i < models.length; i++) {
@@ -229,14 +261,18 @@ var FallbackChain = class {
       let lastError = null;
       let retriesAttempted = 0;
       for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        throwIfAborted(request.signal);
         try {
           const result = await adapter.complete(request);
+          throwIfAborted(request.signal);
           await this._advanceIndex(index);
           return result;
         } catch (error) {
-          if (!this._isRetryable(error)) throw error;
+          throwIfAborted(request.signal);
+          if (!this._canFallback(error)) throw error;
           lastError = error instanceof Error ? error : new Error(String(error));
           retriesAttempted = attempt - 1;
+          if (!this._isRetryable(error)) break;
           if (attempt < maxAttempts) {
             const delayMs = calcDelay(retryDelay, attempt, retryBackoff);
             onRetry?.({
@@ -247,7 +283,7 @@ var FallbackChain = class {
               maxRetries: retries,
               delayMs
             });
-            await sleep(delayMs);
+            await sleep(delayMs, request.signal);
           }
         }
       }