@voltro/ai 0.84.0 → 0.86.0

package/dist/embed.js

@@ -0,0 +1,41 @@
+import { aiGenerationError as e } from "./api.js";
+import { embeddingProviderFromEnv as t, resolveEmbeddingModel as n } from "./embeddingProvider.js";
+import { cosineSimilarity as r, embed as i, embedMany as a } from "ai";
+import { Effect as o } from "effect";
+//#region src/embed.ts
+var s = (r, a) => o.tryPromise({
+	try: async (e) => {
+		let o = a ?? t();
+		l(o.expectedDimensions);
+		let s = await n(o), c = await i({
+			model: s,
+			value: r,
+			abortSignal: e,
+			...o.providerOptions === void 0 ? {} : { providerOptions: o.providerOptions }
+		});
+		return u(c.embedding, o.expectedDimensions, 0), c.embedding;
+	},
+	catch: (t) => e(t)
+}), c = (r, i) => o.tryPromise({
+	try: async (e) => {
+		let o = i ?? t();
+		l(o.expectedDimensions);
+		let s = await n(o), c = await a({
+			model: s,
+			values: [...r],
+			abortSignal: e,
+			...o.providerOptions === void 0 ? {} : { providerOptions: o.providerOptions }
+		});
+		if (c.embeddings.length !== r.length) throw Error(`embedMany: expected ${r.length} vectors, received ${c.embeddings.length}`);
+		return c.embeddings.forEach((e, t) => u(e, o.expectedDimensions, t)), c.embeddings;
+	},
+	catch: (t) => e(t)
+}), l = (e) => {
+	if (e !== void 0 && (!Number.isSafeInteger(e) || e <= 0)) throw Error("embedding expectedDimensions must be a positive safe integer");
+}, u = (e, t, n) => {
+	if (!Array.isArray(e)) throw Error(`embedding ${n}: expected a vector array`);
+	if (t !== void 0 && e.length !== t) throw Error(`embedding ${n}: expected ${t} dimensions, received ${e.length}`);
+	if (e.length === 0 || e.some((e) => !Number.isFinite(e))) throw Error(`embedding ${n}: expected a non-empty vector of finite numbers`);
+}, d = (e, t) => r([...e], [...t]);
+//#endregion
+export { d as cosineSimilarity, s as embed, c as embedMany };

package/dist/embeddingProvider.js

@@ -0,0 +1,51 @@
+import { createGateway as e, gateway as t } from "@ai-sdk/gateway";
+//#region src/embeddingProvider.ts
+var n = (e, t) => ({
+	specificationVersion: "v4",
+	provider: "mock",
+	modelId: e,
+	maxEmbeddingsPerCall: 2048,
+	supportsParallelCalls: !0,
+	doEmbed: async ({ values: e }) => ({
+		embeddings: e.map((e) => r(e, t)),
+		usage: { tokens: e.reduce((e, t) => e + t.length, 0) },
+		warnings: []
+	})
+}), r = (e, t) => {
+	let n = Array(t);
+	for (let r = 0; r < t; r++) {
+		let t = 2166136261 ^ r * 16777619;
+		for (let n = 0; n < e.length; n++) t ^= e.charCodeAt(n), t = Math.imul(t, 16777619);
+		n[r] = (t >>> 0) / 4294967295 * 2 - 1;
+	}
+	return n;
+}, i = async (r) => {
+	switch (r.name) {
+		case "mock": return n(r.model, r.mockDim ?? 8);
+		case "openai": return (await a("@ai-sdk/openai", "openai")).openai.textEmbeddingModel(r.model);
+		case "voyage": return (await a("voyage-ai-provider", "voyage")).voyage.textEmbeddingModel(r.model);
+		case "cohere": return (await a("@ai-sdk/cohere", "cohere")).cohere.textEmbeddingModel(r.model);
+		case "gateway": return (r.apiKey !== void 0 || r.baseURL !== void 0 ? e({
+			...r.apiKey === void 0 ? {} : { apiKey: r.apiKey },
+			...r.baseURL === void 0 ? {} : { baseURL: r.baseURL }
+		}) : t).embeddingModel(r.model);
+	}
+}, a = async (e, t) => {
+	try {
+		return await import(
+			/* @vite-ignore */
+			e
+);
+	} catch {
+		throw Error(`embedding provider '${t}' needs the '${e}' package — install it (pnpm add ${e}) or use AI_EMBED_PROVIDER=mock for tests/demos.`);
+	}
+}, o = (e = process.env) => {
+	let t = (e.AI_EMBED_PROVIDER ?? "mock").toLowerCase(), n = t === "openai" ? "text-embedding-3-small" : t === "voyage" ? "voyage-3" : t === "cohere" ? "embed-english-v3.0" : t === "gateway" ? "openai/text-embedding-3-small" : "mock", r = e.AI_EMBED_MODEL ?? n, i = e.AI_EMBED_MOCK_DIM === void 0 ? void 0 : Number(e.AI_EMBED_MOCK_DIM);
+	return {
+		name: t,
+		model: r,
+		...i !== void 0 && Number.isFinite(i) ? { mockDim: i } : {}
+	};
+};
+//#endregion
+export { o as embeddingProviderFromEnv, r as hashToVector, i as resolveEmbeddingModel };

package/dist/eval.js

@@ -0,0 +1,130 @@
+import { providerFromEnv as e } from "./provider.js";
+import { generateObject as t } from "./api.js";
+import { Effect as n, Schema as r } from "effect";
+//#region src/eval.ts
+var i = (e) => {
+	if (e.name.trim() === "") throw Error("defineEval: name must be non-empty");
+	if (e.cases.length === 0) throw Error(`defineEval "${e.name}": at least one case is required`);
+	let t = /* @__PURE__ */ new Set();
+	for (let n of e.cases) {
+		if (n.id.trim() === "") throw Error(`defineEval "${e.name}": every case needs a non-empty id`);
+		if (t.has(n.id)) throw Error(`defineEval "${e.name}": duplicate case id "${n.id}"`);
+		t.add(n.id);
+	}
+	let n = e.judge?.threshold;
+	if (n !== void 0 && (n < 0 || n > 1)) throw Error(`defineEval "${e.name}": judge.threshold must be within 0..1 (got ${n})`);
+	return {
+		...e,
+		__eval: !0
+	};
+}, a = (e) => typeof e == "object" && !!e && "__eval" in e && e.__eval === !0, o = (e, t) => {
+	let n = [], r = e.text;
+	for (let i of t) switch (i.kind) {
+		case "contains": {
+			let e = i.caseInsensitive ? r.toLowerCase() : r, t = i.caseInsensitive ? i.value.toLowerCase() : i.value;
+			e.includes(t) || n.push({
+				assertion: i,
+				detail: `output does not contain "${i.value}"`
+			});
+			break;
+		}
+		case "notContains": {
+			let e = i.caseInsensitive ? r.toLowerCase() : r, t = i.caseInsensitive ? i.value.toLowerCase() : i.value;
+			e.includes(t) && n.push({
+				assertion: i,
+				detail: `output unexpectedly contains "${i.value}"`
+			});
+			break;
+		}
+		case "matches": {
+			let e;
+			try {
+				e = new RegExp(i.pattern, i.flags);
+			} catch (e) {
+				n.push({
+					assertion: i,
+					detail: `invalid pattern /${i.pattern}/: ${e.message}`
+				});
+				break;
+			}
+			e.test(r) || n.push({
+				assertion: i,
+				detail: `output does not match /${i.pattern}/`
+			});
+			break;
+		}
+		case "equals":
+			(i.trim ? r.trim() : r) !== (i.trim ? i.value.trim() : i.value) && n.push({
+				assertion: i,
+				detail: "output is not equal to the expected value"
+			});
+			break;
+		case "maxLatencyMs":
+			e.latencyMs > i.value && n.push({
+				assertion: i,
+				detail: `latency ${e.latencyMs}ms exceeds ${i.value}ms`
+			});
+			break;
+		case "nonEmpty": r.trim() === "" && n.push({
+			assertion: i,
+			detail: "output is empty"
+		});
+	}
+	return n;
+}, s = .7, c = (e, t, n, r, i) => {
+	let a = o(t, [...n, ...e.assert ?? []]), s = r?.threshold ?? .7, c = i === void 0 || i.score >= s;
+	return {
+		id: e.id,
+		pass: a.length === 0 && c,
+		assertionFailures: a,
+		...i === void 0 ? {} : { judge: i },
+		output: t
+	};
+}, l = async (e, t) => {
+	let n = [];
+	for (let r of e.cases) {
+		let i = await t.replay({
+			case: r,
+			def: e
+		}), a = e.judge !== void 0 && t.judge !== void 0 ? await t.judge({
+			case: r,
+			output: i,
+			config: e.judge
+		}) : void 0;
+		n.push(c(r, i, e.assert ?? [], e.judge, a));
+	}
+	let r = n.filter((e) => !e.pass).length;
+	return {
+		name: e.name,
+		ok: r === 0,
+		passed: n.length - r,
+		failed: r,
+		cases: n,
+		...t.branchId === void 0 ? {} : { branch: { id: t.branchId } }
+	};
+}, u = r.Struct({
+	pass: r.Boolean,
+	score: r.Number,
+	reason: r.String
+}), d = (e, t, n) => [
+	"You are grading an AI assistant response against a rubric. Respond with a JSON",
+	"object { pass: boolean, score: number (0..1), reason: string }. Score 1 is a",
+	"perfect response, 0 is unusable. Be strict: a plausible-sounding but wrong or",
+	"incomplete answer scores low.",
+	"",
+	`RUBRIC:\n${n.rubric}`,
+	...e.golden === void 0 ? [] : ["", `REFERENCE (the previously-accepted answer):\n${e.golden}`],
+	...e.input.prompt === "" ? [] : ["", `USER PROMPT:\n${e.input.prompt}`],
+	"",
+	`CANDIDATE RESPONSE (to grade):\n${t.text}`
+].join("\n"), f = async ({ case: r, output: i, config: a }) => await n.runPromise(t({
+	schema: u,
+	prompt: d(r, i, a),
+	provider: e()
+}).pipe(n.map((e) => e.object), n.catch((e) => n.succeed({
+	pass: !1,
+	score: 0,
+	reason: `judge failed: ${e.message}`
+}))));
+//#endregion
+export { s as DEFAULT_JUDGE_THRESHOLD, i as defineEval, o as evaluateAssertions, a as isEvalDefinition, f as llmJudge, l as runEval, c as scoreCase };

package/dist/events.d.ts

@@ -1,63 +1,66 @@
 import { Schema } from 'effect';
+import { YieldableError } from 'effect/Cause';
 
 /** Error taxonomy. `retryable` on the event drives client/agent retry. */
-export declare const AgentErrorCode: Schema.Literal<["provider", "tool", "timeout", "cancelled", "decode", "internal"]>;
+export declare const AgentErrorCode: Schema.Literals<readonly ["provider", "tool", "timeout", "cancelled", "decode", "internal"]>;
 
 export declare type AgentErrorCode = typeof AgentErrorCode.Type;
 
-export declare const AgentEvent: Schema.Union<[Schema.Struct<{
-    _tag: Schema.Literal<["token"]>;
-    text: typeof Schema.String;
+export declare const AgentEvent: Schema.Union<readonly [Schema.Struct<{
+    readonly _tag: Schema.Literal<"token">;
+    readonly text: Schema.String;
 }>, Schema.Struct<{
-    _tag: Schema.Literal<["reasoning"]>;
-    text: typeof Schema.String;
+    readonly _tag: Schema.Literal<"reasoning">;
+    readonly text: Schema.String;
 }>, Schema.Struct<{
-    _tag: Schema.Literal<["toolCall"]>;
-    id: typeof Schema.String;
-    name: typeof Schema.String;
-    input: typeof Schema.Unknown;
+    readonly _tag: Schema.Literal<"toolCall">;
+    readonly id: Schema.String;
+    readonly name: Schema.String;
+    readonly input: Schema.Unknown;
+    /** Present when the caller must execute this pending call. */
+    readonly execution: Schema.optional<Schema.Literal<"client">>;
 }>, Schema.Struct<{
-    _tag: Schema.Literal<["toolResult"]>;
-    id: typeof Schema.String;
-    name: typeof Schema.String;
-    output: Schema.optional<typeof Schema.Unknown>;
-    error: Schema.optional<typeof Schema.String>;
+    readonly _tag: Schema.Literal<"toolResult">;
+    readonly id: Schema.String;
+    readonly name: Schema.String;
+    readonly output: Schema.optional<Schema.Unknown>;
+    readonly error: Schema.optional<Schema.String>;
 }>, Schema.Struct<{
-    _tag: Schema.Literal<["source"]>;
-    sourceType: Schema.Literal<["url", "document"]>;
-    id: typeof Schema.String;
-    url: Schema.optional<typeof Schema.String>;
-    title: Schema.optional<typeof Schema.String>;
-    mediaType: Schema.optional<typeof Schema.String>;
-    filename: Schema.optional<typeof Schema.String>;
+    readonly _tag: Schema.Literal<"source">;
+    readonly sourceType: Schema.Literals<readonly ["url", "document"]>;
+    readonly id: Schema.String;
+    readonly url: Schema.optional<Schema.String>;
+    readonly title: Schema.optional<Schema.String>;
+    readonly mediaType: Schema.optional<Schema.String>;
+    readonly filename: Schema.optional<Schema.String>;
     /** Provider-owned citation attribution; not normalized or interpreted. */
-    providerMetadata: Schema.optional<typeof Schema.Unknown>;
+    readonly providerMetadata: Schema.optional<Schema.Unknown>;
 }>, Schema.Struct<{
-    _tag: Schema.Literal<["file"]>;
-    mediaType: typeof Schema.String;
-    data: typeof Schema.String;
+    readonly _tag: Schema.Literal<"file">;
+    readonly mediaType: Schema.String;
+    readonly data: Schema.String;
     /** Metadata for this file, not the whole model step. */
-    providerMetadata: Schema.optional<typeof Schema.Unknown>;
+    readonly providerMetadata: Schema.optional<Schema.Unknown>;
 }>, Schema.Struct<{
-    _tag: Schema.Literal<["stepMetadata"]>;
-    step: Schema.filter<typeof Schema.Int>;
-    providerMetadata: typeof Schema.Unknown;
+    readonly _tag: Schema.Literal<"stepMetadata">;
+    readonly step: Schema.Int;
+    readonly providerMetadata: Schema.Unknown;
 }>, Schema.Struct<{
-    _tag: Schema.Literal<["message"]>;
-    role: typeof Schema.String;
-    content: typeof Schema.String;
+    readonly _tag: Schema.Literal<"message">;
+    readonly role: Schema.String;
+    readonly content: Schema.String;
 }>, Schema.Struct<{
-    _tag: Schema.Literal<["error"]>;
-    code: Schema.Literal<["provider", "tool", "timeout", "cancelled", "decode", "internal"]>;
-    message: typeof Schema.String;
-    retryable: typeof Schema.Boolean;
+    readonly _tag: Schema.Literal<"error">;
+    readonly code: Schema.Literals<readonly ["provider", "tool", "timeout", "cancelled", "decode", "internal"]>;
+    readonly message: Schema.String;
+    readonly retryable: Schema.Boolean;
 }>, Schema.Struct<{
-    _tag: Schema.Literal<["done"]>;
-    finishReason: typeof Schema.String;
-    usage: Schema.Struct<{
-        inputTokens: Schema.optional<typeof Schema.Number>;
-        outputTokens: Schema.optional<typeof Schema.Number>;
-        totalTokens: Schema.optional<typeof Schema.Number>;
+    readonly _tag: Schema.Literal<"done">;
+    readonly finishReason: Schema.String;
+    readonly usage: Schema.Struct<{
+        readonly inputTokens: Schema.optional<Schema.Number>;
+        readonly outputTokens: Schema.optional<Schema.Number>;
+        readonly totalTokens: Schema.optional<Schema.Number>;
     }>;
 }>]>;
 
@@ -65,81 +68,81 @@ 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>;
+export declare const RealtimeClientEvent: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"input-audio-append">;
+    readonly audio: Schema.String;
 }>, Schema.Struct<{
-    type: Schema.Literal<["input-audio-commit", "input-audio-clear", "response-create", "response-cancel"]>;
+    readonly type: Schema.Literals<readonly ["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;
+    readonly type: Schema.Literal<"conversation-item-create">;
+    readonly item: Schema.Struct<{
+        readonly type: Schema.Literal<"text-message">;
+        readonly role: Schema.Literal<"user">;
+        readonly text: 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>>;
+    readonly type: Schema.Literal<"conversation-item-truncate">;
+    readonly itemId: Schema.String;
+    readonly contentIndex: Schema.Number;
+    readonly audioEndMs: 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"]>;
+export declare const RealtimeServerEvent: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"ready">;
 }>, Schema.Struct<{
-    type: Schema.Literal<["session-created"]>;
-    sessionId: Schema.optional<typeof Schema.String>;
+    readonly type: Schema.Literal<"session-created">;
+    readonly sessionId: Schema.optional<Schema.String>;
 }>, Schema.Struct<{
-    type: Schema.Literal<["session-updated"]>;
+    readonly type: Schema.Literal<"session-updated">;
 }>, Schema.Struct<{
-    type: Schema.Literal<["speech-started", "speech-stopped"]>;
-    itemId: Schema.optional<typeof Schema.String>;
+    readonly type: Schema.Literals<readonly ["speech-started", "speech-stopped"]>;
+    readonly itemId: Schema.optional<Schema.String>;
 }>, Schema.Struct<{
-    type: Schema.Literal<["audio-committed"]>;
-    itemId: Schema.optional<typeof Schema.String>;
-    previousItemId: Schema.optional<typeof Schema.String>;
+    readonly type: Schema.Literal<"audio-committed">;
+    readonly itemId: Schema.optional<Schema.String>;
+    readonly previousItemId: Schema.optional<Schema.String>;
 }>, Schema.Struct<{
-    itemId: typeof Schema.String;
-    type: Schema.Literal<["conversation-item-added"]>;
+    readonly itemId: Schema.String;
+    readonly type: Schema.Literal<"conversation-item-added">;
 }>, Schema.Struct<{
-    transcript: typeof Schema.String;
-    itemId: typeof Schema.String;
-    type: Schema.Literal<["input-transcription-completed"]>;
+    readonly transcript: Schema.String;
+    readonly itemId: Schema.String;
+    readonly type: Schema.Literal<"input-transcription-completed">;
 }>, Schema.Struct<{
-    type: Schema.Literal<["response-created"]>;
-    responseId: typeof Schema.String;
+    readonly type: Schema.Literal<"response-created">;
+    readonly responseId: Schema.String;
 }>, Schema.Struct<{
-    type: Schema.Literal<["response-done"]>;
-    responseId: typeof Schema.String;
-    status: typeof Schema.String;
+    readonly type: Schema.Literal<"response-done">;
+    readonly responseId: Schema.String;
+    readonly status: 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"]>;
+    readonly itemId: Schema.String;
+    readonly responseId: Schema.String;
+    readonly type: Schema.Literals<readonly ["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"]>;
+    readonly delta: Schema.String;
+    readonly itemId: Schema.String;
+    readonly responseId: Schema.String;
+    readonly 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"]>;
+    readonly delta: Schema.String;
+    readonly itemId: Schema.String;
+    readonly responseId: Schema.String;
+    readonly type: Schema.Literals<readonly ["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"]>;
+    readonly text: Schema.optional<Schema.String>;
+    readonly itemId: Schema.String;
+    readonly responseId: Schema.String;
+    readonly 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"]>;
+    readonly transcript: Schema.optional<Schema.String>;
+    readonly itemId: Schema.String;
+    readonly responseId: Schema.String;
+    readonly type: Schema.Literal<"audio-transcript-done">;
 }>]>;
 
 export declare type RealtimeServerEvent = typeof RealtimeServerEvent.Type;
@@ -156,60 +159,62 @@ export declare type RealtimeServerEvent = typeof RealtimeServerEvent.Type;
  * client bundle.
  */
 export declare const SeqEvent: Schema.Struct<{
-    seq: typeof Schema.Number;
-    event: Schema.Union<[Schema.Struct<{
-        _tag: Schema.Literal<["token"]>;
-        text: typeof Schema.String;
+    readonly seq: Schema.Number;
+    readonly event: Schema.Union<readonly [Schema.Struct<{
+        readonly _tag: Schema.Literal<"token">;
+        readonly text: Schema.String;
     }>, Schema.Struct<{
-        _tag: Schema.Literal<["reasoning"]>;
-        text: typeof Schema.String;
+        readonly _tag: Schema.Literal<"reasoning">;
+        readonly text: Schema.String;
     }>, Schema.Struct<{
-        _tag: Schema.Literal<["toolCall"]>;
-        id: typeof Schema.String;
-        name: typeof Schema.String;
-        input: typeof Schema.Unknown;
+        readonly _tag: Schema.Literal<"toolCall">;
+        readonly id: Schema.String;
+        readonly name: Schema.String;
+        readonly input: Schema.Unknown;
+        /** Present when the caller must execute this pending call. */
+        readonly execution: Schema.optional<Schema.Literal<"client">>;
     }>, Schema.Struct<{
-        _tag: Schema.Literal<["toolResult"]>;
-        id: typeof Schema.String;
-        name: typeof Schema.String;
-        output: Schema.optional<typeof Schema.Unknown>;
-        error: Schema.optional<typeof Schema.String>;
+        readonly _tag: Schema.Literal<"toolResult">;
+        readonly id: Schema.String;
+        readonly name: Schema.String;
+        readonly output: Schema.optional<Schema.Unknown>;
+        readonly error: Schema.optional<Schema.String>;
     }>, Schema.Struct<{
-        _tag: Schema.Literal<["source"]>;
-        sourceType: Schema.Literal<["url", "document"]>;
-        id: typeof Schema.String;
-        url: Schema.optional<typeof Schema.String>;
-        title: Schema.optional<typeof Schema.String>;
-        mediaType: Schema.optional<typeof Schema.String>;
-        filename: Schema.optional<typeof Schema.String>;
+        readonly _tag: Schema.Literal<"source">;
+        readonly sourceType: Schema.Literals<readonly ["url", "document"]>;
+        readonly id: Schema.String;
+        readonly url: Schema.optional<Schema.String>;
+        readonly title: Schema.optional<Schema.String>;
+        readonly mediaType: Schema.optional<Schema.String>;
+        readonly filename: Schema.optional<Schema.String>;
         /** Provider-owned citation attribution; not normalized or interpreted. */
-        providerMetadata: Schema.optional<typeof Schema.Unknown>;
+        readonly providerMetadata: Schema.optional<Schema.Unknown>;
     }>, Schema.Struct<{
-        _tag: Schema.Literal<["file"]>;
-        mediaType: typeof Schema.String;
-        data: typeof Schema.String;
+        readonly _tag: Schema.Literal<"file">;
+        readonly mediaType: Schema.String;
+        readonly data: Schema.String;
         /** Metadata for this file, not the whole model step. */
-        providerMetadata: Schema.optional<typeof Schema.Unknown>;
+        readonly providerMetadata: Schema.optional<Schema.Unknown>;
     }>, Schema.Struct<{
-        _tag: Schema.Literal<["stepMetadata"]>;
-        step: Schema.filter<typeof Schema.Int>;
-        providerMetadata: typeof Schema.Unknown;
+        readonly _tag: Schema.Literal<"stepMetadata">;
+        readonly step: Schema.Int;
+        readonly providerMetadata: Schema.Unknown;
     }>, Schema.Struct<{
-        _tag: Schema.Literal<["message"]>;
-        role: typeof Schema.String;
-        content: typeof Schema.String;
+        readonly _tag: Schema.Literal<"message">;
+        readonly role: Schema.String;
+        readonly content: Schema.String;
     }>, Schema.Struct<{
-        _tag: Schema.Literal<["error"]>;
-        code: Schema.Literal<["provider", "tool", "timeout", "cancelled", "decode", "internal"]>;
-        message: typeof Schema.String;
-        retryable: typeof Schema.Boolean;
+        readonly _tag: Schema.Literal<"error">;
+        readonly code: Schema.Literals<readonly ["provider", "tool", "timeout", "cancelled", "decode", "internal"]>;
+        readonly message: Schema.String;
+        readonly retryable: Schema.Boolean;
     }>, Schema.Struct<{
-        _tag: Schema.Literal<["done"]>;
-        finishReason: typeof Schema.String;
-        usage: Schema.Struct<{
-            inputTokens: Schema.optional<typeof Schema.Number>;
-            outputTokens: Schema.optional<typeof Schema.Number>;
-            totalTokens: Schema.optional<typeof Schema.Number>;
+        readonly _tag: Schema.Literal<"done">;
+        readonly finishReason: Schema.String;
+        readonly usage: Schema.Struct<{
+            readonly inputTokens: Schema.optional<Schema.Number>;
+            readonly outputTokens: Schema.optional<Schema.Number>;
+            readonly totalTokens: Schema.optional<Schema.Number>;
         }>;
     }>]>;
 }>;
@@ -220,42 +225,40 @@ export declare type SeqEvent = typeof SeqEvent.Type;
 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;
-}>;
+declare const TranscriptionStreamError_base: Schema.Class<TranscriptionStreamError, Schema.TaggedStruct<"TranscriptionStreamError", {
+    readonly reason: Schema.Literals<readonly ["input", "unsupported", "provider", "cancelled"]>;
+    readonly message: Schema.String;
+}>, YieldableError>;
 
 /** 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"]>;
+export declare const TranscriptionStreamEvent: Schema.Union<readonly [Schema.Struct<{
+    readonly delta: Schema.String;
+    readonly id: Schema.optional<Schema.String>;
+    readonly 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"]>;
+    readonly text: Schema.String;
+    readonly startSecond: Schema.optional<Schema.Number>;
+    readonly durationInSeconds: Schema.optional<Schema.Number>;
+    readonly channelIndex: Schema.optional<Schema.Number>;
+    readonly id: Schema.optional<Schema.String>;
+    readonly 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"]>;
+    readonly text: Schema.String;
+    readonly startSecond: Schema.optional<Schema.Number>;
+    readonly endSecond: Schema.optional<Schema.Number>;
+    readonly channelIndex: Schema.optional<Schema.Number>;
+    readonly id: Schema.optional<Schema.String>;
+    readonly 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;
+    readonly type: Schema.Literal<"finish">;
+    readonly text: Schema.String;
+    readonly segments: Schema.$Array<Schema.Struct<{
+        readonly text: Schema.String;
+        readonly start: Schema.Number;
+        readonly end: Schema.Number;
     }>>;
-    language: Schema.optional<typeof Schema.String>;
-    durationSec: Schema.optional<typeof Schema.Number>;
+    readonly language: Schema.optional<Schema.String>;
+    readonly durationSec: Schema.optional<Schema.Number>;
 }>]>;
 
 export declare type TranscriptionStreamEvent = typeof TranscriptionStreamEvent.Type;