@effect-uai/google 0.14.0 → 0.16.0

package/dist/models.d.mts

@@ -1,75 +1,2 @@
-//#region src/models.d.ts
-/**
- * Known Gemini model identifiers (as of April 2026). The `(string & {})`
- * tail keeps autocomplete on the literals while still accepting any string,
- * so newly-released models work without an SDK update.
- *
- * Reference: https://ai.google.dev/gemini-api/docs/models
- */
-type GoogleModel = "gemini-3.1-pro-preview" | "gemini-3-flash-preview" | "gemini-3.1-flash-lite-preview" | "gemini-3.1-flash-live-preview" | "gemini-3.1-flash-tts-preview" | "gemini-2.5-pro" | "gemini-2.5-flash" | "gemini-2.5-flash-lite" | "gemini-3.1-flash-image" | "gemini-3.1-flash-lite-image" | "gemini-3-pro-image" | (string & {});
-/**
- * Known Gemini image-generation model identifiers. The `-preview` ids
- * were shut down 2026-06-25 and are not listed; neither is the
- * previous-generation `gemini-2.5-flash-image`, which the `(string & {})`
- * tail still accepts.
- *
- * - `gemini-3.1-flash-image` — 512 / 1K / 2K / 4K, web and image search.
- * - `gemini-3.1-flash-lite-image` — 1K only, cheapest, no search.
- * - `gemini-3-pro-image` — 1K / 2K / 4K, the most reference images.
- *
- * Reference: https://ai.google.dev/gemini-api/docs/models
- */
-type GeminiImageModel = "gemini-3.1-flash-image" | "gemini-3.1-flash-lite-image" | "gemini-3-pro-image" | (string & {});
-/**
- * Deep-research agent identifiers for the Interactions API (`POST
- * /v1beta/interactions`). `-preview` is the fast tier, `-max-` the
- * comprehensive one. Preview surface: verify against live docs before relying on
- * exact ids. The `(string & {})` tail accepts any string so a renamed agent
- * works without an SDK update.
- *
- * Reference: https://ai.google.dev/gemini-api/docs/interactions/deep-research
- */
-type GoogleDeepResearchModel = "deep-research-preview-04-2026" | "deep-research-max-preview-04-2026" | (string & {});
-/**
- * Known Gemini embedding model identifiers.
- *
- * - `gemini-embedding-2` — natively multimodal (text, image, audio, video,
- *   PDF). Does *not* honour the `taskType` field; instead prepend a task
- *   instruction to the text yourself.
- * - `gemini-embedding-001` — text-only, supports the full `taskType` enum
- *   (`RETRIEVAL_QUERY` / `RETRIEVAL_DOCUMENT` / classification / etc.).
- *
- * The `(string & {})` tail accepts any string so newly-released models
- * work without an SDK update.
- *
- * Reference: https://ai.google.dev/gemini-api/docs/embeddings
- */
-/**
- * Known Gemini TTS model identifiers. `(string & {})` tail keeps
- * autocomplete on the literals while still accepting any string.
- *
- * Reference: https://ai.google.dev/gemini-api/docs/speech-generation
- */
-type GeminiTtsModel = "gemini-2.5-flash-preview-tts" | "gemini-2.5-pro-preview-tts" | "gemini-3.1-flash-tts-preview" | (string & {});
-/**
- * 30 prebuilt voice names for Gemini TTS. No custom-voice / cloning path
- * is exposed on this surface, so the tail is stock-only (no
- * `(string & {})` escape).
- *
- * Reference: https://ai.google.dev/gemini-api/docs/speech-generation
- */
-type GeminiVoiceName = "Zephyr" | "Puck" | "Charon" | "Kore" | "Fenrir" | "Leda" | "Orus" | "Aoede" | "Callirrhoe" | "Autonoe" | "Enceladus" | "Iapetus" | "Umbriel" | "Algieba" | "Despina" | "Erinome" | "Algenib" | "Rasalgethi" | "Laomedeia" | "Achernar" | "Alnilam" | "Schedar" | "Gacrux" | "Pulcherrima" | "Achird" | "Zubenelgenubi" | "Vindemiatrix" | "Sadachbia" | "Sadaltager" | "Sulafat";
-/**
- * Known Lyria (music generation) model identifiers. `(string & {})` tail
- * keeps autocomplete on the literals while still accepting any string.
- *
- * - `lyria-3-clip-preview` — fixed 30s output, MP3 only.
- * - `lyria-3-pro-preview` — up to a couple of minutes, MP3 or WAV.
- *
- * Reference: https://ai.google.dev/gemini-api/docs/music-generation
- */
-type LyriaModel = "lyria-3-clip-preview" | "lyria-3-pro-preview" | (string & {});
-type GoogleEmbeddingModel = "gemini-embedding-2" | "gemini-embedding-001" | (string & {});
-//#endregion
-export { GeminiImageModel, GeminiTtsModel, GeminiVoiceName, GoogleDeepResearchModel, GoogleEmbeddingModel, GoogleModel, LyriaModel };
-//# sourceMappingURL=models.d.mts.map
+import { a as GoogleDeepResearchModel, c as LyriaModel, i as GeminiVoiceName, n as GeminiLiveModel, o as GoogleEmbeddingModel, r as GeminiTtsModel, s as GoogleModel, t as GeminiImageModel } from "./models-BVSKJwCx.mjs";
+export { GeminiImageModel, GeminiLiveModel, GeminiTtsModel, GeminiVoiceName, GoogleDeepResearchModel, GoogleEmbeddingModel, GoogleModel, LyriaModel };

package/dist/realtimeSession-7HSIjWh4.d.mts

@@ -0,0 +1,62 @@
+import { n as GeminiLiveModel } from "./models-BVSKJwCx.mjs";
+import { Effect, Redacted, Scope } from "effect";
+import * as AiError from "@effect-uai/core/AiError";
+import { RealtimeSessionHandle } from "@effect-uai/core/RealtimeSession";
+import * as Socket from "effect/unstable/socket/Socket";
+import { CommonSessionRequest } from "@effect-uai/core/Realtime";
+//#region src/realtimeSession.d.ts
+type Config = {
+  readonly apiKey: Redacted.Redacted;
+  readonly baseUrl?: string;
+  /** Build the socket yourself, for a proxy or an in-memory transport. */
+  readonly webSocket?: Socket.WebSocketConstructor["Service"];
+};
+/**
+ * Gemini-typed session request. Everything past `CommonSessionRequest` is
+ * provider-shaped. The configuration is immutable for the connection: changing
+ * any of it means opening a new session.
+ */
+type GeminiLiveRequest = Omit<CommonSessionRequest, "model"> & {
+  readonly model: GeminiLiveModel;
+  /** Replaces the plain `turnDetection` switch when you need the knobs. */
+  readonly vad?: {
+    readonly startSensitivity?: "high" | "low";
+    readonly endSensitivity?: "high" | "low";
+    readonly prefixPaddingMs?: number;
+    readonly silenceDurationMs?: number;
+  };
+  /** `"none"` turns barge-in off. Defaults to interrupting. */
+  readonly activityHandling?: "interrupt" | "none";
+  /**
+   * When a tool result reaches the model, for the models that keep generating
+   * while a tool runs. Defaults to `"when-idle"`: the server's own default is
+   * to interrupt, which cuts off whatever the model was saying while it
+   * waited, including the "let me look that up" it just spoke. `"interrupt"`
+   * is right when the result cannot wait, `"silent"` when it is context the
+   * model should have rather than something to announce.
+   */
+  readonly toolScheduling?: "when-idle" | "interrupt" | "silent";
+  readonly turnCoverage?: "activity" | "all" | "audioActivityAndAllVideo";
+  /** 3.1 only. Higher levels delay the first audio. */
+  readonly thinkingLevel?: "minimal" | "low" | "medium" | "high";
+  readonly mediaResolution?: "low" | "medium" | "high";
+  readonly languageCode?: string;
+  readonly temperature?: number;
+  readonly maxOutputTokens?: number;
+  /** What turns an otherwise time-boxed session into an unbounded one. */
+  readonly contextCompression?: {
+    readonly triggerTokens?: number;
+    readonly targetTokens?: number;
+  };
+  /** Grounding. Cannot be combined with `tools`; the pair is a 400. */
+  readonly googleSearch?: boolean;
+  /** 2.5 only. */
+  readonly proactiveAudio?: boolean;
+  /** 2.5 only. */
+  readonly affectiveDialog?: boolean;
+};
+declare const buildWsUrl: (cfg: Config) => string;
+declare const openSession: (cfg: Config) => (request: GeminiLiveRequest) => Effect.Effect<RealtimeSessionHandle, AiError.AiError, Scope.Scope>;
+//#endregion
+export { openSession as i, GeminiLiveRequest as n, buildWsUrl as r, Config as t };
+//# sourceMappingURL=realtimeSession-7HSIjWh4.d.mts.map

package/dist/realtimeSession-7HSIjWh4.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"realtimeSession-7HSIjWh4.d.mts","names":[],"sources":["../src/realtimeSession.ts"],"mappings":";;;;;;;KA8CY;WACD,QAAQ,SAAS;WACjB;;WAEA,YAAY,OAAO;;;;;;;KAQlB,oBAAoB,KAAK;WAC1B,OAAO;;WAEP;aACE;aACA;aACA;aACA;;;WAGF;;;;;;;;;WASA;WACA;;WAEA;WACA;WACA;WACA;WACA;;WAEA;aACE;aACA;;;WAGF;;WAEA;;WAEA;;cAilBE,aAAU,KAAS;cAqCnB,cAAW,KAChB,YAAM,SAED,sBACR,OAAO,OAAO,uBAAuB,QAAQ,SAAS,MAAM"}

package/dist/realtimeSession.d.mts

@@ -0,0 +1,2 @@
+import { i as openSession, n as GeminiLiveRequest, r as buildWsUrl, t as Config } from "./realtimeSession-7HSIjWh4.mjs";
+export { Config, GeminiLiveRequest, buildWsUrl, openSession };

package/dist/realtimeSession.mjs

@@ -0,0 +1,406 @@
+import { parsedResponse, toolDescriptorsToTools } from "./codec.mjs";
+import { Cause, Duration, Effect, Encoding, Match, Pull, Queue, Redacted, Ref, Result, Schema, Stream } from "effect";
+import * as AiError from "@effect-uai/core/AiError";
+import * as Capabilities from "@effect-uai/core/Capabilities";
+import * as Socket from "effect/unstable/socket/Socket";
+import { RealtimeEvent } from "@effect-uai/core/Realtime";
+import * as WebSocketSession from "@effect-uai/core/WebSocketSession";
+//#region src/realtimeSession.ts
+/**
+* Gemini Live speech-to-speech over `BidiGenerateContent`.
+*
+* Auth is a query parameter, so this needs no `ws` package and no headers:
+* the platform `WebSocket` reaches it from Node, Bun, Deno and the browser.
+*
+* Two shapes differ from OpenAI Realtime and drive most of this file. There
+* are no response ids on the wire, so a turn id is minted here and every event
+* of that turn carries it; and there is no truncate op, so a
+* `PlaybackPosition` has nothing to send.
+*/
+const PROVIDER = "gemini-live";
+const DEFAULT_BASE_URL = "wss://generativelanguage.googleapis.com";
+const RPC = "ws/google.ai.generativelanguage.v1beta.GenerativeService.BidiGenerateContent";
+/** Output is 24 kHz whatever the input rate, and cannot be configured. */
+const OUTPUT_RATE = 24e3;
+const unsupportedFormat = (format, field, expected) => new AiError.Unsupported({
+	provider: PROVIDER,
+	capability: field,
+	reason: `Gemini Live accepts ${expected}. Got ${JSON.stringify(format)}.`
+});
+/** Any rate is accepted on input; 16 kHz is what the model works in. */
+const inputRate = (format) => Match.value(format).pipe(Match.when({
+	container: "raw",
+	encoding: "pcm_s16le",
+	channels: 1
+}, (f) => Effect.succeed(f.sampleRate)), Match.orElse((f) => Effect.fail(unsupportedFormat(f, "inputFormat", "mono pcm_s16le at any rate"))));
+const checkOutputFormat = (format) => Match.value(format).pipe(Match.when({
+	container: "raw",
+	encoding: "pcm_s16le",
+	sampleRate: OUTPUT_RATE,
+	channels: 1
+}, () => Effect.void), Match.orElse((f) => Effect.fail(unsupportedFormat(f, "outputFormat", `mono pcm_s16le at ${OUTPUT_RATE}`))));
+const SENSITIVITY = {
+	high: "HIGH",
+	low: "LOW"
+};
+const TURN_COVERAGE = {
+	activity: "TURN_INCLUDES_ONLY_ACTIVITY",
+	all: "TURN_INCLUDES_ALL_INPUT",
+	audioActivityAndAllVideo: "TURN_INCLUDES_AUDIO_ACTIVITY_AND_ALL_VIDEO"
+};
+const realtimeInputConfig = (request) => ({
+	automaticActivityDetection: {
+		...request.turnDetection === "manual" && { disabled: true },
+		...request.vad?.startSensitivity !== void 0 && { startOfSpeechSensitivity: `START_SENSITIVITY_${SENSITIVITY[request.vad.startSensitivity]}` },
+		...request.vad?.endSensitivity !== void 0 && { endOfSpeechSensitivity: `END_SENSITIVITY_${SENSITIVITY[request.vad.endSensitivity]}` },
+		...request.vad?.prefixPaddingMs !== void 0 && { prefixPaddingMs: request.vad.prefixPaddingMs },
+		...request.vad?.silenceDurationMs !== void 0 && { silenceDurationMs: request.vad.silenceDurationMs }
+	},
+	...request.activityHandling !== void 0 && { activityHandling: request.activityHandling === "none" ? "NO_INTERRUPTION" : "START_OF_ACTIVITY_INTERRUPTS" },
+	...request.turnCoverage !== void 0 && { turnCoverage: TURN_COVERAGE[request.turnCoverage] }
+});
+const generationConfig = (request) => ({
+	responseModalities: ["AUDIO"],
+	...request.voiceId !== void 0 && { speechConfig: {
+		voiceConfig: { prebuiltVoiceConfig: { voiceName: request.voiceId } },
+		...request.languageCode !== void 0 && { languageCode: request.languageCode }
+	} },
+	...request.temperature !== void 0 && { temperature: request.temperature },
+	...request.maxOutputTokens !== void 0 && { maxOutputTokens: request.maxOutputTokens },
+	...request.mediaResolution !== void 0 && { mediaResolution: `MEDIA_RESOLUTION_${request.mediaResolution.toUpperCase()}` },
+	...request.thinkingLevel !== void 0 && { thinkingConfig: { thinkingLevel: request.thinkingLevel.toUpperCase() } },
+	...request.affectiveDialog === true && { enableAffectiveDialog: true }
+});
+const toolsOf = (request) => request.googleSearch === true ? [{ googleSearch: {} }] : toolDescriptorsToTools(request.tools ?? []);
+const setupFrame = (request) => {
+	const tools = toolsOf(request);
+	return JSON.stringify({ setup: {
+		model: `models/${request.model}`,
+		generationConfig: generationConfig(request),
+		...request.instructions !== void 0 && { systemInstruction: { parts: [{ text: request.instructions }] } },
+		...tools.length > 0 && { tools },
+		realtimeInputConfig: realtimeInputConfig(request),
+		...request.transcribeInput !== false && { inputAudioTranscription: {} },
+		outputAudioTranscription: {},
+		sessionResumption: request.resume === void 0 ? {} : { handle: request.resume },
+		...request.contextCompression !== void 0 && { contextWindowCompression: {
+			slidingWindow: { ...request.contextCompression.targetTokens !== void 0 && { targetTokens: request.contextCompression.targetTokens } },
+			...request.contextCompression.triggerTokens !== void 0 && { triggerTokens: request.contextCompression.triggerTokens }
+		} },
+		...request.proactiveAudio === true && { proactivity: { proactiveAudio: true } },
+		...(request.history?.length ?? 0) > 0 && { historyConfig: { initialHistoryInClientContent: true } }
+	} });
+};
+const messageText = (item) => item.type !== "message" ? "" : item.content.map((block) => block.type === "input_text" || block.type === "output_text" ? block.text : "").join("");
+/**
+* Text-only seed, which is all `history` promises across providers. Anything
+* with no text of its own, a tool call or its output, has no place in the seed
+* and is reported once per kind rather than vanishing.
+*/
+const historyFrame = (history) => Effect.gen(function* () {
+	const kinds = new Set(history.filter((i) => messageText(i).length === 0).map((i) => i.type));
+	yield* Effect.forEach(kinds, (kind) => Capabilities.warnDropped({
+		provider: PROVIDER,
+		capability: "history",
+		field: "history",
+		value: kind,
+		reason: `Gemini Live seeds a session with text turns only, so \`${kind}\` items are left out.`
+	}), { discard: true });
+	return JSON.stringify({ clientContent: {
+		turns: history.filter((item) => messageText(item).length > 0).map((item) => ({
+			role: item.type === "message" && item.role === "assistant" ? "model" : "user",
+			parts: [{ text: messageText(item) }]
+		})),
+		turnComplete: true
+	} });
+});
+const Part = Schema.Struct({
+	text: Schema.optional(Schema.String),
+	thought: Schema.optional(Schema.Boolean),
+	inlineData: Schema.optional(Schema.Struct({
+		mimeType: Schema.optional(Schema.String),
+		data: Schema.optional(Schema.String)
+	}))
+});
+const Transcription = Schema.Struct({ text: Schema.optional(Schema.String) });
+const ServerContent = Schema.Struct({
+	modelTurn: Schema.optional(Schema.Struct({ parts: Schema.optional(Schema.Array(Part)) })),
+	turnComplete: Schema.optional(Schema.Boolean),
+	generationComplete: Schema.optional(Schema.Boolean),
+	interrupted: Schema.optional(Schema.Boolean),
+	inputTranscription: Schema.optional(Transcription),
+	interimInputTranscription: Schema.optional(Transcription),
+	outputTranscription: Schema.optional(Transcription)
+});
+const UsageMetadata = Schema.Struct({
+	promptTokenCount: Schema.optional(Schema.Number),
+	responseTokenCount: Schema.optional(Schema.Number),
+	totalTokenCount: Schema.optional(Schema.Number)
+});
+const FunctionCall = Schema.Struct({
+	id: Schema.optional(Schema.String),
+	name: Schema.String,
+	args: Schema.optional(Schema.Unknown)
+});
+const ServerMessage = Schema.Struct({
+	setupComplete: Schema.optional(Schema.Unknown),
+	serverContent: Schema.optional(ServerContent),
+	toolCall: Schema.optional(Schema.Struct({ functionCalls: Schema.optional(Schema.Array(FunctionCall)) })),
+	toolCallCancellation: Schema.optional(Schema.Struct({ ids: Schema.optional(Schema.Array(Schema.String)) })),
+	goAway: Schema.optional(Schema.Struct({ timeLeft: Schema.optional(Schema.String) })),
+	sessionResumptionUpdate: Schema.optional(Schema.Struct({
+		newHandle: Schema.optional(Schema.String),
+		resumable: Schema.optional(Schema.Boolean)
+	})),
+	usageMetadata: Schema.optional(UsageMetadata)
+});
+const initialState = {
+	responseId: void 0,
+	turns: 0,
+	callNames: {},
+	usage: void 0,
+	goingAway: false
+};
+/**
+* The id every event of the current turn carries, minting one and announcing
+* the turn if this is its first event.
+*/
+const startTurn = (state) => Ref.modify(state, (s) => {
+	const responseId = s.responseId ?? `turn_${s.turns + 1}`;
+	return s.responseId !== void 0 ? [[responseId, []], s] : [[responseId, [RealtimeEvent.ResponseStarted({ responseId })]], {
+		...s,
+		responseId,
+		turns: s.turns + 1
+	}];
+});
+const usageOf = (metadata) => ({
+	...metadata.promptTokenCount !== void 0 && { input_tokens: metadata.promptTokenCount },
+	...metadata.responseTokenCount !== void 0 && { output_tokens: metadata.responseTokenCount },
+	...metadata.totalTokenCount !== void 0 && { total_tokens: metadata.totalTokenCount }
+});
+const decodeAudio = (b64) => Result.match(Encoding.decodeBase64(b64), {
+	onSuccess: Effect.succeed,
+	onFailure: (cause) => Effect.fail(new AiError.GenerationFailed({
+		provider: PROVIDER,
+		raw: {
+			message: "audio part base64 decode failed",
+			cause
+		}
+	}))
+});
+/** `timeLeft` is a proto duration, so `"60s"` rather than a number. */
+const parseTimeLeft = (timeLeft) => {
+	if (timeLeft === void 0) return void 0;
+	const seconds = Number.parseFloat(timeLeft.replace(/s$/, ""));
+	return Number.isFinite(seconds) ? Duration.seconds(seconds) : void 0;
+};
+/** Thought parts are the model reasoning, not something to speak or show. */
+const partToEvents = (responseId, part) => Match.value(part).pipe(Match.when({ thought: true }, () => Effect.succeed([])), Match.when({ inlineData: { data: Match.string } }, (p) => Effect.map(decodeAudio(p.inlineData.data), (bytes) => [RealtimeEvent.AudioDelta({
+	responseId,
+	bytes
+})])), Match.when({ text: Match.string }, (p) => Effect.succeed([RealtimeEvent.OutputTranscriptDelta({
+	responseId,
+	text: p.text
+})])), Match.orElse(() => Effect.succeed([])));
+const inputTranscripts = (content) => [...content.interimInputTranscription?.text === void 0 ? [] : [RealtimeEvent.InputTranscript({
+	text: content.interimInputTranscription.text,
+	final: false
+})], ...content.inputTranscription?.text === void 0 ? [] : [RealtimeEvent.InputTranscript({
+	text: content.inputTranscription.text,
+	final: true
+})]];
+/**
+* One `serverContent` to its events. Several fields can arrive together, and
+* 3.1 packs several parts into one message, so this answers with a batch.
+*/
+const contentToEvents = (state, content) => Effect.gen(function* () {
+	const input = inputTranscripts(content);
+	const parts = content.modelTurn?.parts ?? [];
+	const spokenText = content.outputTranscription?.text;
+	const generating = parts.length > 0 || spokenText !== void 0;
+	const ending = content.interrupted === true || content.turnComplete === true;
+	if (!generating && !ending) return input;
+	const [responseId, started] = generating ? yield* startTurn(state) : [(yield* Ref.get(state)).responseId, []];
+	if (responseId === void 0) return input;
+	const spoken = yield* Effect.forEach(parts, (part) => partToEvents(responseId, part));
+	const transcript = spokenText === void 0 ? [] : [RealtimeEvent.OutputTranscriptDelta({
+		responseId,
+		text: spokenText
+	})];
+	const body = [
+		...input,
+		...started,
+		...spoken.flat(),
+		...transcript
+	];
+	if (!ending) return body;
+	const usage = (yield* Ref.get(state)).usage;
+	yield* Ref.update(state, (s) => ({
+		...s,
+		responseId: void 0,
+		usage: void 0
+	}));
+	return [
+		...body,
+		...content.interrupted === true ? [RealtimeEvent.Interrupted({ responseId })] : [],
+		RealtimeEvent.ResponseDone({
+			responseId,
+			reason: content.interrupted === true ? "interrupted" : "complete",
+			...usage !== void 0 && { usage }
+		})
+	];
+});
+const toolCallEvents = (state, calls) => Effect.gen(function* () {
+	const [responseId, started] = yield* startTurn(state);
+	yield* Ref.update(state, (s) => ({
+		...s,
+		callNames: calls.reduce((names, call) => ({
+			...names,
+			[call.id ?? call.name]: call.name
+		}), s.callNames)
+	}));
+	return [...started, ...calls.map((call) => RealtimeEvent.ToolCall({
+		responseId,
+		call: {
+			type: "function_call",
+			call_id: call.id ?? call.name,
+			name: call.name,
+			arguments: JSON.stringify(call.args ?? {}),
+			providerData: void 0
+		}
+	}))];
+});
+const toEvents = (state, frame) => Effect.gen(function* () {
+	if (frame.usageMetadata !== void 0) {
+		const usage = usageOf(frame.usageMetadata);
+		yield* Ref.update(state, (s) => ({
+			...s,
+			usage
+		}));
+	}
+	if (frame.serverContent !== void 0) return yield* contentToEvents(state, frame.serverContent);
+	if (frame.toolCall !== void 0) return yield* toolCallEvents(state, frame.toolCall.functionCalls ?? []);
+	const callIds = frame.toolCallCancellation?.ids ?? [];
+	if (callIds.length > 0) return [RealtimeEvent.ToolCallCancelled({ callIds })];
+	if (frame.goAway !== void 0) {
+		const timeLeft = parseTimeLeft(frame.goAway.timeLeft);
+		yield* Ref.update(state, (s) => ({
+			...s,
+			goingAway: true
+		}));
+		return [RealtimeEvent.SessionEnding({ ...timeLeft !== void 0 && { timeLeft } })];
+	}
+	const handle = frame.sessionResumptionUpdate?.newHandle;
+	return frame.sessionResumptionUpdate?.resumable === true && handle !== void 0 && handle !== "" ? [RealtimeEvent.ResumptionHandle({ handle })] : [];
+});
+const droppedActivity = (field) => Capabilities.warnDropped({
+	provider: PROVIDER,
+	capability: "manualTurns",
+	field,
+	reason: "The session uses automatic activity detection; boundaries are the server's."
+});
+const videoPart = (frame) => Match.value(frame).pipe(Match.tag("base64", (s) => Effect.succeed({
+	data: s.base64,
+	mimeType: s.mimeType
+})), Match.tag("bytes", (s) => Effect.succeed({
+	data: Encoding.encodeBase64(s.bytes),
+	mimeType: s.mimeType
+})), Match.tag("url", () => Effect.fail(new AiError.Unsupported({
+	provider: PROVIDER,
+	capability: "videoInput",
+	reason: "A live video frame must carry its bytes; a URL would need the Files API."
+}))), Match.exhaustive);
+const schedulingOf = (request) => Match.value(request.toolScheduling ?? "when-idle").pipe(Match.when("when-idle", () => "WHEN_IDLE"), Match.when("interrupt", () => "INTERRUPT"), Match.when("silent", () => "SILENT"), Match.exhaustive);
+const handleInput = (send, state, options, input) => Match.value(input).pipe(Match.tag("Audio", (i) => send(JSON.stringify({ realtimeInput: { audio: {
+	data: Encoding.encodeBase64(i.bytes),
+	mimeType: `audio/pcm;rate=${options.rate}`
+} } }))), Match.tag("Text", (i) => i.role === "system" ? Effect.fail(new AiError.Unsupported({
+	provider: PROVIDER,
+	capability: "systemTurn",
+	reason: "Gemini Live fixes the system instruction at setup for the connection."
+})) : send(JSON.stringify({ realtimeInput: { text: i.text } }))), Match.tag("ToolResult", (i) => Effect.gen(function* () {
+	const name = (yield* Ref.get(state)).callNames[i.output.call_id];
+	if (name === void 0) return yield* Effect.fail(new AiError.InvalidRequest({
+		provider: PROVIDER,
+		raw: `no tool call ${i.output.call_id} in this session`
+	}));
+	yield* send(JSON.stringify({ toolResponse: { functionResponses: [{
+		id: i.output.call_id,
+		name,
+		response: parsedResponse(i.output.output),
+		scheduling: options.scheduling
+	}] } }));
+})), Match.tag("Interrupt", () => Effect.fail(new AiError.Unsupported({
+	provider: PROVIDER,
+	capability: "interrupt",
+	reason: "Gemini Live has no cancel op: the server interrupts when it hears speech. Pass activityHandling: \"none\" to turn that off."
+}))), Match.tag("VideoFrame", (i) => Effect.flatMap(videoPart(i.frame), (video) => send(JSON.stringify({ realtimeInput: { video } })))), Match.tag("ActivityStart", () => options.manual ? send(JSON.stringify({ realtimeInput: { activityStart: {} } })) : droppedActivity("ActivityStart")), Match.tag("ActivityEnd", () => options.manual ? send(JSON.stringify({ realtimeInput: { activityEnd: {} } })) : droppedActivity("ActivityEnd")), Match.tag("PlaybackPosition", () => Capabilities.warnDropped({
+	provider: PROVIDER,
+	capability: "truncate",
+	field: "PlaybackPosition",
+	reason: "Gemini Live has no truncate op, so the unheard tail stays in context."
+})), Match.exhaustive);
+const buildWsUrl = (cfg) => {
+	const url = new URL(cfg.baseUrl ?? DEFAULT_BASE_URL);
+	url.protocol = url.protocol === "http:" ? "ws:" : "wss:";
+	url.pathname = `${url.pathname.replace(/\/$/, "")}/${RPC}`;
+	url.searchParams.set("key", Redacted.value(cfg.apiKey));
+	return url.toString();
+};
+const withSocket = (cfg) => (effect) => cfg.webSocket === void 0 ? Effect.provide(effect, Socket.layerWebSocketConstructorGlobal) : Effect.provideService(effect, Socket.WebSocketConstructor, cfg.webSocket);
+/** Drop frames until `setupComplete`; a close before it is a failed handshake. */
+const awaitSetupComplete = (session) => Queue.take(session.frames).pipe(Effect.catchCause((cause) => Pull.isDoneCause(cause) ? Effect.fail(new AiError.Unavailable({
+	provider: PROVIDER,
+	raw: "the socket closed during the handshake"
+})) : Effect.failCause(cause)), Effect.flatMap((frame) => frame.setupComplete === void 0 ? awaitSetupComplete(session) : Effect.void));
+const openSession = (cfg) => (request) => Effect.gen(function* () {
+	if (request.googleSearch === true && (request.tools?.length ?? 0) > 0) return yield* Effect.fail(new AiError.InvalidRequest({
+		provider: PROVIDER,
+		raw: "Gemini rejects googleSearch alongside function declarations; pick one per session."
+	}));
+	const rate = yield* inputRate(request.inputFormat);
+	const scheduling = schedulingOf(request);
+	yield* checkOutputFormat(request.outputFormat);
+	const session = yield* WebSocketSession.open({
+		url: buildWsUrl(cfg),
+		provider: PROVIDER,
+		schema: ServerMessage,
+		openTimeout: Duration.seconds(30)
+	}).pipe(withSocket(cfg));
+	yield* session.send(setupFrame(request));
+	yield* awaitSetupComplete(session);
+	const history = request.history ?? [];
+	if (history.length > 0) {
+		const seed = yield* historyFrame(history);
+		yield* session.send(seed);
+	}
+	const state = yield* Ref.make(initialState);
+	const out = yield* Queue.bounded(128);
+	const pump = Stream.fromQueue(session.frames).pipe(Stream.mapEffect((frame) => toEvents(state, frame)), Stream.runForEach((events) => Queue.offerAll(out, events)));
+	const finish = (cause) => Effect.gen(function* () {
+		const { goingAway, responseId } = yield* Ref.get(state);
+		if (responseId !== void 0) return yield* Queue.fail(out, new AiError.IncompleteTurn({ raw: cause ?? "the socket closed mid turn" }));
+		if (goingAway) return yield* Queue.fail(out, new AiError.SessionExpired({
+			provider: PROVIDER,
+			raw: cause ?? "the socket closed after the server announced it was going away"
+		}));
+		return yield* cause !== void 0 && Cause.hasFails(cause) ? Queue.failCause(out, cause) : Queue.end(out);
+	});
+	yield* pump.pipe(Effect.matchCauseEffect({
+		onFailure: finish,
+		onSuccess: () => finish(void 0)
+	}), Effect.forkScoped);
+	const manual = request.turnDetection === "manual";
+	return {
+		send: (input) => handleInput(session.send, state, {
+			manual,
+			rate,
+			scheduling
+		}, input),
+		events: Stream.fromQueue(out)
+	};
+});
+//#endregion
+export { buildWsUrl, openSession };
+
+//# sourceMappingURL=realtimeSession.mjs.map