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

package/docs/decisions.md

@@ -0,0 +1,174 @@
+# Native Decisions
+
+Use Decisions to classify or score shared state with native decision models.
+Chat generation, Responses, and tool execution keep their existing APIs.
+See [package availability](https://copilot-sdk.yourgpt.ai/docs/llm-sdk/beta-upgrade)
+for the versions that expose these exports.
+
+```ts
+import { experimental_decide } from "@yourgpt/llm-sdk";
+import { openaiDecision } from "@yourgpt/llm-sdk/openai";
+
+const result = await experimental_decide({
+  model: openaiDecision("gpt-6-luna"), // server-side OPENAI_API_KEY
+  state: { ticket: "Every customer is unable to sign in." },
+  questions: {
+    outage: {
+      type: "boolean",
+      instructions: "Does the ticket report a service outage?",
+    },
+    team: {
+      type: "choice",
+      instructions: "Which team should handle this?",
+      criteria: {
+        billing: "Invoices and refunds",
+        engineering: "Service outages",
+      },
+    },
+    impact: {
+      type: "score",
+      instructions: "How much service is unavailable?",
+      criteria: ["None", "Some features or users", "All users"],
+    },
+  },
+  timeoutMs: 60_000,
+});
+
+if (result.answers.team.type === "refusal") {
+  // Route to your application's review or error path.
+} else {
+  const team: "billing" | "engineering" = result.answers.team.choice;
+  console.log(team, result.answers.team.probabilities);
+}
+```
+
+Question IDs and choice keys are preserved and inferred in TypeScript. Boolean
+answers contain `probability` (P(true)); scores are fractional, zero-based positions
+along the ordered criteria. Choice/score `confidence` is present only when supplied
+by the provider. Confidence and probability are different signals; neither promises
+task accuracy. Define and evaluate application-specific routing thresholds yourself.
+
+## Providers
+
+| Factory / import                        | Default model         | Environment                                      | Native endpoint                        |
+| --------------------------------------- | --------------------- | ------------------------------------------------ | -------------------------------------- |
+| `openaiDecision` from `/openai`         | `gpt-6-luna`          | `OPENAI_API_KEY`                                 | `/v1/decisions`                        |
+| `typesafeDecision` from `/typesafe`     | `jev-latest`          | `TYPESAFE_AI_API_KEY`                            | `/v1/systemone`                        |
+| `openrouterDecision` from `/openrouter` | `typesafe/jev-1.13`   | `OPENROUTER_API_KEY`                             | `/api/alpha/decisions`                 |
+| `cloudflareDecision` from `/cloudflare` | `@cf/cloudflare/clef` | `CLOUDFLARE_AUTH_TOKEN`, `CLOUDFLARE_ACCOUNT_ID` | Account-scoped Workers AI run endpoint |
+
+Factories also accept `{ apiKey, baseUrl, fetch, headers }` as their second argument.
+Cloudflare accepts `accountId` and the `@cf/cloudflare/clef-flash` model. The
+OpenRouter Decisions base URL is `https://openrouter.ai/api/alpha`; do not pass its
+chat `/api/v1` base. Cloudflare's custom base must include the account's `/ai/run`
+path. Supply keys on the server; these factories do not require upgrading the
+optional OpenAI npm client.
+
+No Anthropic native Decisions adapter is provided. Continue using its existing
+chat/structured-output APIs where appropriate; they are not silently substituted
+for native Decisions.
+
+## Inputs and limits
+
+`state` and `instructions` accept text, JSON objects, or JSON arrays. Arrays remain
+structured JSON. Numbers must be finite; cycles, undefined values, and nesting
+beyond 64 levels are rejected. Unknown request options, such as `temperature`,
+tools, streaming, or audio, fail explicitly.
+
+- Boolean criteria may describe `true` and/or `false`. OpenRouter requires both
+  descriptions if criteria are provided.
+- Choice criteria require 2–255 distinct string keys. Native OpenAI boolean-valued
+  choices are outside this common API; use a boolean question instead.
+- Score criteria require at least two levels. System One adapters accept up to ten.
+- OpenAI accepts at most 200 questions. Cloudflare accepts at most 64 and requires
+  IDs of 1–100 letters, digits, underscores, dots, or hyphens.
+- Request bodies are limited to 32 MiB by this SDK, or 13 MiB for Cloudflare.
+
+Optional provider settings are checked rather than silently ignored:
+
+```ts
+const providerOptions = {
+  openai: { safetyIdentifier: "user-123", promptCacheKey: "support-v1" },
+};
+// Jev: { typesafe: { longContext: true } }
+// OpenRouter: { openrouter: { sessionId: "session-1",
+//   provider: { order: ["TypeSafe"], allowFallbacks: false } } }
+```
+
+Only pass the namespace matching the selected provider. Long-context support is
+experimental and depends on the Jev model/account. Cache hits are not guaranteed.
+
+## Image state
+
+```ts
+import { readFile } from "node:fs/promises";
+
+const images = [
+  {
+    data: await readFile("./sample.png"),
+    mediaType: "image/png" as const,
+  },
+];
+// Pass `images` alongside `state` and `questions` to experimental_decide.
+```
+
+OpenAI accepts PNG, JPEG, WebP, and GIF bytes with optional `detail`, encoded as
+inline data URLs on the wire. This SDK accepts bytes only. OpenAI’s current
+native endpoint also accepts hosted image URLs; URL inputs are not yet exposed
+by this SDK. File IDs remain unsupported by the native endpoint. This SDK limits inline files to 20 MiB and 128 images.
+It never downloads URLs itself. Jev accepts PNG/JPEG bytes up to 16 MiB each using referenced
+native image assets and its required experimental image header. The original state
+is retained under `state` and image references under `images` in the native Jev
+request. Cloudflare accepts at most four PNG/JPEG/WebP files, 4 MiB each and 8 MiB
+total. Remote URLs fail locally for every Decisions provider. OpenAI-specific
+detail settings fail on Jev/Cloudflare. Tool image outputs on Responses are a
+separate API and can still use hosted URLs or OpenAI file IDs.
+
+Byte format headers and size limits are checked locally. Providers perform full
+image decoding, dimension and animation validation. Jev requires still images with
+each dimension between 280 and 1568 pixels; Cloudflare limits each image to 16
+megapixels. Prepare images before sending; this SDK does not resize them.
+OpenRouter's documented native Decisions request has no image field, so this
+adapter rejects image inputs.
+
+## Results, refusals, and errors
+
+The SDK rejects missing/extra answers, duplicate OpenAI answer IDs, unknown choices,
+incomplete distributions, invalid probabilities, and scores inconsistent with their
+ordered levels. Values are never renormalized. TypeSafe's documented rounding is
+allowed for direct Jev and confirmed TypeSafe responses through OpenRouter.
+
+A named OpenAI refusal remains `{ type: "refusal" }` under that question; other
+answers remain available. An unnamed refusal throws `DecisionAPIError` with code
+`refusal`. HTTP, network, malformed-response, unsupported-option, and input errors
+are separate. Errors do not include raw provider error bodies or credentials.
+Use `DecisionAPIError.isInstance(error)` to recognize these errors across separately
+bundled provider imports, CommonJS, and ES modules.
+
+Pass `signal` to cancel. The timeout covers the response body too, and defaults to
+60 seconds. Errors expose `status`, `requestId` when available, and a `retryable`
+hint. There are **no automatic retries or chat fallbacks**. `TRAINING_CONFLICT` and
+existing guardrail behavior are unchanged; evaluate a migration separately.
+
+Normalized token/cache/cost usage is in `usage`; absent fields remain absent.
+`response.body` retains the original provider response, including gateway metadata
+and native score legends. Avoid logging it if your state contains private data.
+Responses larger than 8 MiB are rejected.
+
+## Example and verification
+
+The existing skills demo includes `server/decisions.ts`. With the required provider
+key already in your process environment, run from `examples/skills-demo`:
+
+```sh
+pnpm demo:decisions openai
+pnpm demo:decisions openrouter
+```
+
+The example uses a synthetic ticket and a review route for uncertain/refused
+answers. It does not load a `.env` file automatically or change the chat server.
+Opt-in live tests are in `test/live/decisions.cjs`; select a provider with
+`DECISION_TEST_PROVIDER` and enable `RUN_DECISIONS_LIVE=1` with its key configured
+privately. Direct Jev/Cloudflare live checks require their own credentials.
+
+Research and source pins: [implementation research](../../../docs/plans/2026-10-17-next-beta.md).

package/docs/media.md

@@ -0,0 +1,201 @@
+# Images and realtime voice
+
+Generate and edit images with OpenAI, or connect browser voice calls to Copilot
+tools over WebRTC. Realtime voice is experimental. See
+[package availability](https://copilot-sdk.yourgpt.ai/docs/llm-sdk/beta-upgrade)
+for the versions that expose these APIs.
+
+## Image generation and editing
+
+```ts
+import { generateImage } from "@yourgpt/llm-sdk";
+import { openaiImage } from "@yourgpt/llm-sdk/openai";
+
+const result = await generateImage({
+  model: openaiImage("gpt-image-2.5-flare"), // reads OPENAI_API_KEY on the server
+  prompt: "A simple blue circle on a white background",
+  size: "1024x1024",
+  providerOptions: { openai: { quality: "low", outputFormat: "png" } },
+});
+// result.image.uint8Array, result.image.base64, result.image.mediaType
+// result.images, result.usage, result.response.requestId
+
+const edit = await generateImage({
+  model: openaiImage("gpt-image-2.5-flare"),
+  prompt: "Change the circle to green",
+  images: [{ data: result.image.uint8Array, mediaType: "image/png" }],
+  providerOptions: { openai: { outputFormat: "webp", outputCompression: 80 } },
+});
+```
+
+`images` selects the Images edit endpoint. Inputs accept bytes, ArrayBuffer or Blob
+with a PNG/JPEG/WebP media type. An optional PNG `mask` applies to the first image;
+match its dimensions to that image. No remote URLs are fetched automatically.
+`n` is 1–10; editing accepts 1–16 images. Each input must be below 50 MB, and the
+SDK limits total input to 100 MB and the encoded response to 128 MiB.
+
+OpenAI options: `quality`, `background`, `outputFormat`, `outputCompression`,
+`inputFidelity` (edits), `moderation` (generation), and `safetyIdentifier`.
+GPT Image 2.5 supports `xhigh`/`max` quality and custom dimensions within its
+documented limits. Transparent output requires PNG or WebP. Compression requires
+JPEG or WebP. Unsupported options fail explicitly. Retired DALL-E models are not
+supported. Streaming partial images and the Responses-hosted image tool are
+separate APIs, not part of this helper.
+
+`signal` cancels requests; `timeoutMs` defaults to 120 seconds (maximum 10 minutes).
+Requests are not automatically retried. Aborting locally cannot guarantee that a
+provider has stopped a billable generation. `MediaAPIError` includes `code`,
+optional HTTP `status`, and `requestId`; it omits provider error bodies.
+
+## Realtime voice: server setup
+
+OpenAI GA Realtime is a turn-based speech conversation over WebRTC. It is distinct
+from GPT-Live's continuous/delegated protocol. The SDK supports OpenAI Realtime
+browser calls, not GPT-Live, telephony/SIP, or other realtime providers.
+
+Authenticate and authorize your session endpoint, apply quotas/rate limits, and
+set `Cache-Control: no-store`. Keep the long-lived key on your server. The easiest
+flow exchanges the browser's SDP offer on that server:
+
+```ts
+import { openaiRealtime } from "@yourgpt/llm-sdk/openai";
+
+// Inside your authenticated POST handler. Only accept the SDP from the browser.
+const answer = await openaiRealtime("gpt-realtime-2.1").createCall({
+  sdp: requestBody.sdp,
+  instructions: "You are a helpful assistant. Keep spoken answers brief.",
+  voice: "marin",
+  transcriptionModel: "gpt-transcribe",
+  tools: [
+    {
+      name: "get_status",
+      description: "Read the application status",
+      parameters: {
+        type: "object",
+        properties: {},
+        additionalProperties: false,
+      },
+    },
+  ],
+  signal: requestSignal,
+});
+// Return answer as JSON: { sdp: "..." }. No provider key is returned.
+```
+
+Alternatively, `createClientSecret({ expiresAfterSeconds: 60, ...sessionOptions })`
+returns `{ value, expiresAt, modelId }`. Give only that short-lived credential to
+the browser's `getClientSecret` callback. The TTL applies to establishing sessions,
+not to an already connected call; a token can establish multiple calls until it
+expires. Session options attached to a token can be overridden by the client.
+Neither flow substitutes for authentication/authorization on business tool APIs.
+
+Optional server settings include `outputModality: "text" | "audio"`,
+`maxOutputTokens`, `language` with a transcription model, and `safetyIdentifier`.
+Setup requests time out after 30 seconds and are never retried automatically.
+Server VAD with automatic replies/interruption is enabled by default. Select
+semantic VAD with `turnDetection: { type: "semantic_vad", eagerness: "medium" }`,
+or use `turnDetection: null` with explicit `commitAudio()` after capturing audio.
+
+## Browser and React
+
+Use `useRealtimeVoice` inside `CopilotProvider`. It reads the active tool registry
+and `needsApproval` policy from that provider. Supply `getToolPermission` to reuse
+your application’s stored permissions; otherwise approval-required tools ask on every call. Start capture from a user gesture:
+
+```tsx
+import { useRealtimeVoice } from "@yourgpt/copilot-sdk/react";
+
+function VoiceControls() {
+  const voice = useRealtimeVoice({
+    createCall: async ({ sdp, signal }) => {
+      const response = await fetch("/api/voice", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ sdp }),
+        signal,
+      });
+      if (!response.ok) throw new Error("Voice setup failed");
+      return response.json();
+    },
+  });
+  return (
+    <>
+      <button onClick={() => void voice.connect().catch(console.error)}>
+        Start call
+      </button>
+      <button onClick={voice.disconnect}>End call</button>
+      <button onClick={() => voice.setMuted(!voice.muted)}>
+        Toggle microphone
+      </button>
+      {voice.pendingApprovals.map((call) => (
+        <div key={call.id}>
+          Allow {call.name}?
+          <button onClick={() => call.approve()}>Allow</button>
+          <button onClick={call.reject}>Deny</button>
+        </div>
+      ))}
+    </>
+  );
+}
+```
+
+Also available: `state`, `muted`, `error`, `transcripts`, `sendText`, `interrupt`,
+`commitAudio`, and `resumeAudio` (for browsers that block autoplay). Unmounting
+disconnects and releases capture. The hook retains at most 200 transcript items.
+Connection configuration is captured when connecting; tool handlers, the optional permission resolver,
+and observer callbacks use the latest React values.
+
+Framework-independent apps can construct `RealtimeVoiceSession` from
+`@yourgpt/copilot-sdk/core`, with `getTools`, `getToolPermission` and `onApproval`.
+`realtimeToolDefinitions(tools)` converts Copilot tools to the server setup shape;
+the server must independently choose which tools it permits. Credentials and
+session instructions must not be accepted blindly from browser input.
+
+`needsApproval` (including conditional callbacks) is respected. `deny_always`
+blocks execution; `allow_always`/`session` permit it. Without an approval callback,
+the core class denies required approval. The React hook exposes pending approvals
+unless you provide your own callback. Tool handlers receive `signal`, `toolCallId`
+and approved `approvalData`. Business handlers still validate their arguments and
+enforce server-side authorization. These are voice approval controls, not the
+text-chat pending-approval queue.
+
+Duplicate call IDs execute at most once within a connection. Completed tool batches
+resume the model once; a user interruption suppresses stale follow-up speech while
+retaining tool output in the active conversation. Failed/timed-out tools produce
+one error result. A disconnect cancels pending approvals and signals running tools;
+handlers must honor cancellation themselves. There is no automatic reconnect or
+tool replay. Reconnecting creates a fresh provider conversation; persist application
+state separately if needed. This is not a cross-session exactly-once guarantee.
+
+## Limits and observability
+
+- HTTPS or localhost and a WebRTC browser are required. The default microphone
+  adapter uses browser permission; an optional `getMicrophone` adapter can supply
+  synthetic audio. The session owns and stops all tracks returned by that adapter.
+- Audio travels as WebRTC media tracks with negotiated codecs/rates, not as an SDK
+  PCM stream. Use browser `RTCPeerConnection.getStats()` for actual negotiated media
+  metrics. WebRTC's server buffer handles VAD interruption and truncation.
+- `onTranscript`, `onUsage`, `onEvent`, `onToolResult`, `onStateChange`, and `onError`
+  provide observations. Raw events can contain conversation content: log selectively.
+- Defaults: 30-second connection timeout, 60-second tool/approval timeout,
+  30-minute call duration, 100 tool calls, 1 MiB event/send buffer, 64 KB tool result.
+  Limits are configurable through `RealtimeVoiceOptions` where exposed.
+- Network loss closes the session and stops capture. Browser autoplay failures
+  keep the call available for `resumeAudio()`. Clearly disclose AI-generated voice.
+
+Run the local demo in `examples/skills-demo` with `pnpm demo:media`, then visit
+`http://localhost:3033/media.html`. Existing `.env` keys are read only by the server;
+never prefix them with `VITE_`. Its server binds to loopback and checks the origin;
+that local-only guard is not production authentication.
+
+## Research and validation
+
+Provider contracts: [Realtime getting started](https://developers.openai.com/api/docs/guides/realtime),
+[WebRTC](https://developers.openai.com/api/docs/guides/voice-webrtc?api=realtime),
+[client secrets](https://developers.openai.com/api/reference/resources/realtime/subresources/client_secrets/methods/create),
+[conversations/tools](https://developers.openai.com/api/docs/guides/realtime-conversations),
+[image generation](https://developers.openai.com/api/docs/guides/image-generation).
+Compared with [Vercel realtime](https://ai-sdk.dev/docs/ai-sdk-core/realtime) and
+[image generation](https://ai-sdk.dev/docs/ai-sdk-core/image-generation), including
+source and changelog snapshot `fce9210c6405c0ad8452fee3f50717e8ea910b97` (2026-10-16).
+See the repository's media implementation and validation records for exact validation results.

package/docs/multimodal-and-audio.md

@@ -1,5 +1,12 @@
 # Image tool results and recorded audio
 
+Tools can return images to supported models, and audio helpers provide speech generation and recorded voice input.
+For the navigable documentation, start with the [versions and compatibility](https://copilot-sdk.yourgpt.ai/docs/llm-sdk/beta-upgrade),
+[image tool results](https://copilot-sdk.yourgpt.ai/docs/tools/image-results),
+[speech](https://copilot-sdk.yourgpt.ai/docs/llm-sdk/speech),
+[transcription](https://copilot-sdk.yourgpt.ai/docs/llm-sdk/transcription), and
+[recorded voice input](https://copilot-sdk.yourgpt.ai/docs/chat/voice-input).
+
 These APIs are additive. Chat configuration, ordinary JSON/string tool results, and the existing screenshot `addAsUserMessage` attachment path retain their behavior. Native image tool output requires OpenAI **Responses** or Anthropic. TTS and recorded-file STT currently have an OpenAI implementation; other providers can implement the separate `SpeechModel` / `TranscriptionModel` contracts.
 
 ## Tools that return images
@@ -50,7 +57,7 @@ OpenAI Chat Completions, Gemini, Ollama, Azure Chat and other compatible endpoin
 
 Native output is carried as `modelOutput` next to the tool message's text. Preserve it when storing/restoring messages, along with `tool_call_id` / `toolCallId` and assistant tool calls. The Runtime storage helper places it at `StorageMessage.metadata.modelOutput`; a custom loader must map it back to `modelOutput`. Copilot's serialized `UIMessage` history preserves it directly, including server results in streaming execution metadata. Do not truncate image base64 or substitute it with text. Context pruning can remove complete older tool exchanges.
 
-If an existing screenshot handler explicitly uses `addAsUserMessage`, it continues to add an attachment. When native model output is also supplied, the native output takes precedence and no extra attachment turn is created. General image generation is separate and is not implemented here.
+If an existing screenshot handler explicitly uses `addAsUserMessage`, it continues to add an attachment. When native model output is also supplied, the native output takes precedence and no extra attachment turn is created. General image generation and editing use the API in the [media guide](./media.md).
 
 ## Speech generation on the server
 
@@ -163,7 +170,7 @@ upload?.abort();
 recorder.dispose();
 ```
 
-The recorder negotiates supported WebM/Opus, MP4, or Ogg/Opus containers. Stop, cancel, permission races, recorder errors and disposal release microphone tracks. Defaults: 20 MB and 60 seconds; exceeding either discards the recording and invokes `onError`. No automatic message submission, voice cloning, telephony, live transcription, or bidirectional voice call is included.
+The recorder negotiates supported WebM/Opus, MP4, or Ogg/Opus containers. Stop, cancel, permission races, recorder errors and disposal release microphone tracks. Defaults: 20 MB and 60 seconds; exceeding either discards the recording and invokes `onError`. The recorder does not submit chat messages automatically or provide voice cloning, telephony, live transcription or a bidirectional call. For the WebRTC call API, see the [realtime guide](./media.md#realtime-voice-server-setup).
 
 ## Verification sources
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yourgpt/llm-sdk",
-  "version": "2.6.0-beta.2",
+  "version": "2.6.0",
   "description": "AI SDK for building AI Agents with any LLM",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -135,6 +135,26 @@
         "types": "./dist/fallback/index.d.ts",
         "default": "./dist/fallback/index.js"
       }
+    },
+    "./typesafe": {
+      "import": {
+        "types": "./dist/providers/typesafe/index.d.mts",
+        "default": "./dist/providers/typesafe/index.mjs"
+      },
+      "require": {
+        "types": "./dist/providers/typesafe/index.d.ts",
+        "default": "./dist/providers/typesafe/index.js"
+      }
+    },
+    "./cloudflare": {
+      "import": {
+        "types": "./dist/providers/cloudflare/index.d.mts",
+        "default": "./dist/providers/cloudflare/index.mjs"
+      },
+      "require": {
+        "types": "./dist/providers/cloudflare/index.d.ts",
+        "default": "./dist/providers/cloudflare/index.js"
+      }
     }
   },
   "homepage": "https://copilot-sdk.yourgpt.ai",
@@ -142,17 +162,10 @@
     "dist",
     "!dist/**/*.map",
     "README.md",
-    "docs/multimodal-and-audio.md"
+    "docs/multimodal-and-audio.md",
+    "docs/decisions.md",
+    "docs/media.md"
   ],
-  "scripts": {
-    "build": "tsup",
-    "dev": "tsup --watch",
-    "clean": "rm -rf dist",
-    "lint": "eslint src/",
-    "typecheck": "tsc --noEmit",
-    "test": "pnpm build && pnpm test:types && node --test test/*.test.cjs",
-    "test:types": "tsc --noEmit --strict --skipLibCheck --moduleResolution node16 --module Node16 --target ES2020 test/public-types.ts test/public-types.mts"
-  },
   "dependencies": {
     "hono": "^4.3.0",
     "zod": "^3.23.0"
@@ -207,5 +220,14 @@
   "sideEffects": false,
   "engines": {
     "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "clean": "rm -rf dist",
+    "lint": "eslint src/",
+    "typecheck": "tsc --noEmit",
+    "test": "pnpm build && pnpm test:types && node --test test/*.test.cjs",
+    "test:types": "tsc --noEmit --strict --skipLibCheck --moduleResolution node16 --module Node16 --target ES2020 test/public-types.ts test/public-types.mts"
   }
-}
+}

package/dist/audio-BBSwnjo8.d.mts

@@ -1,92 +0,0 @@
-/** 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

@@ -1,92 +0,0 @@
-/** 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 };