@voltro/ai 0.75.0 → 0.77.0

package/dist/agentEvent-BuXA7sRt.js

@@ -0,0 +1,152 @@
+import { Schema as e } from "effect";
+//#region src/transcriptionEvent.ts
+var t = class extends e.TaggedError()("TranscriptionStreamError", {
+	reason: e.Literal("input", "unsupported", "provider", "cancelled"),
+	message: e.String
+}) {}, n = e.Struct({
+	text: e.String,
+	start: e.Number,
+	end: e.Number
+}), r = { id: e.optional(e.String) }, i = e.Union(e.Struct({
+	type: e.Literal("transcript-delta"),
+	...r,
+	delta: e.String
+}), e.Struct({
+	type: e.Literal("transcript-partial"),
+	...r,
+	text: e.String,
+	startSecond: e.optional(e.Number),
+	durationInSeconds: e.optional(e.Number),
+	channelIndex: e.optional(e.Number)
+}), e.Struct({
+	type: e.Literal("transcript-final"),
+	...r,
+	text: e.String,
+	startSecond: e.optional(e.Number),
+	endSecond: e.optional(e.Number),
+	channelIndex: e.optional(e.Number)
+}), e.Struct({
+	type: e.Literal("finish"),
+	text: e.String,
+	segments: e.Array(n),
+	language: e.optional(e.String),
+	durationSec: e.optional(e.Number)
+})), a = e.String.pipe(e.pattern(/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/)), o = e.Number.pipe(e.finite(), e.nonNegative()), s = e.Union(e.Struct({
+	type: e.Literal("input-audio-append"),
+	audio: a
+}), e.Struct({ type: e.Literal("input-audio-commit", "input-audio-clear", "response-create", "response-cancel") }), e.Struct({
+	type: e.Literal("conversation-item-create"),
+	item: e.Struct({
+		type: e.Literal("text-message"),
+		role: e.Literal("user"),
+		text: e.String
+	})
+}), e.Struct({
+	type: e.Literal("conversation-item-truncate"),
+	itemId: e.String,
+	contentIndex: o.pipe(e.int()),
+	audioEndMs: o
+})), c = { itemId: e.String }, l = {
+	responseId: e.String,
+	...c
+}, u = e.Union(e.Struct({ type: e.Literal("ready") }), e.Struct({
+	type: e.Literal("session-created"),
+	sessionId: e.optional(e.String)
+}), e.Struct({ type: e.Literal("session-updated") }), e.Struct({
+	type: e.Literal("speech-started", "speech-stopped"),
+	itemId: e.optional(e.String)
+}), e.Struct({
+	type: e.Literal("audio-committed"),
+	itemId: e.optional(e.String),
+	previousItemId: e.optional(e.String)
+}), e.Struct({
+	type: e.Literal("conversation-item-added"),
+	...c
+}), e.Struct({
+	type: e.Literal("input-transcription-completed"),
+	...c,
+	transcript: e.String
+}), e.Struct({
+	type: e.Literal("response-created"),
+	responseId: e.String
+}), e.Struct({
+	type: e.Literal("response-done"),
+	responseId: e.String,
+	status: e.String
+}), e.Struct({
+	type: e.Literal("output-item-added", "output-item-done", "content-part-added", "content-part-done", "audio-done"),
+	...l
+}), e.Struct({
+	type: e.Literal("audio-delta"),
+	...l,
+	delta: a
+}), e.Struct({
+	type: e.Literal("text-delta", "audio-transcript-delta"),
+	...l,
+	delta: e.String
+}), e.Struct({
+	type: e.Literal("text-done"),
+	...l,
+	text: e.optional(e.String)
+}), e.Struct({
+	type: e.Literal("audio-transcript-done"),
+	...l,
+	transcript: e.optional(e.String)
+})), d = e.Literal("provider", "tool", "timeout", "cancelled", "decode", "internal"), f = e.Struct({
+	inputTokens: e.optional(e.Number),
+	outputTokens: e.optional(e.Number),
+	totalTokens: e.optional(e.Number)
+}), p = e.Union(e.Struct({
+	_tag: e.Literal("token"),
+	text: e.String
+}), e.Struct({
+	_tag: e.Literal("reasoning"),
+	text: e.String
+}), e.Struct({
+	_tag: e.Literal("toolCall"),
+	id: e.String,
+	name: e.String,
+	input: e.Unknown
+}), e.Struct({
+	_tag: e.Literal("toolResult"),
+	id: e.String,
+	name: e.String,
+	output: e.optional(e.Unknown),
+	error: e.optional(e.String)
+}), e.Struct({
+	_tag: e.Literal("source"),
+	sourceType: e.Literal("url", "document"),
+	id: e.String,
+	url: e.optional(e.String),
+	title: e.optional(e.String),
+	mediaType: e.optional(e.String),
+	filename: e.optional(e.String),
+	providerMetadata: e.optional(e.Unknown)
+}), e.Struct({
+	_tag: e.Literal("file"),
+	mediaType: e.String,
+	data: e.String,
+	providerMetadata: e.optional(e.Unknown)
+}), e.Struct({
+	_tag: e.Literal("stepMetadata"),
+	step: e.Int.pipe(e.nonNegative()),
+	providerMetadata: e.Unknown
+}), e.Struct({
+	_tag: e.Literal("message"),
+	role: e.String,
+	content: e.String
+}), e.Struct({
+	_tag: e.Literal("error"),
+	code: d,
+	message: e.String,
+	retryable: e.Boolean
+}), e.Struct({
+	_tag: e.Literal("done"),
+	finishReason: e.String,
+	usage: f
+})), m = e.Struct({
+	seq: e.Number,
+	event: p
+});
+//#endregion
+export { u as a, s as i, p as n, t as o, m as r, i as s, d as t };

package/dist/events.d.ts

@@ -63,6 +63,87 @@ export declare const AgentEvent: Schema.Union<[Schema.Struct<{
 
 export declare type AgentEvent = typeof AgentEvent.Type;
 
+/** Browser-safe input allowlist. Session configuration and provider credentials
+ * belong to the server, never to events received from the browser. */
+export declare const RealtimeClientEvent: Schema.Union<[Schema.Struct<{
+    type: Schema.Literal<["input-audio-append"]>;
+    audio: Schema.filter<typeof Schema.String>;
+}>, Schema.Struct<{
+    type: Schema.Literal<["input-audio-commit", "input-audio-clear", "response-create", "response-cancel"]>;
+}>, Schema.Struct<{
+    type: Schema.Literal<["conversation-item-create"]>;
+    item: Schema.Struct<{
+        type: Schema.Literal<["text-message"]>;
+        role: Schema.Literal<["user"]>;
+        text: typeof Schema.String;
+    }>;
+}>, Schema.Struct<{
+    type: Schema.Literal<["conversation-item-truncate"]>;
+    itemId: typeof Schema.String;
+    contentIndex: Schema.filter<Schema.filter<Schema.filter<typeof Schema.Number>>>;
+    audioEndMs: Schema.filter<Schema.filter<typeof Schema.Number>>;
+}>]>;
+
+export declare type RealtimeClientEvent = typeof RealtimeClientEvent.Type;
+
+/** Safe, normalized server events. No raw provider payload, client secret,
+ * arbitrary conversation item or provider error message crosses this surface. */
+export declare const RealtimeServerEvent: Schema.Union<[Schema.Struct<{
+    type: Schema.Literal<["ready"]>;
+}>, Schema.Struct<{
+    type: Schema.Literal<["session-created"]>;
+    sessionId: Schema.optional<typeof Schema.String>;
+}>, Schema.Struct<{
+    type: Schema.Literal<["session-updated"]>;
+}>, Schema.Struct<{
+    type: Schema.Literal<["speech-started", "speech-stopped"]>;
+    itemId: Schema.optional<typeof Schema.String>;
+}>, Schema.Struct<{
+    type: Schema.Literal<["audio-committed"]>;
+    itemId: Schema.optional<typeof Schema.String>;
+    previousItemId: Schema.optional<typeof Schema.String>;
+}>, Schema.Struct<{
+    itemId: typeof Schema.String;
+    type: Schema.Literal<["conversation-item-added"]>;
+}>, Schema.Struct<{
+    transcript: typeof Schema.String;
+    itemId: typeof Schema.String;
+    type: Schema.Literal<["input-transcription-completed"]>;
+}>, Schema.Struct<{
+    type: Schema.Literal<["response-created"]>;
+    responseId: typeof Schema.String;
+}>, Schema.Struct<{
+    type: Schema.Literal<["response-done"]>;
+    responseId: typeof Schema.String;
+    status: typeof Schema.String;
+}>, Schema.Struct<{
+    itemId: typeof Schema.String;
+    responseId: typeof Schema.String;
+    type: Schema.Literal<["output-item-added", "output-item-done", "content-part-added", "content-part-done", "audio-done"]>;
+}>, Schema.Struct<{
+    delta: Schema.filter<typeof Schema.String>;
+    itemId: typeof Schema.String;
+    responseId: typeof Schema.String;
+    type: Schema.Literal<["audio-delta"]>;
+}>, Schema.Struct<{
+    delta: typeof Schema.String;
+    itemId: typeof Schema.String;
+    responseId: typeof Schema.String;
+    type: Schema.Literal<["text-delta", "audio-transcript-delta"]>;
+}>, Schema.Struct<{
+    text: Schema.optional<typeof Schema.String>;
+    itemId: typeof Schema.String;
+    responseId: typeof Schema.String;
+    type: Schema.Literal<["text-done"]>;
+}>, Schema.Struct<{
+    transcript: Schema.optional<typeof Schema.String>;
+    itemId: typeof Schema.String;
+    responseId: typeof Schema.String;
+    type: Schema.Literal<["audio-transcript-done"]>;
+}>]>;
+
+export declare type RealtimeServerEvent = typeof RealtimeServerEvent.Type;
+
 /**
  * One persisted event of a RESUMABLE stream: an `AgentEvent` plus its monotonic
  * 1-based position. `seq` is the resume cursor — a client that has rendered up
@@ -135,4 +216,48 @@ export declare const SeqEvent: Schema.Struct<{
 
 export declare type SeqEvent = typeof SeqEvent.Type;
 
+/** Browser-safe error contract for a declared transcription stream. */
+export declare class TranscriptionStreamError extends TranscriptionStreamError_base {
+}
+
+declare const TranscriptionStreamError_base: Schema.TaggedErrorClass<TranscriptionStreamError, "TranscriptionStreamError", {
+    readonly _tag: Schema.tag<"TranscriptionStreamError">;
+} & {
+    reason: Schema.Literal<["input", "unsupported", "provider", "cancelled"]>;
+    message: typeof Schema.String;
+}>;
+
+/** Partial text is replaceable, delta text is append-only, and final text seals a segment. */
+export declare const TranscriptionStreamEvent: Schema.Union<[Schema.Struct<{
+    delta: typeof Schema.String;
+    id: Schema.optional<typeof Schema.String>;
+    type: Schema.Literal<["transcript-delta"]>;
+}>, Schema.Struct<{
+    text: typeof Schema.String;
+    startSecond: Schema.optional<typeof Schema.Number>;
+    durationInSeconds: Schema.optional<typeof Schema.Number>;
+    channelIndex: Schema.optional<typeof Schema.Number>;
+    id: Schema.optional<typeof Schema.String>;
+    type: Schema.Literal<["transcript-partial"]>;
+}>, Schema.Struct<{
+    text: typeof Schema.String;
+    startSecond: Schema.optional<typeof Schema.Number>;
+    endSecond: Schema.optional<typeof Schema.Number>;
+    channelIndex: Schema.optional<typeof Schema.Number>;
+    id: Schema.optional<typeof Schema.String>;
+    type: Schema.Literal<["transcript-final"]>;
+}>, Schema.Struct<{
+    type: Schema.Literal<["finish"]>;
+    text: typeof Schema.String;
+    segments: Schema.Array$<Schema.Struct<{
+        text: typeof Schema.String;
+        start: typeof Schema.Number;
+        end: typeof Schema.Number;
+    }>>;
+    language: Schema.optional<typeof Schema.String>;
+    durationSec: Schema.optional<typeof Schema.Number>;
+}>]>;
+
+export declare type TranscriptionStreamEvent = typeof TranscriptionStreamEvent.Type;
+
 export { }

package/dist/events.js

@@ -1,60 +1,2 @@
-import { Schema as e } from "effect";
-//#region src/agentEvent.ts
-var t = e.Literal("provider", "tool", "timeout", "cancelled", "decode", "internal"), n = e.Struct({
-	inputTokens: e.optional(e.Number),
-	outputTokens: e.optional(e.Number),
-	totalTokens: e.optional(e.Number)
-}), r = e.Union(e.Struct({
-	_tag: e.Literal("token"),
-	text: e.String
-}), e.Struct({
-	_tag: e.Literal("reasoning"),
-	text: e.String
-}), e.Struct({
-	_tag: e.Literal("toolCall"),
-	id: e.String,
-	name: e.String,
-	input: e.Unknown
-}), e.Struct({
-	_tag: e.Literal("toolResult"),
-	id: e.String,
-	name: e.String,
-	output: e.optional(e.Unknown),
-	error: e.optional(e.String)
-}), e.Struct({
-	_tag: e.Literal("source"),
-	sourceType: e.Literal("url", "document"),
-	id: e.String,
-	url: e.optional(e.String),
-	title: e.optional(e.String),
-	mediaType: e.optional(e.String),
-	filename: e.optional(e.String),
-	providerMetadata: e.optional(e.Unknown)
-}), e.Struct({
-	_tag: e.Literal("file"),
-	mediaType: e.String,
-	data: e.String,
-	providerMetadata: e.optional(e.Unknown)
-}), e.Struct({
-	_tag: e.Literal("stepMetadata"),
-	step: e.Int.pipe(e.nonNegative()),
-	providerMetadata: e.Unknown
-}), e.Struct({
-	_tag: e.Literal("message"),
-	role: e.String,
-	content: e.String
-}), e.Struct({
-	_tag: e.Literal("error"),
-	code: t,
-	message: e.String,
-	retryable: e.Boolean
-}), e.Struct({
-	_tag: e.Literal("done"),
-	finishReason: e.String,
-	usage: n
-})), i = e.Struct({
-	seq: e.Number,
-	event: r
-});
-//#endregion
-export { t as AgentErrorCode, r as AgentEvent, i as SeqEvent };
+import { a as e, i as t, n, o as r, r as i, s as a, t as o } from "./agentEvent-BuXA7sRt.js";
+export { o as AgentErrorCode, n as AgentEvent, t as RealtimeClientEvent, e as RealtimeServerEvent, i as SeqEvent, r as TranscriptionStreamError, a as TranscriptionStreamEvent };

package/dist/index.d.ts

@@ -5,6 +5,8 @@ import { DataStore } from '@voltro/database';
 import { defaultSettingsMiddleware } from 'ai';
 import { Effect } from 'effect';
 import { EmbeddingModelV4 } from '@ai-sdk/provider';
+import { Experimental_RealtimeModelV4 } from '@ai-sdk/provider';
+import { Experimental_RealtimeModelV4SessionConfig } from '@ai-sdk/provider';
 import { Experimental_VideoModelV4 } from '@ai-sdk/provider';
 import { Experimental_VideoModelV4File } from '@ai-sdk/provider';
 import { extractReasoningMiddleware } from 'ai';
@@ -26,10 +28,12 @@ import { SemanticCacheShape } from '@voltro/cache';
 import { simulateStreamingMiddleware } from 'ai';
 import { SpeechModelV4 } from '@ai-sdk/provider';
 import { Stream } from 'effect';
+import { Subject } from '@voltro/protocol';
 import { Table } from '@voltro/database';
 import { ToolSet } from 'ai';
 import { TranscriptionModelV4 } from '@ai-sdk/provider';
 import { VoidIfEmpty } from 'effect/Types';
+import { WebSocketGatewayRoute } from '@voltro/protocol';
 import { YieldableError } from 'effect/Cause';
 
 /** Count of in-flight streams (diagnostics / leak detection). */
@@ -305,6 +309,8 @@ export declare const AI_INFERENCES_TABLE = "_voltro_ai_inferences";
 
 export declare const AI_USAGE_TABLE = "_voltro_ai_usage";
 
+export declare type AiBudgetError = AiBudgetExceeded | AiBudgetInvalidInput | AiBudgetReservationConflict;
+
 /** A refused reservation, not evidence of a provider charge. */
 export declare class AiBudgetExceeded extends AiBudgetExceeded_base {
 }
@@ -318,6 +324,17 @@ declare const AiBudgetExceeded_base: Schema.TaggedErrorClass<AiBudgetExceeded, "
     attemptedUsd: typeof Schema.Number;
 }>;
 
+/** Invalid caller configuration, without echoing the supplied value. */
+export declare class AiBudgetInvalidInput extends AiBudgetInvalidInput_base {
+}
+
+declare const AiBudgetInvalidInput_base: Schema.TaggedErrorClass<AiBudgetInvalidInput, "AiBudgetInvalidInput", {
+    readonly _tag: Schema.tag<"AiBudgetInvalidInput">;
+} & {
+    field: Schema.Literal<["limitUsd", "addUsd", "since", "reservationId", "tenantId"]>;
+    message: typeof Schema.String;
+}>;
+
 export declare interface AiBudgetReservation {
     readonly reservationId: string;
     readonly tenantId: string | null;
@@ -325,6 +342,17 @@ export declare interface AiBudgetReservation {
     readonly status: 'reserved' | 'replayed';
 }
 
+/** A durable reservation identity cannot be rebound or spent after release. */
+export declare class AiBudgetReservationConflict extends AiBudgetReservationConflict_base {
+}
+
+declare const AiBudgetReservationConflict_base: Schema.TaggedErrorClass<AiBudgetReservationConflict, "AiBudgetReservationConflict", {
+    readonly _tag: Schema.tag<"AiBudgetReservationConflict">;
+} & {
+    reason: Schema.Literal<["identity-bound", "already-released"]>;
+    message: typeof Schema.String;
+}>;
+
 /** Receipt and release tombstone. A receipt and its counter change commit together. */
 export declare const aiBudgetReservationsTable: Table<typeof AI_BUDGET_RESERVATIONS_TABLE, Record<string, ColumnDefinition<unknown>>, true>;
 
@@ -1146,6 +1174,14 @@ export declare interface DefineEvalInput {
  */
 export declare const definePrompt: (definition: PromptDefinition) => DefinedPrompt;
 
+/**
+ * Declare an authenticated, server-owned voice/text relay as a *.ws.ts route.
+ * This uses the gateway listener, not the physical RPC subscription socket.
+ * Credentials, provider configuration and raw provider events stay server-side.
+ * No reconnection or replay is attempted: a new connection is a new paid session.
+ */
+export declare const defineRealtimeSession: (options: RealtimeSessionOptions) => WebSocketGatewayRoute;
+
 export declare const defineTool: <A, I, O>(def: {
     readonly name: string;
     readonly description: string;
@@ -2609,7 +2645,7 @@ export declare interface ModelDataPolicy {
     readonly noTraining: PolicyCoverage;
 }
 
-export declare type ModelModality = 'language' | 'embedding' | 'image' | 'video' | 'realtime' | 'reranking' | 'speech' | 'transcription' | 'unknown';
+export declare type ModelModality = 'language' | 'embedding' | 'image' | 'video' | 'realtime' | 'reranking' | 'speech' | 'transcription' | 'evaluation' | 'unknown';
 
 export declare interface ModelPrice {
     /** USD per 1,000,000 input (prompt) tokens. */
@@ -3005,6 +3041,106 @@ export declare interface ReadRecorder<S extends QueryableStore> {
     reset(): void;
 }
 
+/** Browser-safe input allowlist. Session configuration and provider credentials
+ * belong to the server, never to events received from the browser. */
+export declare const RealtimeClientEvent: Schema.Union<[Schema.Struct<{
+    type: Schema.Literal<["input-audio-append"]>;
+    audio: Schema.filter<typeof Schema.String>;
+}>, Schema.Struct<{
+    type: Schema.Literal<["input-audio-commit", "input-audio-clear", "response-create", "response-cancel"]>;
+}>, Schema.Struct<{
+    type: Schema.Literal<["conversation-item-create"]>;
+    item: Schema.Struct<{
+        type: Schema.Literal<["text-message"]>;
+        role: Schema.Literal<["user"]>;
+        text: typeof Schema.String;
+    }>;
+}>, Schema.Struct<{
+    type: Schema.Literal<["conversation-item-truncate"]>;
+    itemId: typeof Schema.String;
+    contentIndex: Schema.filter<Schema.filter<Schema.filter<typeof Schema.Number>>>;
+    audioEndMs: Schema.filter<Schema.filter<typeof Schema.Number>>;
+}>]>;
+
+export declare type RealtimeClientEvent = typeof RealtimeClientEvent.Type;
+
+/** Safe, normalized server events. No raw provider payload, client secret,
+ * arbitrary conversation item or provider error message crosses this surface. */
+export declare const RealtimeServerEvent: Schema.Union<[Schema.Struct<{
+    type: Schema.Literal<["ready"]>;
+}>, Schema.Struct<{
+    type: Schema.Literal<["session-created"]>;
+    sessionId: Schema.optional<typeof Schema.String>;
+}>, Schema.Struct<{
+    type: Schema.Literal<["session-updated"]>;
+}>, Schema.Struct<{
+    type: Schema.Literal<["speech-started", "speech-stopped"]>;
+    itemId: Schema.optional<typeof Schema.String>;
+}>, Schema.Struct<{
+    type: Schema.Literal<["audio-committed"]>;
+    itemId: Schema.optional<typeof Schema.String>;
+    previousItemId: Schema.optional<typeof Schema.String>;
+}>, Schema.Struct<{
+    itemId: typeof Schema.String;
+    type: Schema.Literal<["conversation-item-added"]>;
+}>, Schema.Struct<{
+    transcript: typeof Schema.String;
+    itemId: typeof Schema.String;
+    type: Schema.Literal<["input-transcription-completed"]>;
+}>, Schema.Struct<{
+    type: Schema.Literal<["response-created"]>;
+    responseId: typeof Schema.String;
+}>, Schema.Struct<{
+    type: Schema.Literal<["response-done"]>;
+    responseId: typeof Schema.String;
+    status: typeof Schema.String;
+}>, Schema.Struct<{
+    itemId: typeof Schema.String;
+    responseId: typeof Schema.String;
+    type: Schema.Literal<["output-item-added", "output-item-done", "content-part-added", "content-part-done", "audio-done"]>;
+}>, Schema.Struct<{
+    delta: Schema.filter<typeof Schema.String>;
+    itemId: typeof Schema.String;
+    responseId: typeof Schema.String;
+    type: Schema.Literal<["audio-delta"]>;
+}>, Schema.Struct<{
+    delta: typeof Schema.String;
+    itemId: typeof Schema.String;
+    responseId: typeof Schema.String;
+    type: Schema.Literal<["text-delta", "audio-transcript-delta"]>;
+}>, Schema.Struct<{
+    text: Schema.optional<typeof Schema.String>;
+    itemId: typeof Schema.String;
+    responseId: typeof Schema.String;
+    type: Schema.Literal<["text-done"]>;
+}>, Schema.Struct<{
+    transcript: Schema.optional<typeof Schema.String>;
+    itemId: typeof Schema.String;
+    responseId: typeof Schema.String;
+    type: Schema.Literal<["audio-transcript-done"]>;
+}>]>;
+
+export declare type RealtimeServerEvent = typeof RealtimeServerEvent.Type;
+
+export declare interface RealtimeSessionOptions {
+    readonly path: `/${string}`;
+    readonly model: Experimental_RealtimeModelV4;
+    /** Runs before minting/opening. Authentication alone does not authorize AI spend. */
+    readonly authorize: (subject: Subject, model: {
+        readonly provider: string;
+        readonly modelId: string;
+    }) => Effect.Effect<boolean, unknown>;
+    /** Server-owned configuration. Tool execution is not supported by this relay. */
+    readonly sessionConfig: Omit<Experimental_RealtimeModelV4SessionConfig, 'tools'>;
+    readonly limits?: {
+        readonly maxMessageBytes?: number;
+        readonly maxPendingBytes?: number;
+        readonly maxPendingMessages?: number;
+        readonly setupTimeoutMs?: number;
+        readonly maxDurationMs?: number;
+    };
+}
+
 export declare const recordAiUsage: (store: DataStore, record: AiUsageRecordInput) => Effect.Effect<CostBreakdown & {
     readonly receipt: AiUsageReceipt;
 }, AiUsageReceiptConflict | AiUsageLedgerError>;
@@ -3179,7 +3315,7 @@ export declare const registerStream: (streamId: string) => AbortController;
 export declare const releaseAiBudget: (store: DataStore, opts: {
     readonly reservationId: string;
     readonly tenantId: string | null;
-}) => Effect.Effect<"released" | "already-released" | "not-found">;
+}) => Effect.Effect<"released" | "already-released" | "not-found", AiBudgetInvalidInput>;
 
 export declare const releasedAtOf: (raw: RawGatewayModel) => string | undefined;
 
@@ -3199,7 +3335,8 @@ export declare interface RenderedPrompt extends PromptStamp {
 export declare const replacesBuiltinSpeechProvider: (name: string) => boolean;
 
 /** Reserve before provider I/O. Reuse reservationId only for the same logical
- * spend, tenant, amount and window. Zero is check-only and returns null.
+ * spend, tenant, amount and window. Zero checks for strictly positive headroom
+ * and returns null; it never creates a free reservation.
  * Call outside another transaction; the receipt and counter need one commit.
  * A provider failure does not automatically release possibly billed spend. */
 export declare const requireAiBudget: (store: DataStore, opts: {
@@ -3208,7 +3345,7 @@ export declare const requireAiBudget: (store: DataStore, opts: {
     readonly addUsd?: number;
     readonly since?: Date;
     readonly reservationId?: string;
-}) => Effect.Effect<AiBudgetReservation | null, AiBudgetExceeded>;
+}) => Effect.Effect<AiBudgetReservation | null, AiBudgetError>;
 
 /**
  * Rerank `documents` by relevance to `query`, highest score first. Returns
@@ -3274,6 +3411,9 @@ export declare const resolveMcpBounds: (overrides: Partial<McpBounds> | undefine
 
 export declare const resolveModel: (config: ProviderConfig, middleware?: AiMiddleware | ReadonlyArray<AiMiddleware>) => LanguageModelV4;
 
+/** Resolve supported server-owned provider configuration to the SDK codec. */
+export declare const resolveRealtimeModel: (config: ProviderConfig) => Experimental_RealtimeModelV4;
+
 export declare const resolveSpeechModel: (config: ProviderConfig) => SpeechModelV4;
 
 /** Resolve the system prompt for a given decoded input. */
@@ -3915,6 +4055,20 @@ export declare const streamTextWithFallback: (options: StreamTextOptions) => Str
  */
 export declare const streamTextWithRetry: (options: StreamTextOptions, retry?: StreamRetryOptions) => Stream.Stream<AgentEvent>;
 
+/** Live partial transcription, not container decoding or a durable workflow journal.
+ * No automatic retry: replaying audio can duplicate transcript segments and charges.
+ * Raw provider chunks, headers and private metadata are never emitted. */
+export declare const streamTranscribe: (options: StreamTranscribeOptions) => Stream.Stream<TranscriptionStreamEvent, TranscriptionStreamError>;
+
+export declare interface StreamTranscribeOptions {
+    /** Single-use raw audio source. Scope interruption cancels it and the provider. */
+    readonly audio: ReadableStream<Uint8Array>;
+    readonly inputAudioFormat: TranscriptionAudioFormat;
+    readonly provider?: ProviderConfig;
+    readonly providerOptions?: AiProviderOptions;
+    readonly signal?: AbortSignal;
+}
+
 /** A synthesized tool's metadata (the discovery/inventory view). */
 export declare interface SynthesizedTool {
     readonly name: string;
@@ -3975,7 +4129,7 @@ export declare interface ToolContext {
     readonly runtime?: Runtime.Runtime<unknown>;
     /** SDK tool-call identity for this execution, not a durable application idempotency key. */
     readonly invocationId?: string;
-    /** The SDK's cancellation signal; Promise handlers must pass it to their I/O. */
+    /** Cancellation from either the caller's turn or SDK invocation; Promise handlers must pass it to their I/O. */
     readonly abortSignal?: AbortSignal;
 }
 
@@ -4055,6 +4209,13 @@ export declare interface TranscribeOptions {
     readonly providerOptions?: AiProviderOptions;
 }
 
+/** Raw audio only. Container files must be decoded before entering this stream. */
+export declare interface TranscriptionAudioFormat {
+    readonly type: 'audio/pcm' | 'audio/pcmu' | 'audio/pcma';
+    /** Required for PCM; other formats may declare their provider-supported rate. */
+    readonly rate?: number;
+}
+
 export declare interface TranscriptionResult {
     readonly text: string;
     readonly language?: string;
@@ -4105,6 +4266,50 @@ export declare type TranscriptionSource =
     readonly mediaType: string;
 };
 
+/** Browser-safe error contract for a declared transcription stream. */
+export declare class TranscriptionStreamError extends TranscriptionStreamError_base {
+}
+
+declare const TranscriptionStreamError_base: Schema.TaggedErrorClass<TranscriptionStreamError, "TranscriptionStreamError", {
+    readonly _tag: Schema.tag<"TranscriptionStreamError">;
+} & {
+    reason: Schema.Literal<["input", "unsupported", "provider", "cancelled"]>;
+    message: typeof Schema.String;
+}>;
+
+/** Partial text is replaceable, delta text is append-only, and final text seals a segment. */
+export declare const TranscriptionStreamEvent: Schema.Union<[Schema.Struct<{
+    delta: typeof Schema.String;
+    id: Schema.optional<typeof Schema.String>;
+    type: Schema.Literal<["transcript-delta"]>;
+}>, Schema.Struct<{
+    text: typeof Schema.String;
+    startSecond: Schema.optional<typeof Schema.Number>;
+    durationInSeconds: Schema.optional<typeof Schema.Number>;
+    channelIndex: Schema.optional<typeof Schema.Number>;
+    id: Schema.optional<typeof Schema.String>;
+    type: Schema.Literal<["transcript-partial"]>;
+}>, Schema.Struct<{
+    text: typeof Schema.String;
+    startSecond: Schema.optional<typeof Schema.Number>;
+    endSecond: Schema.optional<typeof Schema.Number>;
+    channelIndex: Schema.optional<typeof Schema.Number>;
+    id: Schema.optional<typeof Schema.String>;
+    type: Schema.Literal<["transcript-final"]>;
+}>, Schema.Struct<{
+    type: Schema.Literal<["finish"]>;
+    text: typeof Schema.String;
+    segments: Schema.Array$<Schema.Struct<{
+        text: typeof Schema.String;
+        start: typeof Schema.Number;
+        end: typeof Schema.Number;
+    }>>;
+    language: Schema.optional<typeof Schema.String>;
+    durationSec: Schema.optional<typeof Schema.Number>;
+}>]>;
+
+export declare type TranscriptionStreamEvent = typeof TranscriptionStreamEvent.Type;
+
 /** How much timestamp detail to ask for. Providers charge for it. */
 export declare type TranscriptionTimestamps = 'none' | 'segment' | 'word';