@warlock.js/ai-live 4.6.0

package/CHANGELOG.md

@@ -0,0 +1,15 @@
+# Changelog — @warlock.js/ai-live
+
+All notable changes to `@warlock.js/ai-live` are documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/). `@warlock.js/*` packages are released in lockstep — every package shares the same version number, so a version below may list only the changes that affected this package.
+
+## 4.6.0
+
+### Added
+
+- **First release** — the live & generative rich-media add-on for `@warlock.js/ai`, kept in its own package so core text/image/speech stay dependency-light. A side-effect import (`import "@warlock.js/ai-live"`) mounts `ai.video` + `ai.realtime` onto the shared `Ai` facade.
+- **`ai.video(params)`** — text-to-video (Sora / Veo / Kling-class); the provider's async submit→poll job hidden behind the uniform never-throws `{ data, error, usage, report }` envelope, with per-second cost-truth folded into `Usage.cost` and a `type: "video"` report routed to observers.
+- **`ai.realtime(options)`** — a stateful duplex voice session over a pluggable `RealtimeTransport`: `sendAudio` / `sendText` / `events()` out, `close()` → `RealtimeReport` for the cost/observability surfaces.
+- **Contracts** — `VideoModelContract`, `GeneratedVideo`, `VideoModelPricing`, `VideoOptions`; `RealtimeSession`, `RealtimeTransport`, `RealtimeConnection`, `RealtimeEvent`, `RealtimeReport`, `RealtimeOptions`.
+- **Mocks** — `MockVideoModel` + `MockRealtimeTransport` for deterministic, HTTP- and socket-free tests (scripted responses / event streams, recorded calls).

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Hassan Zohdy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,76 @@
+# `@warlock.js/ai-live`
+
+**Live & generative rich-media for `@warlock.js/ai`** — the two heaviest output
+modalities, kept in their own package so the core stays dependency-light.
+
+`@warlock.js/ai` ships the synchronous modality verbs (`ai.agent`, `ai.image`,
+`ai.speech`, `ai.transcribe`). `ai-live` adds the two that need heavyweight,
+demand-gated machinery — a persistent network session and a long-running job —
+mounted onto the same `ai.*` facade by importing the package:
+
+```ts
+import "@warlock.js/ai-live"; // side-effect: lights up ai.realtime + ai.video
+```
+
+## What it gives you
+
+### `ai.realtime(options)` — duplex realtime voice sessions
+A **stateful, bidirectional voice session** (OpenAI Realtime-class): stream
+microphone audio in, stream synthesized audio + transcripts + tool-calls out,
+with barge-in. Unlike every other `ai.*` verb (one-shot request → result), this
+is a **session primitive** — its closest sibling is `ai.orchestrator`. You open
+a session over a pluggable **transport** (a WebSocket to the provider's realtime
+endpoint), push audio, and consume an async event stream until you `close()` it
+(which yields a final report for cost/observability).
+
+```ts
+const session = await ai.realtime({
+  transport: openAiRealtime({ apiKey }),   // provider transport (own adapter)
+  model: "gpt-realtime",
+  voice: "alloy",
+  instructions: "You are a friendly phone receptionist.",
+});
+
+session.sendAudio(micChunk, "audio/pcm");
+for await (const event of session.events()) {
+  if (event.type === "audio") speaker.write(event.base64);
+  if (event.type === "transcript" && event.final) log(event.role, event.text);
+}
+const report = await session.close();
+```
+
+### `ai.video(params)` — text-to-video generation
+Prompt → video (Sora / Veo / Kling-class). Generation is **async** (submit →
+poll), but the adapter hides the polling, so the verb returns the same uniform
+never-throws `{ data, error, usage, report }` envelope as `ai.image`, with
+per-second cost-truth folded into `Usage.cost`.
+
+```ts
+const { data, error, usage } = await ai.video({
+  model: sora.video({ name: "sora-2", pricing: { perSecond: 0.1 } }),
+  prompt: "a timelapse of a city skyline at dusk, cinematic",
+  durationSeconds: 8,
+  aspectRatio: "16:9",
+});
+if (!error) download(data.video); // { type: "url" | "base64", ... }
+```
+
+## Why a separate package
+
+- **Heavy / optional deps.** Realtime needs a WebSocket transport (`ws` is an
+  optional peer); video pulls long-poll + large-payload handling. Most apps
+  using text/image/speech shouldn't carry that weight.
+- **Different shape.** `ai.realtime` is a *session*, not a request; `ai.video`
+  is a *long job*. Isolating them keeps the core verbs simple and synchronous.
+- **Same contracts.** Both still produce a `BaseReport` (`type: "realtime"` /
+  `"video"`) and route through the shared `observe` seam, so panoptic and the
+  cost tree pick them up for free.
+
+## Status
+
+`4.6.0` introduces the package with the **`VideoModelContract` / `RealtimeSession`
+contracts**, the `ai.video()` verb (uniform envelope + cost-truth, tested against
+a mock), and the `ai.realtime()` session primitive over a **pluggable transport**
+(tested against a mock transport). The first concrete provider transports
+(OpenAI Realtime WebSocket; Sora / Veo video adapters) are the next implementation
+step — the seams are defined so they drop in without changing the verb surface.

package/cjs/index.cjs

@@ -0,0 +1,257 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+let _warlock_js_ai = require("@warlock.js/ai");
+
+//#region ../@warlock.js/ai-live/src/realtime/realtime.ts
+/**
+* Open a live duplex voice session — the stateful primitive of
+* `@warlock.js/ai-live`. Connects through the provided
+* {@link RealtimeOptions.transport} (an OpenAI Realtime WebSocket
+* adapter, a mock in tests), then hands back a {@link RealtimeSession}
+* you drive: push audio/text in, consume the event stream out, and
+* `close()` to end it and receive a `type: "realtime"` report for the
+* cost/observability surfaces.
+*
+* Unlike the one-shot `ai.*` verbs, this returns a long-lived session —
+* its closest sibling is `ai.orchestrator`. Keeping the transport
+* pluggable is what lets the session surface ship without hard-wiring a
+* WebSocket dependency.
+*
+* @example
+* const session = await ai.realtime({ transport, model: "gpt-realtime", voice: "alloy" });
+* session.sendAudio(micChunk, "audio/pcm");
+* for await (const event of session.events()) {
+*   if (event.type === "audio") speaker.write(event.base64);
+* }
+* const report = await session.close();
+*/
+async function realtime(options) {
+	const runId = (0, _warlock_js_ai.generateRunId)("realtime");
+	const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+	const startPerf = performance.now();
+	const connection = await options.transport.connect({
+		model: options.model,
+		voice: options.voice,
+		instructions: options.instructions
+	});
+	let report;
+	return {
+		sendAudio: (base64, mediaType) => connection.sendAudio(base64, mediaType),
+		sendText: (text) => connection.sendText(text),
+		events: () => connection.events(),
+		async close() {
+			if (report) return report;
+			await connection.close();
+			report = {
+				runId,
+				rootRunId: runId,
+				type: "realtime",
+				name: options.name ?? "realtime",
+				status: "completed",
+				startedAt,
+				endedAt: (/* @__PURE__ */ new Date()).toISOString(),
+				duration: performance.now() - startPerf,
+				...options.sessionId ? { sessionId: options.sessionId } : {}
+			};
+			return report;
+		}
+	};
+}
+
+//#endregion
+//#region ../@warlock.js/ai-live/src/video/video.ts
+/**
+* Generate a video from a text prompt — the moving-image verb of the
+* output-modality track. The adapter hides the provider's submit→poll
+* job, so this returns the framework's uniform never-throws envelope:
+*
+* - **Never throws.** Provider failures surface as a typed `AIError`.
+* - **Cost-truth.** `usage.cost` is filled per-second (Sora / Veo) or
+*   per-token, folding into the same `Usage.cost` rollup as everything else.
+* - **Observable.** The completed {@link VideoReport} routes to any
+*   registered `Observer` via the shared `observe` seam.
+*
+* @example
+* const { data, error } = await ai.video({
+*   model: sora.video({ name: "sora-2", pricing: { perSecond: 0.1 } }),
+*   prompt: "a timelapse of a city skyline at dusk, cinematic",
+*   durationSeconds: 8,
+* });
+* if (!error) download(data.video);
+*/
+async function video(params) {
+	const { model, prompt } = params;
+	const runId = (0, _warlock_js_ai.generateRunId)("video");
+	const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+	const startPerf = performance.now();
+	const usage = {
+		input: 0,
+		output: 0,
+		total: 0
+	};
+	let data;
+	let error;
+	let status = "completed";
+	let durationSeconds;
+	try {
+		const response = await model.generate(prompt, {
+			durationSeconds: params.durationSeconds,
+			aspectRatio: params.aspectRatio,
+			resolution: params.resolution,
+			negativePrompt: params.negativePrompt,
+			signal: params.signal,
+			...params.options
+		});
+		Object.assign(usage, response.usage);
+		durationSeconds = response.durationSeconds;
+		if (usage.cost === void 0) {
+			const cost = computeVideoCost(usage, durationSeconds, model.pricing);
+			if (cost !== void 0) usage.cost = cost;
+		}
+		data = { video: response.video };
+	} catch (thrown) {
+		error = thrown instanceof _warlock_js_ai.AIError ? thrown : new _warlock_js_ai.ProviderError(toMessage(thrown), { cause: thrown });
+		status = params.signal?.aborted ? "cancelled" : "failed";
+	}
+	const report = {
+		runId,
+		rootRunId: runId,
+		name: params.name ?? "video",
+		type: "video",
+		status,
+		error,
+		startedAt,
+		endedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		duration: performance.now() - startPerf,
+		usage,
+		children: [],
+		model: {
+			name: model.name,
+			provider: model.provider
+		},
+		...durationSeconds !== void 0 ? { durationSeconds } : {},
+		reportSchemaVersion: _warlock_js_ai.REPORT_SCHEMA_VERSION
+	};
+	(0, _warlock_js_ai.stampReportLineage)(report, {
+		rootRunId: runId,
+		sessionId: params.sessionId
+	});
+	for (const observer of (0, _warlock_js_ai.resolveObservers)(params.observe)) try {
+		await observer.collect(report);
+	} catch {}
+	return {
+		type: "video",
+		data,
+		error,
+		usage,
+		report
+	};
+}
+/**
+* Price a video run: `perSecond × durationSeconds` (per-second metering,
+* attributed to `cost.output`) wins when configured, otherwise the
+* standard token math. Returns `undefined` when no usable pricing is
+* present.
+*/
+function computeVideoCost(usage, durationSeconds, pricing) {
+	if (!pricing) return;
+	if (pricing.perSecond !== void 0) {
+		if (durationSeconds === void 0) return;
+		return {
+			input: 0,
+			output: durationSeconds * pricing.perSecond
+		};
+	}
+	if (pricing.input !== void 0 && pricing.output !== void 0) return (0, _warlock_js_ai.computeCost)(usage, {
+		input: pricing.input,
+		output: pricing.output
+	});
+}
+/** Best-effort message for a non-`AIError` thrown value. */
+function toMessage(thrown) {
+	return thrown instanceof Error ? thrown.message : String(thrown);
+}
+
+//#endregion
+//#region ../@warlock.js/ai-live/src/mock/index.ts
+/** Deterministic {@link VideoModelContract} double for tests — no HTTP, no polling. */
+var MockVideoModel = class {
+	constructor(name, responses, pricing) {
+		this.name = name;
+		this.responses = responses;
+		this.pricing = pricing;
+		this.provider = "mock";
+		this.calls = [];
+		this.callIndex = 0;
+	}
+	async generate(prompt, options) {
+		this.calls.push({
+			prompt,
+			options
+		});
+		const response = this.responses[Math.min(this.callIndex, this.responses.length - 1)] ?? {};
+		this.callIndex += 1;
+		if (response.error) throw response.error;
+		return {
+			video: response.video ?? {
+				type: "url",
+				url: "https://mock/video.mp4",
+				mediaType: "video/mp4"
+			},
+			usage: response.usage ?? {
+				input: 0,
+				output: 0,
+				total: 0
+			},
+			durationSeconds: response.durationSeconds ?? options?.durationSeconds ?? 5
+		};
+	}
+};
+/** A recording {@link RealtimeConnection} the mock transport hands back. */
+var MockRealtimeConnection = class {
+	constructor(scripted) {
+		this.scripted = scripted;
+		this.sentAudio = [];
+		this.sentText = [];
+		this.closed = false;
+	}
+	sendAudio(base64, mediaType) {
+		this.sentAudio.push({
+			base64,
+			mediaType
+		});
+	}
+	sendText(text) {
+		this.sentText.push(text);
+	}
+	async *events() {
+		for (const event of this.scripted) yield event;
+	}
+	async close() {
+		this.closed = true;
+	}
+};
+/** Deterministic {@link RealtimeTransport} double — scripts the event stream, records sends. */
+var MockRealtimeTransport = class {
+	constructor(scriptedEvents = []) {
+		this.scriptedEvents = scriptedEvents;
+		this.connectConfigs = [];
+	}
+	async connect(config) {
+		this.connectConfigs.push(config);
+		this.lastConnection = new MockRealtimeConnection(this.scriptedEvents);
+		return this.lastConnection;
+	}
+};
+
+//#endregion
+//#region ../@warlock.js/ai-live/src/index.ts
+_warlock_js_ai.ai.video = video;
+_warlock_js_ai.ai.realtime = realtime;
+
+//#endregion
+exports.MockRealtimeConnection = MockRealtimeConnection;
+exports.MockRealtimeTransport = MockRealtimeTransport;
+exports.MockVideoModel = MockVideoModel;
+exports.realtime = realtime;
+exports.video = video;
+//# sourceMappingURL=index.cjs.map

package/cjs/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":["AIError","ProviderError","REPORT_SCHEMA_VERSION"],"sources":["../../../../../../@warlock.js/ai-live/src/realtime/realtime.ts","../../../../../../@warlock.js/ai-live/src/video/video.ts","../../../../../../@warlock.js/ai-live/src/mock/index.ts","../../../../../../@warlock.js/ai-live/src/index.ts"],"sourcesContent":["import { generateRunId } from \"@warlock.js/ai\";\nimport type {\n  RealtimeOptions,\n  RealtimeReport,\n  RealtimeSession,\n} from \"../contracts/realtime.contract\";\n\n/**\n * Open a live duplex voice session — the stateful primitive of\n * `@warlock.js/ai-live`. Connects through the provided\n * {@link RealtimeOptions.transport} (an OpenAI Realtime WebSocket\n * adapter, a mock in tests), then hands back a {@link RealtimeSession}\n * you drive: push audio/text in, consume the event stream out, and\n * `close()` to end it and receive a `type: \"realtime\"` report for the\n * cost/observability surfaces.\n *\n * Unlike the one-shot `ai.*` verbs, this returns a long-lived session —\n * its closest sibling is `ai.orchestrator`. Keeping the transport\n * pluggable is what lets the session surface ship without hard-wiring a\n * WebSocket dependency.\n *\n * @example\n * const session = await ai.realtime({ transport, model: \"gpt-realtime\", voice: \"alloy\" });\n * session.sendAudio(micChunk, \"audio/pcm\");\n * for await (const event of session.events()) {\n *   if (event.type === \"audio\") speaker.write(event.base64);\n * }\n * const report = await session.close();\n */\nexport async function realtime(options: RealtimeOptions): Promise<RealtimeSession> {\n  const runId = generateRunId(\"realtime\");\n  const startedAt = new Date().toISOString();\n  const startPerf = performance.now();\n\n  const connection = await options.transport.connect({\n    model: options.model,\n    voice: options.voice,\n    instructions: options.instructions,\n  });\n\n  let report: RealtimeReport | undefined;\n\n  return {\n    sendAudio: (base64, mediaType) => connection.sendAudio(base64, mediaType),\n    sendText: (text) => connection.sendText(text),\n    events: () => connection.events(),\n    async close(): Promise<RealtimeReport> {\n      // Idempotent — closing twice returns the first report, never\n      // re-tears-down the connection.\n      if (report) {\n        return report;\n      }\n\n      await connection.close();\n\n      report = {\n        runId,\n        rootRunId: runId,\n        type: \"realtime\",\n        name: options.name ?? \"realtime\",\n        status: \"completed\",\n        startedAt,\n        endedAt: new Date().toISOString(),\n        duration: performance.now() - startPerf,\n        ...(options.sessionId ? { sessionId: options.sessionId } : {}),\n      };\n\n      return report;\n    },\n  };\n}\n","import {\n  AIError,\n  computeCost,\n  generateRunId,\n  ProviderError,\n  REPORT_SCHEMA_VERSION,\n  resolveObservers,\n  stampReportLineage,\n  type BaseReport,\n  type ExecuteResult,\n  type FlowObserveOption,\n  type ModelPricing,\n  type Usage,\n} from \"@warlock.js/ai\";\nimport type {\n  GeneratedVideo,\n  VideoModelContract,\n  VideoModelPricing,\n} from \"../contracts/video.contract\";\n\n/** Parameters for {@link video}. `model` comes from an adapter's `video({ name })`. */\nexport type VideoParams = {\n  model: VideoModelContract;\n  prompt: string;\n  durationSeconds?: number;\n  aspectRatio?: string;\n  resolution?: string;\n  negativePrompt?: string;\n  signal?: AbortSignal;\n  observe?: FlowObserveOption;\n  sessionId?: string;\n  name?: string;\n  options?: Record<string, unknown>;\n};\n\n/** Success payload of a {@link video} run. */\nexport type VideoData = { video: GeneratedVideo };\n\n/** The report node a {@link video} run produces (`type: \"video\"`). */\nexport type VideoReport = BaseReport & {\n  type: \"video\";\n  model: { name: string; provider: string };\n  /** Final clip duration in seconds, when reported. */\n  durationSeconds?: number;\n};\n\n/** Result envelope of {@link video} — the uniform `{ data, error, usage, report }`. */\nexport type VideoResult = ExecuteResult<VideoData> & { type: \"video\"; report: VideoReport };\n\n/**\n * Generate a video from a text prompt — the moving-image verb of the\n * output-modality track. The adapter hides the provider's submit→poll\n * job, so this returns the framework's uniform never-throws envelope:\n *\n * - **Never throws.** Provider failures surface as a typed `AIError`.\n * - **Cost-truth.** `usage.cost` is filled per-second (Sora / Veo) or\n *   per-token, folding into the same `Usage.cost` rollup as everything else.\n * - **Observable.** The completed {@link VideoReport} routes to any\n *   registered `Observer` via the shared `observe` seam.\n *\n * @example\n * const { data, error } = await ai.video({\n *   model: sora.video({ name: \"sora-2\", pricing: { perSecond: 0.1 } }),\n *   prompt: \"a timelapse of a city skyline at dusk, cinematic\",\n *   durationSeconds: 8,\n * });\n * if (!error) download(data.video);\n */\nexport async function video(params: VideoParams): Promise<VideoResult> {\n  const { model, prompt } = params;\n\n  const runId = generateRunId(\"video\");\n  const startedAt = new Date().toISOString();\n  const startPerf = performance.now();\n\n  const usage: Usage = { input: 0, output: 0, total: 0 };\n  let data: VideoData | undefined;\n  let error: AIError | undefined;\n  let status: VideoReport[\"status\"] = \"completed\";\n  let durationSeconds: number | undefined;\n\n  try {\n    const response = await model.generate(prompt, {\n      durationSeconds: params.durationSeconds,\n      aspectRatio: params.aspectRatio,\n      resolution: params.resolution,\n      negativePrompt: params.negativePrompt,\n      signal: params.signal,\n      ...params.options,\n    });\n\n    Object.assign(usage, response.usage);\n    durationSeconds = response.durationSeconds;\n\n    if (usage.cost === undefined) {\n      const cost = computeVideoCost(usage, durationSeconds, model.pricing);\n      if (cost !== undefined) {\n        usage.cost = cost;\n      }\n    }\n\n    data = { video: response.video };\n  } catch (thrown) {\n    error =\n      thrown instanceof AIError ? thrown : new ProviderError(toMessage(thrown), { cause: thrown });\n    status = params.signal?.aborted ? \"cancelled\" : \"failed\";\n  }\n\n  const report: VideoReport = {\n    runId,\n    rootRunId: runId,\n    name: params.name ?? \"video\",\n    type: \"video\",\n    status,\n    error,\n    startedAt,\n    endedAt: new Date().toISOString(),\n    duration: performance.now() - startPerf,\n    usage,\n    children: [],\n    model: { name: model.name, provider: model.provider },\n    ...(durationSeconds !== undefined ? { durationSeconds } : {}),\n    reportSchemaVersion: REPORT_SCHEMA_VERSION,\n  };\n\n  stampReportLineage(report, { rootRunId: runId, sessionId: params.sessionId });\n\n  for (const observer of resolveObservers(params.observe)) {\n    try {\n      await observer.collect(report);\n    } catch {\n      // Isolate observer failures — never break the run.\n    }\n  }\n\n  return { type: \"video\", data, error, usage, report };\n}\n\n/**\n * Price a video run: `perSecond × durationSeconds` (per-second metering,\n * attributed to `cost.output`) wins when configured, otherwise the\n * standard token math. Returns `undefined` when no usable pricing is\n * present.\n */\nfunction computeVideoCost(\n  usage: Usage,\n  durationSeconds: number | undefined,\n  pricing: VideoModelPricing | undefined,\n): ModelPricing | undefined {\n  if (!pricing) {\n    return undefined;\n  }\n\n  if (pricing.perSecond !== undefined) {\n    if (durationSeconds === undefined) {\n      return undefined;\n    }\n    return { input: 0, output: durationSeconds * pricing.perSecond };\n  }\n\n  if (pricing.input !== undefined && pricing.output !== undefined) {\n    return computeCost(usage, { input: pricing.input, output: pricing.output });\n  }\n\n  return undefined;\n}\n\n/** Best-effort message for a non-`AIError` thrown value. */\nfunction toMessage(thrown: unknown): string {\n  return thrown instanceof Error ? thrown.message : String(thrown);\n}\n","import type { Usage } from \"@warlock.js/ai\";\nimport type {\n  RealtimeConnectConfig,\n  RealtimeConnection,\n  RealtimeEvent,\n  RealtimeTransport,\n} from \"../contracts/realtime.contract\";\nimport type {\n  GeneratedVideo,\n  VideoGenerationResponse,\n  VideoModelContract,\n  VideoModelPricing,\n  VideoOptions,\n} from \"../contracts/video.contract\";\n\n/** One scripted response for a {@link MockVideoModel}. */\nexport type MockVideoResponse = {\n  video?: GeneratedVideo;\n  usage?: Usage;\n  durationSeconds?: number;\n  error?: Error;\n};\n\n/** Deterministic {@link VideoModelContract} double for tests — no HTTP, no polling. */\nexport class MockVideoModel implements VideoModelContract {\n  public readonly provider = \"mock\";\n  public readonly calls: { prompt: string; options: VideoOptions | undefined }[] = [];\n\n  private callIndex = 0;\n\n  public constructor(\n    public readonly name: string,\n    private readonly responses: MockVideoResponse[],\n    public readonly pricing?: VideoModelPricing,\n  ) {}\n\n  public async generate(\n    prompt: string,\n    options?: VideoOptions,\n  ): Promise<VideoGenerationResponse> {\n    this.calls.push({ prompt, options });\n\n    const response = this.responses[Math.min(this.callIndex, this.responses.length - 1)] ?? {};\n    this.callIndex += 1;\n\n    if (response.error) {\n      throw response.error;\n    }\n\n    return {\n      video: response.video ?? { type: \"url\", url: \"https://mock/video.mp4\", mediaType: \"video/mp4\" },\n      usage: response.usage ?? { input: 0, output: 0, total: 0 },\n      durationSeconds: response.durationSeconds ?? options?.durationSeconds ?? 5,\n    };\n  }\n}\n\n/** A recording {@link RealtimeConnection} the mock transport hands back. */\nexport class MockRealtimeConnection implements RealtimeConnection {\n  public readonly sentAudio: { base64: string; mediaType: string }[] = [];\n  public readonly sentText: string[] = [];\n  public closed = false;\n\n  public constructor(private readonly scripted: RealtimeEvent[]) {}\n\n  public sendAudio(base64: string, mediaType: string): void {\n    this.sentAudio.push({ base64, mediaType });\n  }\n\n  public sendText(text: string): void {\n    this.sentText.push(text);\n  }\n\n  public async *events(): AsyncIterable<RealtimeEvent> {\n    for (const event of this.scripted) {\n      yield event;\n    }\n  }\n\n  public async close(): Promise<void> {\n    this.closed = true;\n  }\n}\n\n/** Deterministic {@link RealtimeTransport} double — scripts the event stream, records sends. */\nexport class MockRealtimeTransport implements RealtimeTransport {\n  public readonly connectConfigs: RealtimeConnectConfig[] = [];\n  public lastConnection?: MockRealtimeConnection;\n\n  public constructor(private readonly scriptedEvents: RealtimeEvent[] = []) {}\n\n  public async connect(config: RealtimeConnectConfig): Promise<RealtimeConnection> {\n    this.connectConfigs.push(config);\n    this.lastConnection = new MockRealtimeConnection(this.scriptedEvents);\n    return this.lastConnection;\n  }\n}\n","import { ai } from \"@warlock.js/ai\";\nimport { realtime } from \"./realtime/realtime\";\nimport { video } from \"./video/video\";\n\n/**\n * Augment the shared `Ai` facade with this package's two heavy\n * modalities. Importing `@warlock.js/ai-live` mounts `ai.video` +\n * `ai.realtime` as a side effect, mirroring how `@warlock.js/ai-tools`\n * mounts `ai.mcp` / `ai.tools` and `@warlock.js/ai-workspace` mounts\n * `ai.workspace`.\n */\ndeclare module \"@warlock.js/ai\" {\n  interface Ai {\n    /**\n     * Text-to-video generation (Sora / Veo / Kling-class). Async under\n     * the hood (submit→poll), surfaced as the uniform never-throws\n     * `{ data, error, usage, report }` envelope. Ships in `@warlock.js/ai-live`.\n     */\n    video: typeof video;\n    /**\n     * Live duplex voice sessions (OpenAI Realtime-class). A stateful\n     * session over a pluggable transport — push audio/text in, consume\n     * events out, `close()` for a report. Ships in `@warlock.js/ai-live`.\n     */\n    realtime: typeof realtime;\n  }\n}\n\nai.video = video;\nai.realtime = realtime;\n\nexport { realtime, video };\nexport type { VideoData, VideoParams, VideoReport, VideoResult } from \"./video/video\";\nexport * from \"./contracts/video.contract\";\nexport * from \"./contracts/realtime.contract\";\nexport * from \"./mock\";\n"],"mappings":"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"}

package/esm/contracts/realtime.contract.d.mts

@@ -0,0 +1,104 @@
+import { AIError } from "@warlock.js/ai";
+
+//#region ../@warlock.js/ai-live/src/contracts/realtime.contract.d.ts
+/**
+ * One event streamed out of a realtime voice session. A closed union so
+ * consumers can `switch` exhaustively over the duplex output.
+ *
+ * - `audio` — a chunk of synthesized assistant audio (base64).
+ * - `transcript` — an incremental or final transcript line for either side.
+ * - `tool-call` — the model requested a tool (wire it like an agent tool).
+ * - `error` — a typed, non-fatal provider/transport error.
+ * - `done` — the session ended (server-side).
+ */
+type RealtimeEvent = {
+  type: "audio";
+  base64: string;
+  mediaType: string;
+} | {
+  type: "transcript";
+  role: "user" | "assistant";
+  text: string;
+  final: boolean;
+} | {
+  type: "tool-call";
+  id: string;
+  name: string;
+  input: unknown;
+} | {
+  type: "error";
+  error: AIError;
+} | {
+  type: "done";
+};
+/** Config a {@link RealtimeTransport} needs to open a connection. */
+type RealtimeConnectConfig = {
+  /** Realtime model id (e.g. `"gpt-realtime"`). */model: string; /** Default voice. */
+  voice?: string; /** System instructions for the session. */
+  instructions?: string;
+};
+/**
+ * A live, bidirectional connection to a provider's realtime endpoint —
+ * the low-level transport the {@link RealtimeSession} wraps. The first
+ * concrete transport is an OpenAI Realtime WebSocket (own adapter); a
+ * mock transport drives the tests. Keeping this pluggable is what lets
+ * `ai-live` ship the session surface without hard-wiring `ws`.
+ */
+interface RealtimeConnection {
+  /** Push a chunk of microphone audio (base64) upstream. */
+  sendAudio(base64: string, mediaType: string): void;
+  /** Push a text message upstream (the model can reply with audio). */
+  sendText(text: string): void;
+  /** The duplex event stream coming back from the provider. */
+  events(): AsyncIterable<RealtimeEvent>;
+  /** Tear down the connection. */
+  close(): Promise<void>;
+}
+/** Opens a {@link RealtimeConnection}. Implemented per provider. */
+interface RealtimeTransport {
+  connect(config: RealtimeConnectConfig): Promise<RealtimeConnection>;
+}
+/** Options for {@link ai.realtime}. */
+type RealtimeOptions = {
+  /** The provider transport (e.g. an OpenAI Realtime WebSocket adapter). */transport: RealtimeTransport; /** Realtime model id. */
+  model: string; /** Default voice. */
+  voice?: string; /** System instructions for the session. */
+  instructions?: string; /** Groups this session into a wider request for cost/trace queries. */
+  sessionId?: string; /** Report node name (defaults to `"realtime"`). */
+  name?: string;
+};
+/**
+ * A live duplex voice session — the stateful primitive `ai.realtime()`
+ * returns. Push audio/text in, consume {@link RealtimeEvent}s out, and
+ * `close()` to end the session and get a report for cost + observability.
+ * Its closest sibling is `ai.orchestrator` (a session, not a one-shot).
+ */
+interface RealtimeSession {
+  /** Push microphone audio (base64) into the session. */
+  sendAudio(base64: string, mediaType: string): void;
+  /** Push a text turn into the session. */
+  sendText(text: string): void;
+  /** The duplex event stream (audio / transcript / tool-call / …). */
+  events(): AsyncIterable<RealtimeEvent>;
+  /** End the session; resolves with the session's report. */
+  close(): Promise<RealtimeReport>;
+}
+/**
+ * The report a closed {@link RealtimeSession} produces — a flat
+ * `type: "realtime"` node for the trace/cost surfaces. (Realtime usage
+ * accounting is provider-dependent and refined as transports land.)
+ */
+type RealtimeReport = {
+  runId: string;
+  rootRunId: string;
+  type: "realtime";
+  name: string;
+  status: "completed" | "failed" | "cancelled";
+  startedAt: string;
+  endedAt: string;
+  duration: number;
+  sessionId?: string;
+};
+//#endregion
+export { RealtimeConnectConfig, RealtimeConnection, RealtimeEvent, RealtimeOptions, RealtimeReport, RealtimeSession, RealtimeTransport };
+//# sourceMappingURL=realtime.contract.d.mts.map

package/esm/contracts/realtime.contract.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"realtime.contract.d.mts","names":[],"sources":["../../../../../../../@warlock.js/ai-live/src/contracts/realtime.contract.ts"],"mappings":";;;;;AAYA;;;;;;;;KAAY,aAAA;EACN,IAAA;EAAe,MAAA;EAAgB,SAAA;AAAA;EAC/B,IAAA;EAAoB,IAAA;EAA4B,IAAA;EAAc,KAAA;AAAA;EAC9D,IAAA;EAAmB,EAAA;EAAY,IAAA;EAAc,KAAA;AAAA;EAC7C,IAAA;EAAe,KAAA,EAAO,OAAO;AAAA;EAC7B,IAAA;AAAA;;KAGM,qBAAA;EAgBK,iDAdf,KAAA;EAEA,KAAA,WAkBU;EAhBV,YAAA;AAAA;;;;;;;;UAUe,kBAAA;EAMS;EAJxB,SAAA,CAAU,MAAA,UAAgB,SAAA;EAMjB;EAJT,QAAA,CAAS,IAAA;EAIO;EAFhB,MAAA,IAAU,aAAA,CAAc,aAAA;EAMQ;EAJhC,KAAA,IAAS,OAAA;AAAA;;UAIM,iBAAA;EACf,OAAA,CAAQ,MAAA,EAAQ,qBAAA,GAAwB,OAAA,CAAQ,kBAAA;AAAA;;KAItC,eAAA;EAJF,0EAMR,SAAA,EAAW,iBAAiB,EANoB;EAQhD,KAAA,UARkE;EAUlE,KAAA,WANyB;EAQzB,YAAA,WAN4B;EAQ5B,SAAA,WARW;EAUX,IAAA;AAAA;;;;;AAAI;AASN;UAAiB,eAAA;;EAEf,SAAA,CAAU,MAAA,UAAgB,SAAA;EAIhB;EAFV,QAAA,CAAS,IAAA;EAIA;EAFT,MAAA,IAAU,aAAA,CAAc,aAAA;EAER;EAAhB,KAAA,IAAS,OAAA,CAAQ,cAAA;AAAA;;;;;;KAQP,cAAA;EACV,KAAA;EACA,SAAA;EACA,IAAA;EACA,IAAA;EACA,MAAA;EACA,SAAA;EACA,OAAA;EACA,QAAA;EACA,SAAA;AAAA"}

package/esm/contracts/video.contract.d.mts

@@ -0,0 +1,72 @@
+import { Usage } from "@warlock.js/ai";
+
+//#region ../@warlock.js/ai-live/src/contracts/video.contract.d.ts
+/**
+ * USD pricing for a text-to-video model. Video providers meter per
+ * second of generated video (Sora / Veo / Kling); a token channel is
+ * kept for the rare token-metered model. Per-second wins when both are
+ * set. Folds into the same `Usage.cost` rollup as every other modality.
+ *
+ * @example
+ * const pricing: VideoModelPricing = { perSecond: 0.1 };
+ */
+type VideoModelPricing = {
+  /** USD per second of generated video — per-second-metered models. */perSecond?: number; /** USD per 1M input tokens — token-metered models. */
+  input?: number; /** USD per 1M output tokens — token-metered models. */
+  output?: number;
+};
+/**
+ * One generated video, normalized to a discriminated shape (mirrors
+ * `GeneratedImage`). Providers return either a hosted URL (typically the
+ * common case for video, which is large) or inlined base64 bytes.
+ */
+type GeneratedVideo = {
+  type: "url";
+  url: string;
+  mediaType?: string;
+} | {
+  type: "base64";
+  base64: string;
+  mediaType: string;
+};
+/** Options for a single {@link VideoModelContract.generate} request. */
+type VideoOptions = {
+  /** Requested clip length in seconds. */durationSeconds?: number; /** Aspect ratio (e.g. `"16:9"`, `"9:16"`). */
+  aspectRatio?: string; /** Resolution hint (e.g. `"720p"`, `"1080p"`). */
+  resolution?: string; /** Concepts to steer away from. */
+  negativePrompt?: string; /** Cancellation handle. */
+  signal?: AbortSignal; /** Provider-specific escape hatch — forwarded verbatim. */
+  [key: string]: unknown;
+};
+/**
+ * Raw result of a {@link VideoModelContract.generate} call. The adapter
+ * hides the submit→poll lifecycle and resolves only when the video is
+ * ready (or throws a typed `AIError`). The never-throws envelope is
+ * added by `ai.video()`.
+ */
+type VideoGenerationResponse = {
+  video: GeneratedVideo; /** Token usage when the provider reports it; otherwise all-zero. */
+  usage: Usage; /** Final clip duration in seconds — drives per-second cost. */
+  durationSeconds?: number;
+};
+/**
+ * Provider-neutral contract for a text-to-video model — the moving-image
+ * sibling of `ImageModelContract`. Produced by an adapter's `video()`
+ * factory and consumed by `ai.video()`. `generate()` encapsulates the
+ * provider's async job (submit → poll → fetch result).
+ */
+interface VideoModelContract {
+  readonly name: string;
+  readonly provider: string;
+  readonly pricing?: VideoModelPricing;
+  generate(prompt: string, options?: VideoOptions): Promise<VideoGenerationResponse>;
+}
+/** Configuration passed to an adapter's `video()` factory. */
+type VideoModelConfig = {
+  name: string;
+  pricing?: VideoModelPricing;
+  [key: string]: unknown;
+};
+//#endregion
+export { GeneratedVideo, VideoGenerationResponse, VideoModelConfig, VideoModelContract, VideoModelPricing, VideoOptions };
+//# sourceMappingURL=video.contract.d.mts.map

package/esm/contracts/video.contract.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"video.contract.d.mts","names":[],"sources":["../../../../../../../@warlock.js/ai-live/src/contracts/video.contract.ts"],"mappings":";;;;;AAWA;;;;;;;KAAY,iBAAA;EAMJ,qEAJN,SAAA,WAYwB;EAVxB,KAAA,WAUwB;EARxB,MAAA;AAAA;;;;;;KAQU,cAAA;EACN,IAAA;EAAa,GAAA;EAAa,SAAA;AAAA;EAC1B,IAAA;EAAgB,MAAA;EAAgB,SAAA;AAAA;;KAG1B,YAAA;EAYT,wCAVD,eAAA,WAUY;EARZ,WAAA,WAiBiC;EAfjC,UAAA,WAkBY;EAhBZ,cAAA,WAcO;EAZP,MAAA,GAAS,WAAW,EAcb;EAAA,CAZN,GAAA;AAAA;AAcc;AASjB;;;;;AATiB,KALL,uBAAA;EACV,KAAA,EAAO,cAAA,EAiBkD;EAfzD,KAAA,EAAO,KAAK,EAYH;EAVT,eAAA;AAAA;;;;;;;UASe,kBAAA;EAAA,SACN,IAAA;EAAA,SACA,QAAA;EAAA,SACA,OAAA,GAAU,iBAAA;EACnB,QAAA,CAAS,MAAA,UAAgB,OAAA,GAAU,YAAA,GAAe,OAAA,CAAQ,uBAAA;AAAA;;KAIhD,gBAAA;EACV,IAAA;EACA,OAAA,GAAU,iBAAiB;EAAA,CAC1B,GAAA;AAAA"}

package/esm/index.d.mts

@@ -0,0 +1,33 @@
+import { RealtimeConnectConfig, RealtimeConnection, RealtimeEvent, RealtimeOptions, RealtimeReport, RealtimeSession, RealtimeTransport } from "./contracts/realtime.contract.mjs";
+import { realtime } from "./realtime/realtime.mjs";
+import { GeneratedVideo, VideoGenerationResponse, VideoModelConfig, VideoModelContract, VideoModelPricing, VideoOptions } from "./contracts/video.contract.mjs";
+import { VideoData, VideoParams, VideoReport, VideoResult, video } from "./video/video.mjs";
+import { MockRealtimeConnection, MockRealtimeTransport, MockVideoModel, MockVideoResponse } from "./mock/index.mjs";
+
+//#region ../@warlock.js/ai-live/src/index.d.ts
+/**
+ * Augment the shared `Ai` facade with this package's two heavy
+ * modalities. Importing `@warlock.js/ai-live` mounts `ai.video` +
+ * `ai.realtime` as a side effect, mirroring how `@warlock.js/ai-tools`
+ * mounts `ai.mcp` / `ai.tools` and `@warlock.js/ai-workspace` mounts
+ * `ai.workspace`.
+ */
+declare module "@warlock.js/ai" {
+  interface Ai {
+    /**
+     * Text-to-video generation (Sora / Veo / Kling-class). Async under
+     * the hood (submit→poll), surfaced as the uniform never-throws
+     * `{ data, error, usage, report }` envelope. Ships in `@warlock.js/ai-live`.
+     */
+    video: typeof video;
+    /**
+     * Live duplex voice sessions (OpenAI Realtime-class). A stateful
+     * session over a pluggable transport — push audio/text in, consume
+     * events out, `close()` for a report. Ships in `@warlock.js/ai-live`.
+     */
+    realtime: typeof realtime;
+  }
+}
+//#endregion
+export { GeneratedVideo, MockRealtimeConnection, MockRealtimeTransport, MockVideoModel, MockVideoResponse, RealtimeConnectConfig, RealtimeConnection, RealtimeEvent, RealtimeOptions, RealtimeReport, RealtimeSession, RealtimeTransport, type VideoData, VideoGenerationResponse, VideoModelConfig, VideoModelContract, VideoModelPricing, VideoOptions, type VideoParams, type VideoReport, type VideoResult, realtime, video };
+//# sourceMappingURL=index.d.mts.map

package/esm/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../../../../../@warlock.js/ai-live/src/index.ts"],"mappings":";;;;;;;;;;;;AAEsC;;;YAU1B,EAAA;IAAA;;;;;IAMR,KAAA,SAAc,KAAA;IAMW;AAAA;;;;IAAzB,QAAA,SAAiB,QAAQ;EAAA;AAAA"}

package/esm/index.mjs

@@ -0,0 +1,12 @@
+import { realtime } from "./realtime/realtime.mjs";
+import { video } from "./video/video.mjs";
+import { MockRealtimeConnection, MockRealtimeTransport, MockVideoModel } from "./mock/index.mjs";
+import { ai } from "@warlock.js/ai";
+
+//#region ../@warlock.js/ai-live/src/index.ts
+ai.video = video;
+ai.realtime = realtime;
+
+//#endregion
+export { MockRealtimeConnection, MockRealtimeTransport, MockVideoModel, realtime, video };
+//# sourceMappingURL=index.mjs.map

package/esm/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../../../../../@warlock.js/ai-live/src/index.ts"],"sourcesContent":["import { ai } from \"@warlock.js/ai\";\nimport { realtime } from \"./realtime/realtime\";\nimport { video } from \"./video/video\";\n\n/**\n * Augment the shared `Ai` facade with this package's two heavy\n * modalities. Importing `@warlock.js/ai-live` mounts `ai.video` +\n * `ai.realtime` as a side effect, mirroring how `@warlock.js/ai-tools`\n * mounts `ai.mcp` / `ai.tools` and `@warlock.js/ai-workspace` mounts\n * `ai.workspace`.\n */\ndeclare module \"@warlock.js/ai\" {\n  interface Ai {\n    /**\n     * Text-to-video generation (Sora / Veo / Kling-class). Async under\n     * the hood (submit→poll), surfaced as the uniform never-throws\n     * `{ data, error, usage, report }` envelope. Ships in `@warlock.js/ai-live`.\n     */\n    video: typeof video;\n    /**\n     * Live duplex voice sessions (OpenAI Realtime-class). A stateful\n     * session over a pluggable transport — push audio/text in, consume\n     * events out, `close()` for a report. Ships in `@warlock.js/ai-live`.\n     */\n    realtime: typeof realtime;\n  }\n}\n\nai.video = video;\nai.realtime = realtime;\n\nexport { realtime, video };\nexport type { VideoData, VideoParams, VideoReport, VideoResult } from \"./video/video\";\nexport * from \"./contracts/video.contract\";\nexport * from \"./contracts/realtime.contract\";\nexport * from \"./mock\";\n"],"mappings":";;;;;;AA4BA,GAAG,QAAQ;AACX,GAAG,WAAW"}