diff --git a/cloudflare-worker.mjs b/cloudflare-worker.mjs index d39577ee..7ff0878d 100644 --- a/cloudflare-worker.mjs +++ b/cloudflare-worker.mjs @@ -1,4 +1,4 @@ -import { nativeGenerationFetch, withForwardedCorrelation, withNativeMetrics, nativeCacheHeader, nativeGenerationSetup, generationErrorResponse, forwardedGenerationHeaders, runScheduledMaintenance, scheduledMaintenanceEnabled, handleRoleplayContextPageRequest } from "./worker/gateway-extensions.mjs"; +import { nativeGenerationFetch, withForwardedCorrelation, withNativeMetrics, nativeCacheHeader, nativeGenerationSetup, generationErrorResponse, forwardedGenerationHeaders, runScheduledMaintenance, scheduledMaintenanceEnabled, handleRoleplayContextPageRequest, handleRealtimeRequest } from "./worker/gateway-extensions.mjs"; import { batchesEnabled, runScheduledBatches } from "./worker/batch-jobs.mjs"; import { tickNativeRevisionSync } from "./worker/native-config-sync.mjs"; import { firewallFetch } from "./worker/secret-firewall.mjs"; @@ -1891,6 +1891,9 @@ export default { return applyCorsHeaders(request, buildFallbackHealthResponse(), env); } + const realtimeResponse = await handleRealtimeRequest(request, env, ctx); + if (realtimeResponse) return realtimeResponse.status === 101 ? realtimeResponse : applyCorsHeaders(request, realtimeResponse, env); + if (requestUrl.pathname === "/status.prometheus" || requestUrl.pathname === "/v1/metrics/prometheus") { if (!prometheusEnabled(env.PROMETHEUS_ENABLED)) { return new Response("Not found", { status: 404, headers: { "Cache-Control": "no-store" } }); diff --git a/docs/realtime.md b/docs/realtime.md new file mode 100644 index 00000000..cb452fae --- /dev/null +++ b/docs/realtime.md @@ -0,0 +1,91 @@ +# Worker Realtime WebSocket transport + +Realtime bridges authenticated OpenAI-compatible sockets directly in the Worker. +It does not start the Container. `REALTIME_ENABLED` is off by default; an unset, +empty, false or malformed value preserves existing route handling. A malformed +provider mapping disables Realtime and warns once without printing its value. + +Enable it with `REALTIME_ENABLED=true` and an exact model mapping: + +```json +{"openai:realtime-model":{"url":"wss://approved.example/v1/realtime?model=realtime-model"}} +``` + +Set this JSON as `REALTIME_PROVIDERS_JSON`. Every URL must use WSS, a public DNS +hostname and port 443. The mapping supplies the complete upstream URL, including +any provider model query. Client URLs, query fields, hosts and credentials never +select an upstream. Redirects are refused. OpenAI, OpenCode, LinkAPI, Codex Easy, +NanoGPT, OpenRouter, Groq and xAI use their existing Worker provider key bindings +with Bearer authentication. Configure only providers whose socket contract uses +that authentication. No caller header reaches upstream except the exact +`OpenAI-Beta: realtime=v1` version header. Upstream headers are not returned. + +Connect with `GET /v1/realtime?model=openai:realtime-model`, `Upgrade: websocket` +and `Authorization: Bearer ` or `X-MultiLLM-API-Key`. The bootstrap +gateway key, verifiable D1 dashboard keys and D1 integration keys are accepted. +Dashboard model grants, expiry, revocation and IP controls apply. Both `chat` and +`audio` scopes are required. Keys stored only in the Container cannot open sockets. +Each socket is authorized at admission; revoking a key stops later admissions, +including tickets. Already-open sockets expire within 15 minutes. + +With Realtime enabled, invalid upgrades return JSON 426, absent or invalid keys +return 401 and insufficient scopes or model grants return 403. Unsupported models +return 403. Missing storage, migrations, price evidence, monetary ceilings or +admission authority return JSON 503 before dialing. A full session or budget limit +returns 429. Upstream handshake failure returns 502; no automatic retry occurs. +With Realtime disabled, `/v1/realtime` keeps the existing Container handling. + +## Cost admission + +`REALTIME_SESSION_CAP_USD` must be positive. `REALTIME_PRICING_JSON` maps each +exact model to prices per million tokens and a provider-enforced session ceiling: + +```json +{"openai:realtime-model":{"input_text":1,"output_text":2,"input_audio":3,"output_audio":4,"provider_session_limit_usd":0.10}} +``` + +These numbers are illustrative, not a provider price quotation. The provider +ceiling must be enforced by an independently verified upstream account or session +contract and must be no greater than the gateway cap. Ordinary usage events arrive +after generation and cannot enforce a hard monetary ceiling themselves. Do not +configure an estimated cost as `provider_session_limit_usd`. If the upstream has +no enforceable ceiling, leave it unset: admission refuses the session. Operators +must verify that the ceiling includes every billed activity, including transcription. +The gateway cannot discover or certify a provider's billing contract from a socket. + +The entire ceiling is reserved through durable usage reservations before dialing. +Key daily/monthly budgets apply; otherwise set a positive +`REALTIME_DAILY_BUDGET_USD`. Existing unknown holds still reduce available budget. +Known final audio/text usage uses the supplied prices. Cached input requires +`cached_text` and `cached_audio` prices plus the provider's modality breakdown. +Partial, inconsistent, unpriced, interrupted or in-flight usage retains an unknown +hold instead of inventing a zero bill. Unpriced transcription remains unknown. +The usage ledger stores measured aggregate tokens and nullable cost. Realtime +session rows also store modality counts, opaque key identity, lease and timestamps. +Storage failures retain reservation evidence for operator reconciliation. + +## Lifetime and tickets + +At most two simultaneous sockets per gateway key are admitted atomically in D1. +Enable the existing admission authority with a nonzero principal or model-group +limit and its existing binding. Its renewable lease is held until either side +closes. Sessions have a 900-second TTL, 30-second idle limit and 1 MiB frame limit. +Both text and binary frames retain their bytes. Policy violations close 1008. +Upstream error events are forwarded verbatim before closing both sides with 1011, +unless an event exposes the provider key, in which case it is withheld and the +session closes 1008. Transport failures close 1011 without fabricated events. + +Optional `POST /v1/realtime/client_secrets` accepts an authenticated JSON body +`{"model":"openai:realtime-model"}`. It requires the existing `JWT_SECRET` binding +and returns `{value,expires_at}`: a gateway-scoped signed ticket, never a provider +secret. Present `value` as the Bearer token for the socket. Tickets last 60 seconds, +are restricted to that model and current credential, and are consumed atomically +once. At most 16 outstanding tickets per key may exist. A ticket cannot issue +another ticket. No credentials are accepted in URL parameters or subprotocols. + +Apply migration `0029_realtime_sessions.sql` and the existing usage/admission +migrations before enabling. No prompt, transcript, audio or event content is +persisted or logged. Socket metadata and unknown holds remain until the operator's +approved retention/reconciliation process handles them. The implementation does +not claim live provider protocol, billing or WebSocket compatibility from local +fake-socket checks. diff --git a/intelligence-migrations/0029_realtime_sessions.sql b/intelligence-migrations/0029_realtime_sessions.sql new file mode 100644 index 00000000..2ca5d6d9 --- /dev/null +++ b/intelligence-migrations/0029_realtime_sessions.sql @@ -0,0 +1,14 @@ +CREATE TABLE IF NOT EXISTS realtime_tickets ( + nonce TEXT PRIMARY KEY, principal_hash TEXT NOT NULL, owner TEXT NOT NULL, + credential_kind TEXT NOT NULL, credential_fingerprint TEXT NOT NULL, + model TEXT NOT NULL, expires_at INTEGER NOT NULL, consumed_at INTEGER +); +CREATE INDEX IF NOT EXISTS realtime_ticket_expiry ON realtime_tickets(expires_at); +CREATE TABLE IF NOT EXISTS realtime_sessions ( + id TEXT PRIMARY KEY, principal_hash TEXT NOT NULL, owner TEXT NOT NULL, model TEXT NOT NULL, + lease_id TEXT, created_at INTEGER NOT NULL, expires_at INTEGER NOT NULL, lease_until INTEGER NOT NULL, + state TEXT NOT NULL CHECK(state IN ('admitted','active','settled','unknown','released')), + input_text_tokens INTEGER, input_audio_tokens INTEGER, output_text_tokens INTEGER, output_audio_tokens INTEGER, + cost_usd REAL, closed_at INTEGER +); +CREATE INDEX IF NOT EXISTS realtime_session_scope ON realtime_sessions(principal_hash,state,lease_until); diff --git a/package.json b/package.json index a006629c..1bf970cf 100644 --- a/package.json +++ b/package.json @@ -9,7 +9,7 @@ "lint": "ruff check . --select E9,F63,F7,F82", "typecheck": "mypy --ignore-missing-imports --follow-imports=skip --disable-error-code import-untyped --disable-error-code var-annotated --disable-error-code arg-type --disable-error-code assignment --disable-error-code operator app.py routes services providers streaming", "test": "python -m pytest -q", - "test:worker": "node --test tests/test_cloudflare_worker.mjs tests/test_cascades_worker.mjs tests/test_cascades_dashboard.mjs tests/test_image_quality_worker.mjs tests/test_secret_scan_worker.mjs tests/test_secret_firewall_worker.mjs tests/test_secret_firewall_coverage_worker.mjs tests/test_roleplay_compaction_budget_worker.mjs tests/test_roleplay_compaction_model_worker.mjs tests/test_roleplay_stream_validation_worker.mjs tests/test_aihubmix_worker.mjs tests/test_gpt_image_moderation_worker.mjs tests/test_dashboard_scripts.mjs tests/test_operations_dashboard.mjs tests/test_opencode_reasoning_worker.mjs tests/test_opencode_thinking_worker.mjs tests/test_nanogpt_reasoning_worker.mjs tests/test_nanogpt_speed_routing_worker.mjs tests/test_sse_heartbeat_worker.mjs tests/test_roleplay_worker.mjs tests/test_roleplay_config_worker.mjs tests/test_roleplay_glm_failover_worker.mjs tests/test_roleplay_intelligence_worker.mjs tests/test_roleplay_memory_worker.mjs tests/test_roleplay_compatibility_worker.mjs tests/test_roleplay_history_reconciliation_worker.mjs tests/test_roleplay_output_contract_analysis.mjs tests/test_roleplay_output_contract_cleanup_worker.mjs tests/test_roleplay_output_contract_nonstream_worker.mjs tests/test_roleplay_output_contract_worker.mjs tests/test_roleplay_performance_worker.mjs tests/test_roleplay_quality_routing_worker.mjs tests/test_roleplay_reasoning_worker.mjs tests/test_roleplay_session_storage_worker.mjs tests/test_roleplay_transport_failure_worker.mjs tests/test_roleplay_unlimited_worker.mjs tests/test_roleplay_workbench_worker.mjs tests/test_roleplay_candidate_context_worker.mjs tests/test_roleplay_operator_worker.mjs tests/test_workbench_stream.mjs tests/test_intelligence_worker.mjs tests/test_intelligence_d1_worker.mjs tests/test_intelligence_auth_worker.mjs tests/test_intelligence_outbound_worker.mjs tests/test_intelligence_operator.mjs tests/test_control_users_worker.mjs tests/test_control_audit_worker.mjs tests/test_access_sso_worker.mjs tests/test_d1_schema_worker.mjs tests/test_shadow_eval_worker.mjs tests/test_auto_routes_worker.mjs tests/test_ai_outbound_worker.mjs tests/test_knowledge_*.mjs tests/test_control_state_worker.mjs tests/test_route_health_worker.mjs tests/test_gateway_mcp_worker.mjs tests/test_usage_ledger_worker.mjs tests/test_media_outbound_worker.mjs tests/test_media_files_worker.mjs tests/test_media_jobs_worker.mjs tests/test_tool_repair_worker.mjs tests/test_prometheus_worker.mjs tests/test_evaluation_noise_floor_worker.mjs tests/test_prompt_templates_worker.mjs tests/test_config_snapshots_worker.mjs tests/test_managed_idempotency_worker.mjs tests/test_wave3_hub_worker.mjs tests/test_wave3_transport_worker.mjs tests/test_admission_leases_worker.mjs tests/test_edge_request_metrics_worker.mjs tests/test_request_cancellation_worker.mjs tests/test_mcp_contract_drift_worker.mjs tests/test_zero_content_retention_worker.mjs tests/test_prompt_cache_cost_worker.mjs tests/test_config_revision_sync_worker.mjs tests/test_gateway_alerts_worker.mjs tests/test_session_tiers_worker.mjs tests/test_usage_reservations_worker.mjs tests/test_shared_generation_cache_worker.mjs tests/test_deferred_tools_worker.mjs tests/test_generation_deadline_worker.mjs tests/test_wave4_worker.mjs tests/test_responses_state_worker.mjs tests/test_gateway_batches_worker.mjs tests/test_semantic_generation_cache_worker.mjs tests/test_canary_traffic_worker.mjs tests/test_context_pages_worker.mjs tests/test_observability_exports_worker.mjs tests/test_prompt_injection_worker.mjs tests/test_pii_rehydration_worker.mjs tests/test_wave5_worker.mjs", + "test:worker": "node --test tests/test_cloudflare_worker.mjs tests/test_cascades_worker.mjs tests/test_cascades_dashboard.mjs tests/test_image_quality_worker.mjs tests/test_secret_scan_worker.mjs tests/test_secret_firewall_worker.mjs tests/test_secret_firewall_coverage_worker.mjs tests/test_roleplay_compaction_budget_worker.mjs tests/test_roleplay_compaction_model_worker.mjs tests/test_roleplay_stream_validation_worker.mjs tests/test_aihubmix_worker.mjs tests/test_gpt_image_moderation_worker.mjs tests/test_dashboard_scripts.mjs tests/test_operations_dashboard.mjs tests/test_opencode_reasoning_worker.mjs tests/test_opencode_thinking_worker.mjs tests/test_nanogpt_reasoning_worker.mjs tests/test_nanogpt_speed_routing_worker.mjs tests/test_sse_heartbeat_worker.mjs tests/test_roleplay_worker.mjs tests/test_roleplay_config_worker.mjs tests/test_roleplay_glm_failover_worker.mjs tests/test_roleplay_intelligence_worker.mjs tests/test_roleplay_memory_worker.mjs tests/test_roleplay_compatibility_worker.mjs tests/test_roleplay_history_reconciliation_worker.mjs tests/test_roleplay_output_contract_analysis.mjs tests/test_roleplay_output_contract_cleanup_worker.mjs tests/test_roleplay_output_contract_nonstream_worker.mjs tests/test_roleplay_output_contract_worker.mjs tests/test_roleplay_performance_worker.mjs tests/test_roleplay_quality_routing_worker.mjs tests/test_roleplay_reasoning_worker.mjs tests/test_roleplay_session_storage_worker.mjs tests/test_roleplay_transport_failure_worker.mjs tests/test_roleplay_unlimited_worker.mjs tests/test_roleplay_workbench_worker.mjs tests/test_roleplay_candidate_context_worker.mjs tests/test_roleplay_operator_worker.mjs tests/test_workbench_stream.mjs tests/test_intelligence_worker.mjs tests/test_intelligence_d1_worker.mjs tests/test_intelligence_auth_worker.mjs tests/test_intelligence_outbound_worker.mjs tests/test_intelligence_operator.mjs tests/test_control_users_worker.mjs tests/test_control_audit_worker.mjs tests/test_access_sso_worker.mjs tests/test_d1_schema_worker.mjs tests/test_shadow_eval_worker.mjs tests/test_auto_routes_worker.mjs tests/test_ai_outbound_worker.mjs tests/test_knowledge_*.mjs tests/test_control_state_worker.mjs tests/test_route_health_worker.mjs tests/test_gateway_mcp_worker.mjs tests/test_usage_ledger_worker.mjs tests/test_media_outbound_worker.mjs tests/test_media_files_worker.mjs tests/test_media_jobs_worker.mjs tests/test_tool_repair_worker.mjs tests/test_prometheus_worker.mjs tests/test_evaluation_noise_floor_worker.mjs tests/test_prompt_templates_worker.mjs tests/test_config_snapshots_worker.mjs tests/test_managed_idempotency_worker.mjs tests/test_wave3_hub_worker.mjs tests/test_wave3_transport_worker.mjs tests/test_admission_leases_worker.mjs tests/test_edge_request_metrics_worker.mjs tests/test_request_cancellation_worker.mjs tests/test_mcp_contract_drift_worker.mjs tests/test_zero_content_retention_worker.mjs tests/test_prompt_cache_cost_worker.mjs tests/test_config_revision_sync_worker.mjs tests/test_gateway_alerts_worker.mjs tests/test_session_tiers_worker.mjs tests/test_usage_reservations_worker.mjs tests/test_shared_generation_cache_worker.mjs tests/test_deferred_tools_worker.mjs tests/test_generation_deadline_worker.mjs tests/test_wave4_worker.mjs tests/test_responses_state_worker.mjs tests/test_gateway_batches_worker.mjs tests/test_semantic_generation_cache_worker.mjs tests/test_canary_traffic_worker.mjs tests/test_context_pages_worker.mjs tests/test_observability_exports_worker.mjs tests/test_prompt_injection_worker.mjs tests/test_pii_rehydration_worker.mjs tests/test_wave5_worker.mjs tests/test_realtime_worker.mjs", "db:migrate": "python scripts/validate_sqlite_schema.py --apply", "db:validate": "python scripts/validate_sqlite_schema.py", "security:secrets": "python scripts/check_static_secrets.py", diff --git a/tests/fixtures/secret_firewall_coverage.json b/tests/fixtures/secret_firewall_coverage.json index 37f37f77..21690fb8 100644 --- a/tests/fixtures/secret_firewall_coverage.json +++ b/tests/fixtures/secret_firewall_coverage.json @@ -334,6 +334,9 @@ "worker/prometheus.mjs", "worker/prompt-injection-detection.mjs", "worker/prompt-templates-d1.mjs", + "worker/realtime-metering.mjs", + "worker/realtime-session.mjs", + "worker/realtime.mjs", "worker/request-telemetry.mjs", "worker/reservations-d1.mjs", "worker/responses-state-d1.mjs", diff --git a/tests/test_realtime_worker.mjs b/tests/test_realtime_worker.mjs new file mode 100644 index 00000000..0776c2fa --- /dev/null +++ b/tests/test_realtime_worker.mjs @@ -0,0 +1,260 @@ +import test from "node:test"; +import assert from "node:assert/strict"; +import { DatabaseSync } from "node:sqlite"; +import { readFile, readdir } from "node:fs/promises"; +import { scryptSync } from "node:crypto"; +import { loadWorkerModule } from "./helpers/load_cloudflare_worker.mjs"; +import { handleRealtimeRequest, realtimeSettings } from "../worker/realtime.mjs"; +import { bridgeRealtime } from "../worker/realtime-session.mjs"; +import { createRealtimeMeter, realtimeCostPolicy } from "../worker/realtime-metering.mjs"; + +const worker = (await loadWorkerModule()).default; +const model = "openai:realtime-test"; +const prices = { input_text: 1, output_text: 2, input_audio: 3, output_audio: 4, provider_session_limit_usd: 0.1 }; +const enabled = { REALTIME_ENABLED: "true", ADMIN_API_KEY: "synthetic-gateway", + JWT_SECRET: "synthetic-ticket-signing", + OPENAI_API_KEY: "synthetic-provider", REALTIME_SESSION_CAP_USD: "0.2", REALTIME_DAILY_BUDGET_USD: "1", + REALTIME_PROVIDERS_JSON: JSON.stringify({ [model]: { url: "wss://approved.example/v1/realtime?model=realtime-test" } }), + REALTIME_PRICING_JSON: JSON.stringify({ [model]: prices }), ADMISSION_ENABLED: "true", ADMISSION_LIMITS_JSON: '{"principal":2}' }; +const request = (extra = {}) => new Request(`https://gateway.example/v1/realtime?model=${model}`, { + headers: { upgrade: "websocket", authorization: "Bearer synthetic-gateway", ...extra } }); +class Socket { + listeners = {}; sent = []; closes = []; accepted = false; + accept() { this.accepted = true; } + addEventListener(name, fn) { (this.listeners[name] ??= []).push(fn); } + removeEventListener(name, fn) { this.listeners[name] = (this.listeners[name] ?? []).filter(item => item !== fn); } + send(data) { this.sent.push(data); } + close(code, reason) { this.closes.push([code, reason]); } + emit(name, event = {}) { for (const fn of [...(this.listeners[name] ?? [])]) fn(event); } +} +function clock() { + let now = Date.now(), next = 0; const jobs = new Map(); + return { now: () => now, setTimeout(fn, delay) { jobs.set(++next, { at: now + delay, fn }); return next; }, + clearTimeout(id) { jobs.delete(id); }, async advance(ms) { now += ms; + for (const [id, job] of [...jobs]) if (job.at <= now) { jobs.delete(id); job.fn(); } + await new Promise(resolve => setImmediate(resolve)); } }; +} +async function fixture(t) { + const sql = new DatabaseSync(":memory:"); t.after(() => sql.close()); + const directory = new URL("../intelligence-migrations/", import.meta.url); + for (const file of (await readdir(directory)).filter(name => name.endsWith(".sql")).sort()) sql.exec(await readFile(new URL(file, directory), "utf8")); + const db = { prepare(query) { const values = []; return { bind(...args) { values.push(...args); return this; }, + async first() { return sql.prepare(query).get(...values) ?? null; }, + async all() { return { results: sql.prepare(query).all(...values), success: true }; }, + async run() { const meta = sql.prepare(query).run(...values); return { success: true, meta: { changes: Number(meta.changes) } }; }, + execute() { const stmt = sql.prepare(query); if (stmt.columns().length) return { success: true, results: stmt.all(...values), meta: { changes: 0 } }; + return { success: true, results: [], meta: { changes: Number(stmt.run(...values).changes) } }; } }; }, + async batch(statements) { sql.exec("BEGIN"); try { const results = statements.map(stmt => stmt.execute()); sql.exec("COMMIT"); return results; } + catch (error) { sql.exec("ROLLBACK"); throw error; } } }; + const server = new Socket(), client = new Socket(), upstream = new Socket(), timers = clock(), pending = [], leases = []; + const env = { ...enabled, INTELLIGENCE_DB: db, ADMISSION_COORDINATOR: { getByName() { return { async fetch(req) { + const value = await req.json(); leases.push(value); + return Response.json({ version: 1, ...(value.operation === "release" ? { released: true } + : { lease: { lease_id: "a".repeat(32), expires_at: Math.min(Date.now() + 25000, value.deadline_ms) } }) }); } }; } } }; + let calls = 0; const options = { timers, pair: () => ({ 0: client, 1: server }), + upgradeResponse: socket => ({ status: 101, webSocket: socket }), async dial(url, init) { calls++; + assert.equal(url, "https://approved.example/v1/realtime?model=realtime-test"); + assert.equal(init.headers.get("authorization"), "Bearer synthetic-provider"); + assert.equal(init.headers.get("x-attacker"), null); return { status: 101, webSocket: upstream }; } }; + const ctx = { waitUntil(promise) { pending.push(promise); } }; + return { sql, db, env, options, ctx, server, upstream, client, timers, leases, calls: () => calls, + async flush() { await Promise.all(pending); } }; +} +const done = (id = "r1") => JSON.stringify({ type: "response.done", response: { id, status: "completed", usage: { + input_tokens: 3, output_tokens: 2, input_token_details: { text_tokens: 1, audio_tokens: 2, cached_tokens: 0 }, + output_token_details: { text_tokens: 1, audio_tokens: 1 } } } }); + +test("disabled, empty and malformed flags preserve registered Container bytes and headers", async () => { + for (const flag of [undefined, "", "false", "garbage"]) { + let calls = 0; const env = { REALTIME_ENABLED: flag, MULTILLM_PROXY_CONTAINER: { getByName() { return { + async fetch(req) { calls++; assert.equal(req.headers.get("upgrade"), "websocket"); + return new Response("unchanged 雪", { status: 418, headers: { "x-original": "yes" } }); } }; } } }; + const response = await worker.fetch(request(), env, {}); + assert.equal(response.status, 418); assert.equal(response.headers.get("x-original"), "yes"); + assert.equal(await response.text(), "unchanged 雪"); assert.equal(calls, 1); + assert.equal(await handleRealtimeRequest(request(), env), null); + } +}); +test("invalid mappings disable once without logging values", () => { + const old = console.warn, messages = []; console.warn = message => messages.push(message); + try { for (const url of ["https://approved.example", "wss://user:password@approved.example", "wss://127.0.0.1/x", "wss://approved.example/#x", "wss://approved.example/?api_key=private"]) { + const env = { ...enabled, REALTIME_PROVIDERS_JSON: JSON.stringify({ [model]: { url } }) }; + assert.equal(realtimeSettings(env).enabled, false); assert.equal(realtimeSettings(env).enabled, false); + } } finally { console.warn = old; } + assert.equal(messages.length, 1); assert.ok(!messages.join().includes("password")); +}); +test("registered enabled errors never wake Container", async () => { + const env = { ...enabled, MULTILLM_PROXY_CONTAINER: { getByName() { throw Error("Container woke"); } } }; + for (const [req, expected] of [[request({ upgrade: "" }), 426], [request({ authorization: "" }), 401], + [new Request("https://gateway.example/v1/realtime?model=openai:unmapped", { headers: { upgrade: "websocket", authorization: "Bearer synthetic-gateway" } }), 403]]) { + const response = await worker.fetch(req, env, {}); assert.equal(response.status, expected); assert.ok((await response.json()).error.code); + } +}); +test("missing session migration, prices, cap or admission fail before dialing", async t => { + const f = await fixture(t); f.sql.exec("DROP TABLE realtime_sessions"); + assert.equal((await handleRealtimeRequest(request(), f.env, f.ctx, f.options)).status, 503); assert.equal(f.calls(), 0); + for (const changes of [{ REALTIME_PRICING_JSON: "{}" }, { REALTIME_SESSION_CAP_USD: "" }, { ADMISSION_ENABLED: "false" }]) { + const response = await handleRealtimeRequest(request(), { ...f.env, ...changes }, f.ctx, f.options); + assert.equal(response.status, 503); assert.equal(f.calls(), 0); + } +}); +test("policy requires known audio/text prices and an enforceable upstream ceiling", () => { + assert.equal(realtimeCostPolicy(enabled, model).cap, 0.2); + for (const changes of [{ input_audio: null }, { provider_session_limit_usd: null }, { provider_session_limit_usd: 1 }]) { + assert.throws(() => realtimeCostPolicy({ ...enabled, REALTIME_PRICING_JSON: JSON.stringify({ [model]: { ...prices, ...changes } }) }, model)); + } +}); +test("approved sockets preserve JSON/binary, lease lifetime, measured usage and content-free ledger", async t => { + const f = await fixture(t); + const response = await handleRealtimeRequest(request({ "x-attacker": "bad", "openai-beta": "realtime=v1" }), f.env, f.ctx, f.options); + assert.equal(response.status, 101); assert.equal(f.calls(), 1); assert.equal(f.leases.length, 1); + f.server.emit("message", { data: '{"type":"conversation.item.create","content":"private prompt"}' }); + const binary = new Uint8Array([1, 2]).buffer; f.upstream.emit("message", { data: binary }); + assert.equal(f.upstream.sent[0], '{"type":"conversation.item.create","content":"private prompt"}'); assert.equal(f.server.sent[0], binary); + f.upstream.emit("message", { data: done() }); f.server.emit("close", { code: 1000 }); await f.flush(); + assert.equal(f.leases.at(-1).operation, "release"); assert.equal(f.upstream.closes.length, 1); + const row = f.sql.prepare("SELECT * FROM usage_events").get(); + assert.deepEqual([row.input_tokens, row.output_tokens, row.cost_usd, row.cost_basis], [3, 2, 0.000013, "usage"]); + assert.equal(f.sql.prepare("SELECT state FROM usage_reservations").get().state, "settled"); + assert.ok(!JSON.stringify(f.sql.prepare("SELECT * FROM realtime_sessions").all()).includes("private prompt")); +}); +test("single-use tickets expire and cannot switch models or bypass rotated credentials", async t => { + const f = await fixture(t), issue = () => handleRealtimeRequest(new Request("https://gateway.example/v1/realtime/client_secrets", { + method: "POST", headers: { authorization: "Bearer synthetic-gateway", "content-type": "application/json" }, body: JSON.stringify({ model }) }), f.env, f.ctx, f.options); + const issued = await issue(), payload = await issued.json(); assert.equal(issued.status, 200); + assert.ok(!JSON.stringify(payload).includes("synthetic-provider")); + const ticketReq = token => request({ authorization: `Bearer ${token}` }); + assert.equal((await handleRealtimeRequest(ticketReq(payload.value), f.env, f.ctx, f.options)).status, 101); + assert.equal((await handleRealtimeRequest(ticketReq(payload.value), f.env, f.ctx, f.options)).status, 401); + f.server.emit("close", { code: 1000 }); await f.flush(); + const rotated = await (await issue()).json(); + assert.equal((await handleRealtimeRequest(ticketReq(rotated.value), { ...f.env, ADMIN_API_KEY: "synthetic-rotated" }, f.ctx, f.options)).status, 401); + const otherModel = new Request(`https://gateway.example/v1/realtime?model=openai:other`, { headers: { upgrade: "websocket", authorization: `Bearer ${rotated.value}` } }); + assert.equal((await handleRealtimeRequest(otherModel, f.env, f.ctx, f.options)).status, 401); + const tampered = rotated.value.slice(0, -1) + (rotated.value.endsWith("A") ? "B" : "A"); + assert.equal((await handleRealtimeRequest(ticketReq(tampered), f.env, f.ctx, f.options)).status, 401); + const expired = await (await issue()).json(); await f.timers.advance(60001); + assert.equal((await handleRealtimeRequest(ticketReq(expired.value), f.env, f.ctx, f.options)).status, 401); +}); +test("D1 admission enforces two sessions per key across parallel requests", async t => { + const f = await fixture(t); + const results = await Promise.all(Array.from({ length: 3 }, () => handleRealtimeRequest(request(), f.env, f.ctx, + { ...f.options, pair: () => ({ 0: new Socket(), 1: new Socket() }), dial: async () => ({ status: 101, webSocket: new Socket() }) }))); + assert.deepEqual(results.map(r => r.status).sort(), [101, 101, 429]); + await f.timers.advance(900001); await f.flush(); +}); +test("upstream real errors precede 1011; uncertain usage retains a distinct hold", async t => { + const f = await fixture(t); await handleRealtimeRequest(request(), f.env, f.ctx, f.options); + const error = '{"type":"error","error":{"code":"upstream_limit","message":"real error"}}'; + f.upstream.emit("message", { data: error }); f.upstream.emit("error"); f.server.emit("close"); await f.flush(); + assert.equal(f.server.sent[0], error); assert.equal(f.server.closes[0][0], 1011); assert.equal(f.upstream.closes.length, 1); + assert.equal(f.sql.prepare("SELECT state FROM usage_reservations").get().state, "unknown"); + assert.equal(f.sql.prepare("SELECT cost_usd FROM usage_events").get().cost_usd, null); +}); +test("frame, idle, TTL, request abort and send failures couple closure exactly once", async () => { + for (const mode of ["frame", "idle", "ttl", "abort", "send"]) { + const client = new Socket(), upstream = new Socket(), timers = clock(), controller = new AbortController(); let finalized = 0; + const bridge = bridgeRealtime(client, upstream, { timers, signal: controller.signal, meter: createRealtimeMeter({ ...prices, cap: 0.2 }), + finalize: async () => { finalized++; } }); + if (mode === "frame") client.emit("message", { data: "雪".repeat(400000) }); + if (mode === "idle") await timers.advance(30000); + if (mode === "ttl") { for (let i = 0; i < 30; i++) { await timers.advance(29999); client.emit("message", { data: "{}" }); } await timers.advance(31); } + if (mode === "abort") controller.abort(); + if (mode === "send") { upstream.send = () => { throw Error("private failure"); }; client.emit("message", { data: "{}" }); } + await bridge.done; assert.equal(finalized, 1); assert.equal(client.closes.length, 1); assert.equal(upstream.closes.length, 1); + assert.equal(client.closes[0][0], mode === "send" ? 1011 : 1008); + } +}); +test("usage dedupe, partial, in-flight and cap overflow never invent a final bill", () => { + const meter = createRealtimeMeter({ ...prices, cap: 0.2 }); meter.observe(done()); meter.observe(done()); + assert.equal(meter.finish().cost_usd, 0.000013); + meter.observe('{"type":"response.created","response":{"id":"r2"}}'); assert.equal(meter.finish().cost_usd, null); + const unknown = createRealtimeMeter({ ...prices, cap: 0.2 }); unknown.observe('{"type":"response.done","response":{"id":"r","usage":{"input_tokens":1}}}'); + assert.equal(unknown.finish().cost_usd, null); + const overflow = createRealtimeMeter({ ...prices, cap: 0.000001 }); assert.equal(overflow.observe(done()), "policy"); assert.equal(overflow.finish().cost_usd, null); + const cached = createRealtimeMeter({ ...prices, cap: 0.2 }); + const event = JSON.parse(done()); event.response.usage.input_token_details.cached_tokens = 1; + cached.observe(JSON.stringify(event)); assert.equal(cached.finish().cost_usd, null); +}); + +test("dashboard key model grants, scopes, expiry and tickets use current D1 authority", async t => { + const f = await fixture(t), key = "synthetic-account-key", salt = "syntheticsalt"; + const hash = `scrypt:32768:8:1$${salt}$${scryptSync(key, salt, 64, { N: 32768, r: 8, p: 1, maxmem: 64 * 1024 * 1024 }).toString("hex")}`; + f.env.AUTH_STORAGE_BACKEND = "d1"; + f.sql.prepare(`INSERT INTO control_users(username,api_key_hash,api_key_prefix,scopes,is_admin,created_at,allowed_models) + VALUES (?,?,?,?,0,?,?)`).run("fixture-user", hash, `mllm_${key.slice(0, 8)}`, "chat,audio", new Date().toISOString(), "openai:other"); + assert.equal((await handleRealtimeRequest(request({ authorization: `Bearer ${key}` }), f.env, f.ctx, f.options)).status, 403); + f.sql.prepare("UPDATE control_users SET allowed_models='OPENAI:realtime-*',scopes='chat' WHERE username='fixture-user'").run(); + assert.equal((await handleRealtimeRequest(request({ authorization: `Bearer ${key}` }), f.env, f.ctx, f.options)).status, 403); + f.sql.prepare("UPDATE control_users SET scopes='chat,audio',expires_at='2000-01-01T00:00:00Z' WHERE username='fixture-user'").run(); + assert.equal((await handleRealtimeRequest(request({ authorization: `Bearer ${key}` }), f.env, f.ctx, f.options)).status, 401); + f.sql.prepare("UPDATE control_users SET expires_at=NULL WHERE username='fixture-user'").run(); + assert.equal((await handleRealtimeRequest(request({ authorization: `Bearer ${key}` }), f.env, f.ctx, f.options)).status, 101); + f.server.emit("close", { code: 1000 }); await f.flush(); assert.equal(f.calls(), 1); +}); +test("provider-key echoes close 1008 without transmitting bytes or escaped JSON", async () => { + for (const data of ['{"key":"synthetic-provider"}', '{"key":"synthetic-\\u0070rovider"}', new TextEncoder().encode("synthetic-provider").buffer]) { + const client = new Socket(), upstream = new Socket(); + const bridge = bridgeRealtime(client, upstream, { secret: "synthetic-provider", meter: createRealtimeMeter({ ...prices, cap: 0.2 }), finalize: async () => {} }); + upstream.emit("message", { data }); await bridge.done; + assert.equal(client.sent.length, 0); assert.equal(client.closes[0][0], 1008); + } +}); +test("redirects and handshake failures are not followed and retain ambiguous holds", async t => { + const f = await fixture(t); + const result = await handleRealtimeRequest(request(), f.env, f.ctx, { ...f.options, dial: async (url, init) => { + assert.equal(init.redirect, "manual"); return new Response("private upstream", { status: 302, headers: { location: "https://attacker.example" } }); } }); + assert.equal(result.status, 502); assert.equal(f.leases.at(-1).operation, "release"); + assert.equal(f.sql.prepare("SELECT state FROM usage_reservations").get().state, "unknown"); + assert.ok(!JSON.stringify(await result.json()).includes("private upstream")); +}); + +test("registered successful socket route never wakes Container or forwards caller headers", async t => { + const f = await fixture(t), BaseResponse = globalThis.Response, previousFetch = globalThis.fetch, previousPair = globalThis.WebSocketPair; + globalThis.Response = class extends BaseResponse { constructor(body, init) { + if (init?.status === 101) return { status: 101, webSocket: init.webSocket }; + super(body, init); + } }; + globalThis.WebSocketPair = class { constructor() { return { 0: f.client, 1: f.server }; } }; + globalThis.fetch = async (url, init) => { assert.equal(url, "https://approved.example/v1/realtime?model=realtime-test"); + assert.deepEqual([...init.headers.keys()].sort(), ["authorization", "openai-beta", "upgrade"]); + assert.equal(init.headers.get("authorization"), "Bearer synthetic-provider"); return { status: 101, webSocket: f.upstream }; }; + try { + const response = await worker.fetch(request({ "x-attacker": "bad", "openai-beta": "realtime=v1" }), { + ...f.env, MULTILLM_PROXY_CONTAINER: { getByName() { throw Error("Container woke"); } } }, f.ctx); + assert.equal(response.status, 101); assert.equal(response.webSocket, f.client); + f.upstream.emit("message", { data: done() }); f.server.emit("close", { code: 1000 }); await f.flush(); + } finally { globalThis.Response = BaseResponse; globalThis.fetch = previousFetch; globalThis.WebSocketPair = previousPair; } +}); +test("additive session migration preserves prior rows and can be applied again", async t => { + const f = await fixture(t); + f.sql.prepare("INSERT INTO realtime_sessions(id,principal_hash,owner,model,created_at,expires_at,lease_until,state) VALUES (?,?,?,?,0,1,1,'unknown')") + .run("old-row", "opaque-key", "old-owner", model); + f.sql.exec(await readFile(new URL("../intelligence-migrations/0029_realtime_sessions.sql", import.meta.url), "utf8")); + assert.equal(f.sql.prepare("SELECT state FROM realtime_sessions WHERE id='old-row'").get().state, "unknown"); + assert.equal(f.sql.prepare("SELECT name FROM sqlite_master WHERE name='usage_reservations'").get().name, "usage_reservations"); +}); +test("late input, transcription and canceled responses retain holds", () => { + for (const mode of ["input", "transcription", "canceled"]) { + const meter = createRealtimeMeter({ ...prices, cap: 0.2 }); meter.observe(done()); + if (mode === "input") meter.noteInput('{"type":"input_audio_buffer.append","audio":"opaque"}'); + if (mode === "transcription") meter.observe('{"type":"conversation.item.input_audio_transcription.completed"}'); + if (mode === "canceled") { const value = JSON.parse(done("r2")); value.response.status = "cancelled"; meter.observe(JSON.stringify(value)); } + assert.equal(meter.finish().cost_usd, null); + } +}); +test("output from a later incomplete response never settles prior usage as the final bill", () => { + const meter = createRealtimeMeter({ ...prices, cap: 0.2 }); meter.observe(done()); + meter.observe('{"type":"response.output_audio.delta","response_id":"r2","delta":"opaque"}'); + assert.equal(meter.finish().cost_usd, null); + meter.observe(done("r2")); assert.equal(meter.finish().cost_usd, 0.000026); +}); +test("missing lease, storage failure and budget exhaustion never dial", async t => { + const f = await fixture(t); + for (const env of [{ ...f.env, ADMISSION_LIMITS_JSON: "{}" }, { ...f.env, REALTIME_DAILY_BUDGET_USD: "0.01" }, + { ...f.env, INTELLIGENCE_DB: { prepare() { throw Error("private storage details"); } } }]) { + const response = await handleRealtimeRequest(request(), env, f.ctx, f.options); + assert.ok([429, 503].includes(response.status)); assert.equal(f.calls(), 0); + assert.ok(!JSON.stringify(await response.json()).includes("private storage details")); + } +}); diff --git a/worker/api-paths.mjs b/worker/api-paths.mjs index facf5dbe..aeb69737 100644 --- a/worker/api-paths.mjs +++ b/worker/api-paths.mjs @@ -32,6 +32,10 @@ const API_ROUTE_PREFIXES = new Set([ "xai", ]); +export function isRealtimeRequestPath(pathname) { + return pathname === "/v1/realtime" || pathname.startsWith("/v1/realtime/"); +} + export function isApiRequestPath(pathname) { const stripped = pathname.replace(/^\/+|\/+$/g, ""); if (!stripped) { diff --git a/worker/container-env.mjs b/worker/container-env.mjs index a27d53fb..dd44801f 100644 --- a/worker/container-env.mjs +++ b/worker/container-env.mjs @@ -40,6 +40,8 @@ const DIRECT_ENV_KEYS = [ "CONNECTION_PROFILES_DB_PATH", "CONFIG_REVISION_SYNC_ENABLED", "CONFIG_SYNC_TTL_SECONDS", + "REALTIME_ENABLED", + "REALTIME_PROVIDERS_JSON", "BANDIT_MODE", "BATCH_SPILLOVER_ENABLED", "CANARY_TRAFFIC_ENABLED", diff --git a/worker/d1-schema.mjs b/worker/d1-schema.mjs index 28996804..5c1351dd 100644 --- a/worker/d1-schema.mjs +++ b/worker/d1-schema.mjs @@ -10,7 +10,7 @@ export const REQUIRED_D1_TABLES = Object.freeze(["intelligence_policy", "intelli "usage_events", "usage_daily", "usage_batches", "media_jobs", "media_job_items", "shadow_eval_samples", "shadow_eval_results", "shadow_eval_config", "shadow_eval_policy_backups", "prompt_templates", - "config_snapshot_revisions", "config_snapshots", "config_snapshot_applications", "control_revisions", "tool_grants", "generation_cache", "usage_reservation_budgets", "usage_reservations", "usage_reservation_transitions", "session_tiers", "gateway_alert_rules", "gateway_alert_events", "managed_idempotency", "context_pages", "canary_traffic", "semantic_generation_cache", "gateway_batch_files", "gateway_batches", "gateway_batch_items", "hosted_responses"]); + "config_snapshot_revisions", "config_snapshots", "config_snapshot_applications", "control_revisions", "tool_grants", "generation_cache", "usage_reservation_budgets", "usage_reservations", "usage_reservation_transitions", "session_tiers", "gateway_alert_rules", "gateway_alert_events", "managed_idempotency", "context_pages", "canary_traffic", "semantic_generation_cache", "gateway_batch_files", "gateway_batches", "gateway_batch_items", "hosted_responses", "realtime_tickets", "realtime_sessions"]); /** * Readiness for the D1 schema. A deploy that skipped `wrangler d1 migrations apply` reports diff --git a/worker/gateway-extensions.mjs b/worker/gateway-extensions.mjs index face3046..034a1084 100644 --- a/worker/gateway-extensions.mjs +++ b/worker/gateway-extensions.mjs @@ -10,6 +10,7 @@ import { generationDeadlineHook, createGenerationDeadline, forwardedDeadlineHead import { nativeReservationLifecycle, reservationSettings, ReservationError } from "./reservations-d1.mjs"; export { runScheduledMaintenance, scheduledMaintenanceEnabled } from "./scheduled-maintenance.mjs"; export { handleResponsesStateRequest, responsesStateEnabled } from "./responses-state-d1.mjs"; +export { handleRealtimeRequest } from "./realtime.mjs"; import { UpstreamCancellation } from "./upstream-cancellation.mjs"; import { prepareSemanticCache, semanticCacheSettings, createNativeSemanticCollaborators } from "./semantic-generation-cache.mjs"; import { createNativeObservabilityHook, observabilityEnabled } from "./observability-export.mjs"; diff --git a/worker/realtime-metering.mjs b/worker/realtime-metering.mjs new file mode 100644 index 00000000..569d254a --- /dev/null +++ b/worker/realtime-metering.mjs @@ -0,0 +1,125 @@ +/** Content-free Realtime price evidence and durable monetary holds. */ +import { reserveUsage, transitionUsage } from "./reservations-d1.mjs"; +import { recordNativeUsage } from "./usage-ledger-d1.mjs"; + +const integer = value => Number.isSafeInteger(value) && value >= 0; +const money = value => typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= 1_000_000; +const id = () => crypto.randomUUID().replaceAll("-", ""); +export class RealtimeError extends Error { + constructor(code, status = 503) { super(code); this.code = code; this.status = status; } + response() { return Response.json({ error: { code: this.code, message: "The Realtime request could not be admitted or completed." } }, + { status: this.status, headers: { "cache-control": "no-store", ...(this.status === 426 ? { Upgrade: "websocket" } : {}) } }); } +} +export function realtimeCostPolicy(env, model) { + const cap = Number(String(env.REALTIME_SESSION_CAP_USD ?? "").trim()); + let price; + try { const raw = String(env.REALTIME_PRICING_JSON ?? ""); if (raw.length > 65536) throw Error(); price = JSON.parse(raw || "{}")[model]; } + catch { throw new RealtimeError("realtime_unpriced"); } + // This ceiling must be enforced by the approved provider's account/session contract. + // Post-response usage alone cannot cap money already spent upstream. + if (!money(cap) || cap <= 0 || !price || Array.isArray(price) + || !["input_text", "output_text", "input_audio", "output_audio"].every(name => money(price[name])) + || !money(price.provider_session_limit_usd) || price.provider_session_limit_usd <= 0 + || price.provider_session_limit_usd > cap) throw new RealtimeError("realtime_unpriced_or_unbounded"); + return Object.freeze({ ...price, cap }); +} +function usageDetails(usage, policy) { + const input = usage?.input_token_details, output = usage?.output_token_details; + const counts = [input?.text_tokens, input?.audio_tokens, output?.text_tokens, output?.audio_tokens]; + if (!counts.every(integer) || !integer(usage.input_tokens) || !integer(usage.output_tokens) + || counts[0] + counts[1] !== usage.input_tokens || counts[2] + counts[3] !== usage.output_tokens) return null; + let cost = (counts[0] * policy.input_text + counts[1] * policy.input_audio + + counts[2] * policy.output_text + counts[3] * policy.output_audio) / 1_000_000; + const cached = input.cached_tokens ?? 0; + if (!integer(cached) || cached > usage.input_tokens) return null; + if (cached) { + const details = input.cached_tokens_details; + if (!integer(details?.text_tokens) || !integer(details?.audio_tokens) || details.text_tokens + details.audio_tokens !== cached + || details.text_tokens > counts[0] || details.audio_tokens > counts[1] + || !money(policy.cached_text) || !money(policy.cached_audio)) return null; + cost += (details.text_tokens * (policy.cached_text - policy.input_text) + + details.audio_tokens * (policy.cached_audio - policy.input_audio)) / 1_000_000; + } + return money(cost) ? { counts, cost } : null; +} +export function createRealtimeMeter(policy) { + let cost = 0, unknown = false, seenUsage = false, inputDirty = false; + const totals = [0, 0, 0, 0], completed = new Set(), pending = new Set(); + return { + noteInput(data) { + if (typeof data !== "string") { inputDirty = true; return; } + let event; try { event = JSON.parse(data); } catch { inputDirty = true; return; } + if (["conversation.item.create", "input_audio_buffer.append", "input_audio_buffer.commit", "response.create"].includes(event?.type)) inputDirty = true; + }, + observe(data) { + if (typeof data !== "string") return; + let event; try { event = JSON.parse(data); } catch { unknown = true; return; } + if (event?.type === "error" || event?.error) { unknown = true; return "upstream_error"; } + if (event?.type === "conversation.item.input_audio_transcription.completed") unknown = true; + if (typeof event?.type === "string" && event.type.startsWith("response.") && event.type !== "response.done") { + const responseId = event.response?.id ?? event.response_id; + if (responseId !== undefined || event.type === "response.created" || event.type.endsWith(".delta")) { + if (typeof responseId !== "string" || !responseId || responseId.length > 128 || pending.size >= 256) { unknown = true; return "policy"; } + if (completed.has(responseId)) unknown = true; + else pending.add(responseId); + } + } + if (event?.type !== "response.done") return; + const responseId = event.response?.id; + if (typeof responseId !== "string" || responseId.length > 128) { unknown = true; return; } + if (completed.has(responseId)) return; + if (completed.size >= 256) { unknown = true; return "policy"; } + completed.add(responseId); pending.delete(responseId); + const usage = usageDetails(event.response?.usage, policy); + if (!usage || event.response.status !== "completed") { unknown = true; return; } + seenUsage = true; inputDirty = false; cost += usage.cost; + totals.forEach((value, index) => { totals[index] = value + usage.counts[index]; }); + if (!money(cost) || !totals.every(integer) || cost > policy.cap || cost > policy.provider_session_limit_usd) { + unknown = true; return "policy"; + } + }, + finish({ uncertain = false } = {}) { + const known = seenUsage && !unknown && !pending.size && !inputDirty && !uncertain; + return { input_text_tokens: seenUsage ? totals[0] : null, input_audio_tokens: seenUsage ? totals[1] : null, + output_text_tokens: seenUsage ? totals[2] : null, output_audio_tokens: seenUsage ? totals[3] : null, + input_tokens: seenUsage ? totals[0] + totals[1] : null, output_tokens: seenUsage ? totals[2] + totals[3] : null, + cost_usd: known ? cost : null, cost_basis: known ? "usage" : null }; + }, + }; +} +export async function reserveRealtime(env, principal, policy, sessionId, now) { + const defaultBudget = Number(String(env.REALTIME_DAILY_BUDGET_USD ?? "").trim()); + const daily = principal.daily_budget_usd ?? (money(defaultBudget) && defaultBudget > 0 ? defaultBudget : null); + const monthly = principal.monthly_budget_usd ?? null; + if (daily === null && monthly === null) throw new RealtimeError("realtime_budget_required"); + const day = new Date(now).toISOString().slice(0, 10); + const spent = await env.INTELLIGENCE_DB.prepare(`SELECT + COALESCE(SUM(CASE WHEN day=?2 THEN cost_usd ELSE 0 END),0) AS day_usd, + COALESCE(SUM(cost_usd),0) AS month_usd FROM usage_daily WHERE principal=?1 AND day>=?3 AND day<=?2`) + .bind(principal.owner, day, day.slice(0, 7) + "-01").first(); + await reserveUsage(env.INTELLIGENCE_DB, { id: sessionId, principal: principal.owner, + estimate_usd: policy.provider_session_limit_usd, daily_budget_usd: daily, monthly_budget_usd: monthly, + day_spent_usd: spent.day_usd, month_spent_usd: spent.month_usd }, now); + let revision = 0, handedOff = false, finished; + return { + async dispatch() { await transitionUsage(env.INTELLIGENCE_DB, { id: sessionId, revision, state: "dispatched", transition_id: id() }, now); + revision++; handedOff = true; }, + finalize(usage, context, status, ctx) { + if (finished) return finished; + finished = (async () => { + const known = usage.cost_usd !== null; + const state = !handedOff || known ? "settled" : "unknown"; + // The ledger is idempotent, but its writer absorbs storage faults. Persist the + // uncertainty state first, then leave durable session metadata for reconciliation. + await transitionUsage(env.INTELLIGENCE_DB, { id: sessionId, revision, state, transition_id: id(), + input_tokens: usage.input_tokens, output_tokens: usage.output_tokens, + ...(!handedOff || known ? { cost_usd: handedOff ? usage.cost_usd : 0, + basis: handedOff ? "provider" : "released", settlement_id: id() } : {}) }, Date.now()); + if (handedOff) await recordNativeUsage(env, { ...context, ...usage, status, + duration_ms: Math.min(86_400_000, Math.max(0, Date.now() - now)) }, ctx); + return state; + })(); + return finished; + }, + }; +} diff --git a/worker/realtime-session.mjs b/worker/realtime-session.mjs new file mode 100644 index 00000000..9b3e361f --- /dev/null +++ b/worker/realtime-session.mjs @@ -0,0 +1,72 @@ +/** Coupled sockets with bounded lifetime; no payload storage or logging. */ +export const REALTIME_TTL_MS = 900_000; +export const REALTIME_IDLE_MS = 30_000; +export const REALTIME_FRAME_BYTES = 1_048_576; +const byteLength = data => typeof data === "string" ? new TextEncoder().encode(data).byteLength + : data instanceof ArrayBuffer || ArrayBuffer.isView(data) ? data.byteLength : Infinity; +const closeCode = code => [1000, 1001, 1008, 1011].includes(code) || (code >= 3000 && code <= 4999) ? code : 1011; +function exposesSecret(data, secret) { + if (!secret) return false; + if (typeof data === "string") { + if (data.includes(secret)) return true; + try { return JSON.stringify(JSON.parse(data)).includes(secret); } catch { return false; } + } + const bytes = data instanceof ArrayBuffer ? new Uint8Array(data) : new Uint8Array(data.buffer, data.byteOffset, data.byteLength); + return new TextDecoder().decode(bytes).includes(secret); +} + +export function bridgeRealtime(client, upstream, { meter, finalize, signal, timers = globalThis, lease, heartbeat, secret }) { + let closed = false, idleTimer, heartbeatTimer, resolveDone; + const done = new Promise(resolve => { resolveDone = resolve; }); + const listeners = []; + const listen = (socket, name, fn) => { socket.addEventListener(name, fn); listeners.push([socket, name, fn]); }; + const clear = () => { + timers.clearTimeout(ttlTimer); timers.clearTimeout(idleTimer); timers.clearTimeout(heartbeatTimer); + signal?.removeEventListener("abort", aborted); + for (const [socket, name, fn] of listeners) socket.removeEventListener?.(name, fn); + }; + const finish = (code, uncertain = false) => { + if (closed) return done; + closed = true; clear(); + for (const socket of [client, upstream]) { try { socket.close(code, code === 1000 ? "" : "Realtime session closed"); } catch { /* Already closed. */ } } + const finalization = Promise.resolve().then(() => finalize(meter.finish({ uncertain }), code)); + void Promise.allSettled([finalization, Promise.resolve().then(() => lease?.release())]).then(results => { + if (results.some(result => result.status === "rejected")) console.warn("Realtime finalization unavailable; retain monetary hold"); + resolveDone(); + }); + return done; + }; + const aborted = () => { void finish(1008, true); }; + const idle = () => { + timers.clearTimeout(idleTimer); idleTimer = timers.setTimeout(() => { void finish(1008, true); }, REALTIME_IDLE_MS); idleTimer?.unref?.(); + }; + const renew = () => { + heartbeatTimer = timers.setTimeout(() => { + if (closed) return; + void Promise.resolve().then(() => { lease?.check(); return heartbeat?.(); }) + .then(() => { if (!closed) renew(); }, () => finish(1008, true)); + }, 10_000); heartbeatTimer?.unref?.(); + }; + const forward = (target, upstreamMessage) => event => { + if (closed) return; + if (byteLength(event.data) > REALTIME_FRAME_BYTES) { void finish(1008, true); return; } + try { + lease?.check(); + if (upstreamMessage && exposesSecret(event.data, secret)) { void finish(1008, true); return; } + if (!upstreamMessage) meter.noteInput?.(event.data); + const result = upstreamMessage ? meter.observe(event.data) : null; + if (result === "policy") { void finish(1008, true); return; } + target.send(event.data); idle(); + if (result === "upstream_error") void finish(1011, true); + } catch { void finish(1011, true); } + }; + const ttlTimer = timers.setTimeout(() => { void finish(1008, true); }, REALTIME_TTL_MS); ttlTimer?.unref?.(); + listen(client, "message", forward(upstream, false)); listen(upstream, "message", forward(client, true)); + for (const socket of [client, upstream]) { + listen(socket, "close", event => { const code = closeCode(event.code); void finish(code, code !== 1000); }); + listen(socket, "error", () => { void finish(1011, true); }); + } + idle(); if (heartbeat) renew(); + signal?.addEventListener("abort", aborted, { once: true }); if (signal?.aborted) aborted(); + return { done, close: finish }; +} diff --git a/worker/realtime.mjs b/worker/realtime.mjs new file mode 100644 index 00000000..9082e155 --- /dev/null +++ b/worker/realtime.mjs @@ -0,0 +1,284 @@ +/** Native gateway authentication, ticket admission and approved Realtime dispatch. */ +import { Buffer } from "node:buffer"; +import { createHash, scrypt, timingSafeEqual } from "node:crypto"; +import { activeUsersByPrefix, boundedBody, keyControlsPermit, validUser } from "./control-users-d1.mjs"; +import { lookupIntegrationPrincipal } from "./intelligence-auth-d1.mjs"; +import { authStorageBackend } from "./container-env.mjs"; +import { acquireAdmission, admissionSettings, principalHash } from "./admission-do.mjs"; +import { nativeRevisionConsumer, tickNativeRevisionSync } from "./native-config-sync.mjs"; +import { isRealtimeRequestPath } from "./api-paths.mjs"; +import { bridgeRealtime, REALTIME_TTL_MS } from "./realtime-session.mjs"; +import { createRealtimeMeter, realtimeCostPolicy, reserveRealtime, RealtimeError } from "./realtime-metering.mjs"; + +const MODEL = /^[a-z][a-z0-9-]{0,31}:[A-Za-z0-9][A-Za-z0-9._:/+@-]{0,191}$/; +const HASH = /^scrypt:32768:8:1\$([A-Za-z0-9]{8,32})\$([a-f0-9]{128})$/; +const KEYS = Object.freeze({ openai: ["OPENAI_API_KEY"], opencode: ["OPENCODE_GO_API_KEY", "OPENCODE_API_KEY"], + linkapi: ["LINKAPI_KEY", "LINKAPI_API_KEY"], "codex-easy": ["CODEX_EASY_API_KEY", "CODEX_API_KEY"], + nanogpt: ["NANOGPT_API_KEY"], openrouter: ["OPENROUTER_API_KEY"], groq: ["GROQ_API_KEY"], xai: ["XAI_API_KEY"] }); +const object = value => value !== null && typeof value === "object" && !Array.isArray(value); +const digest = value => createHash("sha256").update(String(value)).digest("hex"); +const same = (a, b) => Boolean(a && b) && timingSafeEqual(Buffer.from(digest(a), "hex"), Buffer.from(digest(b), "hex")); +const warned = new Set(); +function warn(name) { if (!warned.has(name)) { warned.add(name); console.warn(`Invalid ${name}; Realtime disabled`); } } +const identifier = () => crypto.randomUUID().replaceAll("-", ""); +let verifying = 0; + +export function realtimeSettings(env = {}) { + const flag = String(env.REALTIME_ENABLED ?? "").trim().toLowerCase(); + if (["", "false", "0", "off", "no"].includes(flag)) return { enabled: false }; + if (!["true", "1", "on", "yes"].includes(flag)) { warn("REALTIME_ENABLED"); return { enabled: false }; } + try { + const raw = String(env.REALTIME_PROVIDERS_JSON ?? "").trim(); if (raw.length > 65536) throw Error(); + const mapping = JSON.parse(raw || "{}"); + if (!object(mapping) || Object.keys(mapping).length > 256) throw Error(); + const providers = new Map(); + for (const [model, entry] of Object.entries(mapping)) { + if (!MODEL.test(model) || !Object.hasOwn(KEYS, model.split(":", 1)[0]) || !object(entry) + || Object.keys(entry).join() !== "url" || typeof entry.url !== "string" || entry.url.length > 2048) throw Error(); + const url = new URL(entry.url); + if (url.protocol !== "wss:" || url.username || url.password || url.hash || url.port && url.port !== "443" + || !/^[a-z0-9](?:[a-z0-9.-]*[a-z0-9])?$/.test(url.hostname) || !url.hostname.includes(".") + || /^[0-9.]+$/.test(url.hostname) || /(?:^|\.)(?:localhost|local|internal)$/.test(url.hostname) + || /[\x00-\x20\\]/.test(entry.url) + || [...url.searchParams.keys()].some(name => /^(?:api[-_]?key|access[-_]?token|token|authorization|secret|key)$/i.test(name))) throw Error(); + providers.set(model, url.href); + } + return { enabled: true, providers }; + } catch { warn("REALTIME_PROVIDERS_JSON"); return { enabled: false }; } +} +function bearer(request) { + const direct = request.headers.get("x-multillm-api-key")?.trim(); + return direct || /^Bearer\s+(.+)$/i.exec(request.headers.get("authorization") ?? "")?.[1].trim(); +} +async function checkHash(key, hash) { + const match = HASH.exec(hash ?? ""); if (!match) throw new RealtimeError("realtime_credential_unverifiable"); + if (verifying >= 2) throw new RealtimeError("realtime_auth_busy"); + verifying++; + try { + const derived = await new Promise((resolve, reject) => scrypt(key, match[1], 64, + { N: 32768, r: 8, p: 1, maxmem: 64 * 1024 * 1024 }, (error, value) => error ? reject(error) : resolve(value))); + return timingSafeEqual(derived, Buffer.from(match[2], "hex")); + } finally { verifying--; } +} +function modelGranted(patterns, model) { + if (patterns == null || patterns === "") return true; + if (typeof patterns !== "string") return false; + return patterns.split(",").some(pattern => new RegExp("^" + pattern.toLowerCase().split("*") + .map(part => part.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join(".*") + "$").test(model.toLowerCase())); +} +function permit(principal, request, model, now) { + if (!principal || principal.revoked_at || !keyControlsPermit(principal, request.headers.get("cf-connecting-ip"), now)) { + throw new RealtimeError("invalid_api_key", 401); + } + if (!principal.scopes.includes("chat") || !principal.scopes.includes("audio") || !modelGranted(principal.allowed_models, model)) { + throw new RealtimeError("model_not_granted", 403); + } + return principal; +} +function account(row) { + if (!validUser(row)) throw new RealtimeError("realtime_auth_unavailable"); + return { ...row, owner: row.username, scopes: row.scopes.split(",").map(value => value.trim()), + credential_kind: "account", credential_fingerprint: digest(row.api_key_hash) }; +} +function bootstrap(env) { + const owner = String(env.ADMIN_USERNAME ?? "admin").trim(); + if (!owner || owner.length > 128 || /[\x00-\x1f\x7f]/.test(owner)) throw new RealtimeError("realtime_auth_unavailable"); + return { owner, scopes: ["chat", "audio"], credential_kind: "bootstrap", credential_fingerprint: digest(env.ADMIN_API_KEY) }; +} +function integration(row) { + if (!row || !/^integration:[a-z][a-z0-9_-]{0,63}$/.test(row.id) || !Array.isArray(row.scopes) + || !row.scopes.every(scope => typeof scope === "string") || !HASH.test(row.keyHash) + || !Number.isSafeInteger(row.credentialVersion)) throw new RealtimeError("realtime_auth_unavailable"); + return { owner: row.id, scopes: row.scopes, revoked_at: row.revokedAt, + credential_kind: "integration", credential_fingerprint: digest(row.keyHash) }; +} +async function authenticate(request, env, model, now) { + const key = bearer(request); + if (!key || key.length > 1024) throw new RealtimeError("invalid_api_key", 401); + if (key.startsWith("rt1.")) return consumeTicket(key, request, env, model, now); + let principal; + if (same(key, env.ADMIN_API_KEY)) principal = bootstrap(env); + else if (/^mllm_intelligence_[A-Za-z0-9_-]{32,128}$/.test(key)) { + const row = await lookupIntegrationPrincipal(env.INTELLIGENCE_DB, key.slice(0, "mllm_intelligence_".length + 16)); + if (!row || !await checkHash(key, row.keyHash)) throw new RealtimeError("invalid_api_key", 401); + principal = integration(row); + } else if (authStorageBackend(env) === "d1") { + const rows = await activeUsersByPrefix(env.INTELLIGENCE_DB, `mllm_${key.slice(0, 8)}`); + if (rows.length > 8) throw new RealtimeError("realtime_auth_busy"); + for (const row of rows) { if (!validUser(row)) throw new RealtimeError("realtime_auth_unavailable"); + if (await checkHash(key, row.api_key_hash)) { principal = account(row); break; } } + } + if (!principal) throw new RealtimeError("invalid_api_key", 401); + principal.principal_hash = await principalHash(`realtime-key:${digest(key)}`); + return permit(principal, request, model, now); +} +async function signingKey(env) { + // Derive a domain-specific key from the existing gateway signing binding. + if (!env.JWT_SECRET) throw new RealtimeError("realtime_tickets_unavailable"); + return crypto.subtle.importKey("raw", new TextEncoder().encode(`multillm-realtime-ticket:v1:${env.JWT_SECRET}`), + { name: "HMAC", hash: "SHA-256" }, false, ["sign", "verify"]); +} +async function issueTicket(request, env, settings, now) { + if (request.headers.get("content-type")?.split(";", 1)[0].trim().toLowerCase() !== "application/json") throw new RealtimeError("invalid_request", 400); + let body; try { body = JSON.parse(await boundedBody(request, 4096)); } catch { throw new RealtimeError("invalid_request", 400); } + if (!object(body) || Object.keys(body).join() !== "model" || !settings.providers.has(body.model)) throw new RealtimeError("model_not_granted", 403); + // A ticket cannot mint a second generation of tickets. + if (bearer(request)?.startsWith("rt1.")) throw new RealtimeError("invalid_api_key", 401); + const principal = await authenticate(request, env, body.model, now), key = await signingKey(env); + const nonce = identifier(), expires = now + 60000; + const result = await env.INTELLIGENCE_DB.prepare(`INSERT INTO realtime_tickets + (nonce,principal_hash,owner,credential_kind,credential_fingerprint,model,expires_at) + SELECT ?,?,?,?,?,?,? WHERE (SELECT COUNT(*) FROM realtime_tickets WHERE principal_hash=? AND expires_at>? AND consumed_at IS NULL)<16`) + .bind(nonce, principal.principal_hash, principal.owner, principal.credential_kind, principal.credential_fingerprint, body.model, + expires, principal.principal_hash, now).run(); + if (result.meta.changes !== 1) throw new RealtimeError("realtime_ticket_limit", 429); + const payload = `rt1.${nonce}.${expires}`; + const signature = Buffer.from(await crypto.subtle.sign("HMAC", key, new TextEncoder().encode(payload))).toString("base64url"); + return Response.json({ value: `${payload}.${signature}`, expires_at: Math.floor(expires / 1000) }, { headers: { "cache-control": "no-store" } }); +} +async function consumeTicket(ticket, request, env, model, now) { + const match = /^(rt1\.([a-f0-9]{32})\.([0-9]{13}))\.([A-Za-z0-9_-]{43})$/.exec(ticket); + if (!match || Number(match[3]) <= now || Number(match[3]) > now + 60000 + || Buffer.from(match[4], "base64url").toString("base64url") !== match[4] + || !await crypto.subtle.verify("HMAC", await signingKey(env), Buffer.from(match[4], "base64url"), new TextEncoder().encode(match[1]))) { + throw new RealtimeError("invalid_api_key", 401); + } + const row = await env.INTELLIGENCE_DB.prepare("SELECT * FROM realtime_tickets WHERE nonce=?").bind(match[2]).first(); + if (!row || row.model !== model || row.consumed_at !== null || row.expires_at !== Number(match[3])) throw new RealtimeError("invalid_api_key", 401); + let principal; + if (row.credential_kind === "bootstrap") principal = bootstrap(env); + if (row.credential_kind === "account") { + const user = await env.INTELLIGENCE_DB.prepare("SELECT * FROM control_users WHERE username=? AND revoked_at IS NULL").bind(row.owner).first(); + if (user) principal = account(user); + } + if (row.credential_kind === "integration") { + const credential = await env.INTELLIGENCE_DB.prepare(`SELECT c.key_prefix FROM intelligence_credentials c + JOIN intelligence_principals p ON p.id=c.principal_id AND p.version=c.version WHERE p.id=? AND p.revoked_at IS NULL`).bind(row.owner).first(); + if (credential) principal = integration(await lookupIntegrationPrincipal(env.INTELLIGENCE_DB, credential.key_prefix)); + } + if (!principal || principal.owner !== row.owner || !same(principal.credential_fingerprint, row.credential_fingerprint)) throw new RealtimeError("invalid_api_key", 401); + permit(principal, request, model, now); + const consumed = await env.INTELLIGENCE_DB.prepare("UPDATE realtime_tickets SET consumed_at=? WHERE nonce=? AND consumed_at IS NULL AND expires_at>?") + .bind(now, match[2], now).run(); + if (consumed.meta.changes !== 1) throw new RealtimeError("invalid_api_key", 401); + return { ...principal, principal_hash: row.principal_hash }; +} +async function schemaReady(db) { + if (!db) throw new RealtimeError("realtime_storage_unavailable"); + try { + await db.prepare(`SELECT nonce,principal_hash,owner,credential_kind,credential_fingerprint,model,expires_at,consumed_at FROM realtime_tickets LIMIT 0`).all(); + await db.prepare(`SELECT id,principal_hash,owner,model,lease_id,created_at,expires_at,lease_until,state, + input_text_tokens,input_audio_tokens,output_text_tokens,output_audio_tokens,cost_usd,closed_at FROM realtime_sessions LIMIT 0`).all(); + await db.prepare("SELECT id,state,revision FROM usage_reservations LIMIT 0").all(); + await db.prepare("SELECT id FROM usage_events LIMIT 0").all(); + } catch { throw new RealtimeError("realtime_schema_missing"); } +} +async function admitSession(env, principal, model, sessionId, now) { + const result = await env.INTELLIGENCE_DB.prepare(`INSERT INTO realtime_sessions + (id,principal_hash,owner,model,created_at,expires_at,lease_until,state) + SELECT ?,?,?,?,?,?,?,'admitted' WHERE (SELECT COUNT(*) FROM realtime_sessions + WHERE principal_hash=? AND state IN ('admitted','active') AND lease_until>?)<2`) + .bind(sessionId, principal.principal_hash, principal.owner, model, now, now + REALTIME_TTL_MS, now + 30000, principal.principal_hash, now).run(); + if (result.meta.changes !== 1) throw new RealtimeError("realtime_session_limit", 429); +} +function upstreamHeaders(request, key) { + const headers = new Headers({ Upgrade: "websocket", Authorization: `Bearer ${key}` }); + const beta = request.headers.get("openai-beta"); + if (beta === "realtime=v1") headers.set("OpenAI-Beta", beta); + return headers; +} +async function openSession(request, env, ctx, settings, options) { + const params = new URL(request.url).searchParams, model = params.get("model"); + const now = options.timers?.now?.() ?? Date.now(); + if (!model || !MODEL.test(model)) throw new RealtimeError("invalid_model", 400); + const principal = await authenticate(request, env, model, now); + if (!settings.providers.has(model)) throw new RealtimeError("model_not_granted", 403); + if ([...params.keys()].some(name => name !== "model") || params.getAll("model").length !== 1) throw new RealtimeError("invalid_request", 400); + const policy = realtimeCostPolicy(env, model), provider = model.split(":", 1)[0]; + const key = KEYS[provider].map(name => env[name]).find(value => typeof value === "string" && value.trim()); + if (!key) throw new RealtimeError("realtime_provider_unavailable"); + const admission = admissionSettings(env); + if (!admission.enabled || !env.ADMISSION_COORDINATOR) throw new RealtimeError("realtime_admission_required"); + await schemaReady(env.INTELLIGENCE_DB); + const sessionId = identifier(), controller = new AbortController(); + let lease, reservation, bridge, socket, server, admitted = false, handedOff = false; + const abort = () => { controller.abort(); void bridge?.close(1008, true); }; + request.signal.addEventListener("abort", abort, { once: true }); + const setupTimeout = setTimeout(abort, 10000); setupTimeout.unref?.(); + const context = { principal: principal.owner, requestId: sessionId, provider, model: model.slice(provider.length + 1), endpoint: "/v1/realtime" }; + const finish = async (usage, code) => { + try { + const state = await reservation.finalize(usage, context, code === 1000 ? 200 : code === 1008 ? 499 : 502, ctx); + await env.INTELLIGENCE_DB.prepare(`UPDATE realtime_sessions SET state=?,input_text_tokens=?,input_audio_tokens=?, + output_text_tokens=?,output_audio_tokens=?,cost_usd=?,closed_at=? WHERE id=?`) + .bind(state === "settled" ? "settled" : "unknown", usage.input_text_tokens, usage.input_audio_tokens, + usage.output_text_tokens, usage.output_audio_tokens, usage.cost_usd, Date.now(), sessionId).run(); + } finally { request.signal.removeEventListener("abort", abort); } + }; + try { + await admitSession(env, principal, model, sessionId, now); admitted = true; + lease = await acquireAdmission({ principal_hash: await principalHash(principal.owner), model_group: model, + request_id: sessionId, deadline_ms: now + REALTIME_TTL_MS }, env, { onLost: abort }); + if (!lease) throw new RealtimeError("realtime_admission_required"); + reservation = await reserveRealtime(env, principal, policy, sessionId, now); + if (request.signal.aborted || controller.signal.aborted) throw new RealtimeError("realtime_canceled", 499); + await reservation.dispatch(); + if (request.signal.aborted || controller.signal.aborted) throw new RealtimeError("realtime_canceled", 499); + const url = new URL(settings.providers.get(model)); url.protocol = "https:"; + handedOff = true; + const response = await (options.dial ?? fetch)(url.href, { method: "GET", headers: upstreamHeaders(request, key), + redirect: "manual", signal: controller.signal }); + socket = response.webSocket; + if (response.status !== 101 || !socket) { void response.body?.cancel?.().catch(() => {}); throw new RealtimeError("realtime_upstream_error", 502); } + if (request.signal.aborted || controller.signal.aborted) throw new RealtimeError("realtime_canceled", 499); + lease.check(); + const pair = options.pair ? options.pair() : new WebSocketPair(); server = pair[1]; + await env.INTELLIGENCE_DB.prepare("UPDATE realtime_sessions SET state='active',lease_id=? WHERE id=?") + .bind(lease.value.lease_id, sessionId).run(); + socket.accept(); server.accept(); + bridge = bridgeRealtime(server, socket, { meter: createRealtimeMeter(policy), finalize: finish, secret: key, + signal: request.signal, timers: options.timers, lease, + heartbeat: async () => { const timestamp = options.timers?.now?.() ?? Date.now(); + const result = await env.INTELLIGENCE_DB.prepare(`UPDATE realtime_sessions SET lease_until=? WHERE id=? AND state='active' AND lease_until>?`) + .bind(Math.min(timestamp + 30000, now + REALTIME_TTL_MS), sessionId, timestamp).run(); + if (result.meta.changes !== 1) throw new RealtimeError("realtime_session_expired"); } }); + ctx?.waitUntil?.(bridge.done); + return options.upgradeResponse ? options.upgradeResponse(pair[0]) : new Response(null, { status: 101, webSocket: pair[0] }); + } catch (error) { + if (bridge) await bridge.close(1011, true); + else { + try { socket?.close(1011, "Realtime session closed"); server?.close(1011, "Realtime session closed"); } catch { /* Already closed. */ } + try { + if (reservation) await reservation.finalize({ input_tokens: null, output_tokens: null, cost_usd: null, cost_basis: null }, context, 502, ctx); + if (admitted) await env.INTELLIGENCE_DB.prepare("UPDATE realtime_sessions SET state=?,closed_at=? WHERE id=?") + .bind(handedOff ? "unknown" : "released", Date.now(), sessionId).run(); + } catch { console.warn("Realtime finalization unavailable; retain monetary hold"); } + await lease?.release(); request.signal.removeEventListener("abort", abort); + } + throw error; + } finally { clearTimeout(setupTimeout); } +} + +/** Null is the untouched legacy path; enabled routes never fall through to Container. */ +export async function handleRealtimeRequest(request, env, ctx, options = {}) { + if (!isRealtimeRequestPath(new URL(request.url).pathname)) return null; + const settings = realtimeSettings(env); if (!settings.enabled) return null; + try { + const url = new URL(request.url); + if (url.pathname === "/v1/realtime" && (request.method !== "GET" || request.headers.get("upgrade")?.trim().toLowerCase() !== "websocket")) { + throw new RealtimeError("websocket_upgrade_required", 426); + } + const rejection = nativeRevisionConsumer(env)?.requireFreshSecurity(); if (rejection) return rejection; + tickNativeRevisionSync(env, ctx); + if (url.pathname === "/v1/realtime/client_secrets" && request.method === "POST") { + await schemaReady(env.INTELLIGENCE_DB); + if (url.search) throw new RealtimeError("invalid_request", 400); + return await issueTicket(request, env, settings, options.timers?.now?.() ?? Date.now()); + } + if (url.pathname !== "/v1/realtime") throw new RealtimeError("not_found", 404); + return await openSession(request, env, ctx, settings, options); + } catch (error) { + if (error instanceof RealtimeError || typeof error?.response === "function") return error.response(); + return new RealtimeError("realtime_unavailable").response(); + } +}