@volter/twin-openrouter 0.1.0

package/dist/src/openrouter-twin.js

@@ -0,0 +1,1506 @@
+import { createHash } from 'node:crypto';
+import { applyTwinWrite, projectResources } from '@volter/world-core';
+import { OPENROUTER_MODELS, OPENROUTER_PROVIDERS, findOpenRouterModel } from "./openrouter-models.js";
+import { countPromptTokens, estimateTokens, firstToolCall, lastUserText, stableHash, stubAssistantText } from "./openrouter-stub.js";
+import { realizeOpenRouterRespond } from "./openrouter-scenario.js";
+const SERVICE = 'openrouter';
+const FIXED_NOW = '1970-01-01T00:00:00.000Z';
+function nowEpoch(occurredAt) {
+    return Math.floor(Date.parse(occurredAt ?? FIXED_NOW) / 1000);
+}
+function nowIso(occurredAt) {
+    return new Date(Date.parse(occurredAt ?? FIXED_NOW)).toISOString();
+}
+function parseJson(body) {
+    if (!body?.trim())
+        return {};
+    try {
+        const parsed = JSON.parse(body);
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+function error(status, code, message, type = 'invalid_request_error') {
+    return { status, body: { error: { message, type, code } } };
+}
+function apiPath(path) {
+    const url = new URL(path, 'http://twin.local');
+    return url.pathname.replace(/^\/api\/v1/, '/v1');
+}
+function rowsOfType(type, root) {
+    return projectResources(SERVICE, root)
+        .filter((r) => r.type === type)
+        .map((r) => {
+        const { type: _type, updatedAt: _updatedAt, ...rest } = r;
+        return rest;
+    });
+}
+function generationRows(root) {
+    return rowsOfType('generation', root);
+}
+function hasMessageContent(message) {
+    if (typeof message.content === 'string')
+        return message.content.length > 0;
+    if (Array.isArray(message.content))
+        return message.content.length > 0;
+    return message.tool_calls !== undefined;
+}
+function parseResponseFormat(raw) {
+    if (raw === undefined)
+        return { value: {} };
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+        return { error: error(400, 'invalid_response_format', 'response_format must be an object') };
+    }
+    const rf = raw;
+    if (rf.type !== 'json_object' && rf.type !== 'json_schema' && rf.type !== 'text') {
+        return { error: error(400, 'invalid_response_format', 'response_format.type must be one of text, json_object, json_schema') };
+    }
+    if (rf.type === 'json_schema') {
+        const schema = rf.json_schema;
+        if (!schema || typeof schema !== 'object' || typeof schema.name !== 'string') {
+            return { error: error(400, 'invalid_response_format', 'json_schema requires a json_schema.name') };
+        }
+    }
+    return { value: rf };
+}
+function parseReasoning(raw) {
+    if (raw === undefined)
+        return { value: {} };
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+        return { error: error(400, 'invalid_reasoning', 'reasoning must be an object') };
+    }
+    const r = raw;
+    if (r.effort !== undefined && !['low', 'medium', 'high', 'minimal'].includes(String(r.effort))) {
+        return { error: error(400, 'invalid_reasoning', 'reasoning.effort must be one of minimal, low, medium, high') };
+    }
+    if (r.max_tokens !== undefined && (!Number.isInteger(Number(r.max_tokens)) || Number(r.max_tokens) < 0)) {
+        return { error: error(400, 'invalid_reasoning', 'reasoning.max_tokens must be a non-negative integer') };
+    }
+    return {
+        value: {
+            ...(r.effort !== undefined ? { effort: String(r.effort) } : {}),
+            ...(r.max_tokens !== undefined ? { max_tokens: Number(r.max_tokens) } : {}),
+            ...(r.exclude !== undefined ? { exclude: r.exclude === true } : {}),
+            ...(r.enabled !== undefined ? { enabled: r.enabled === true } : {}),
+        },
+    };
+}
+function parseWebSearch(params) {
+    // OpenRouter enables web search via the `:online` model suffix, a `web` plugin entry, or `web_search_options`.
+    const plugins = Array.isArray(params.plugins) ? params.plugins : [];
+    const webPlugin = plugins.find((p) => p && typeof p === 'object' && p.id === 'web');
+    const opts = params.web_search_options && typeof params.web_search_options === 'object' ? params.web_search_options : undefined;
+    const online = typeof params.model === 'string' && params.model.endsWith(':online');
+    if (!webPlugin && !opts && !online)
+        return { value: undefined };
+    const rawMax = (webPlugin?.max_results ?? opts?.max_results);
+    const maxResults = rawMax === undefined ? 5 : Number(rawMax);
+    if (!Number.isInteger(maxResults) || maxResults < 1)
+        return { error: error(400, 'invalid_web_search', 'web search max_results must be an integer >= 1') };
+    const engine = typeof webPlugin?.engine === 'string' ? webPlugin.engine : 'native';
+    return { value: { maxResults, engine } };
+}
+// `transforms` is OpenRouter's prompt-transform list (e.g. "middle-out"). Validate it is an
+// array of known transform ids so the plumbing is faithful even though the stub doesn't reshape.
+const KNOWN_TRANSFORMS = ['middle-out'];
+function parseTransforms(raw) {
+    if (raw === undefined)
+        return { value: undefined };
+    if (!Array.isArray(raw))
+        return { error: error(400, 'invalid_transforms', 'transforms must be an array of transform ids') };
+    for (const t of raw) {
+        if (typeof t !== 'string' || !KNOWN_TRANSFORMS.includes(t)) {
+            return { error: error(400, 'invalid_transforms', `unknown transform: ${String(t)}`) };
+        }
+    }
+    return { value: raw };
+}
+function parseLogprobs(params) {
+    if (params.logprobs === undefined || params.logprobs === false)
+        return { value: undefined };
+    if (params.logprobs !== true)
+        return { error: error(400, 'invalid_logprobs', 'logprobs must be a boolean') };
+    const topRaw = params.top_logprobs;
+    const top = topRaw === undefined ? 0 : Number(topRaw);
+    if (!Number.isInteger(top) || top < 0 || top > 20) {
+        return { error: error(400, 'invalid_top_logprobs', 'top_logprobs must be an integer between 0 and 20') };
+    }
+    return { value: { topLogprobs: top } };
+}
+function parseModalities(raw) {
+    if (raw === undefined)
+        return { value: undefined };
+    if (!Array.isArray(raw) || raw.length === 0)
+        return { error: error(400, 'invalid_modalities', 'modalities must be a non-empty array') };
+    for (const m of raw) {
+        if (m !== 'text' && m !== 'image' && m !== 'audio')
+            return { error: error(400, 'invalid_modalities', `unsupported modality: ${String(m)}`) };
+    }
+    return { value: raw };
+}
+// cache_control on a message part marks a prefix for caching; the twin deterministically
+// reports those marked prompt tokens as cached on a (modeled) cache hit.
+function cachedPromptTokens(messages) {
+    let cached = 0;
+    for (const message of messages) {
+        const marked = message.cache_control !== undefined ||
+            (Array.isArray(message.content) && message.content.some((p) => p && typeof p === 'object' && 'cache_control' in p));
+        if (marked)
+            cached += estimateTokens(`${message.role}: ${typeof message.content === 'string' ? message.content : JSON.stringify(message.content)}`);
+    }
+    return cached;
+}
+function validateChat(params) {
+    let model = typeof params.model === 'string' && params.model ? params.model : 'openai/gpt-4o';
+    if (model.endsWith(':online'))
+        model = model.slice(0, -':online'.length);
+    if (!findOpenRouterModel(model))
+        return { response: error(404, 'not_found', `Model not found: ${model}`, 'not_found_error') };
+    if (!Array.isArray(params.messages) || params.messages.length === 0) {
+        return { response: error(400, 'invalid_messages', 'messages must be a non-empty array') };
+    }
+    for (const message of params.messages) {
+        if (!message || typeof message !== 'object' || typeof message.role !== 'string') {
+            return { response: error(400, 'invalid_message', 'each message must include a role') };
+        }
+        const role = message.role;
+        if (!['system', 'developer', 'user', 'assistant', 'tool'].includes(role)) {
+            return { response: error(400, 'invalid_message_role', `unsupported message role: ${role}`) };
+        }
+        if (!hasMessageContent(message)) {
+            return { response: error(400, 'invalid_message_content', 'each message must include content or tool_calls') };
+        }
+    }
+    const n = params.n === undefined ? 1 : Number(params.n);
+    if (!Number.isInteger(n) || n < 1)
+        return { response: error(400, 'invalid_n', 'n must be an integer >= 1') };
+    const rawMax = params.max_completion_tokens ?? params.max_tokens;
+    const maxTokens = rawMax === undefined ? undefined : Number(rawMax);
+    if (maxTokens !== undefined && (!Number.isInteger(maxTokens) || maxTokens < 1)) {
+        return { response: error(400, 'invalid_max_tokens', 'max_tokens must be an integer >= 1') };
+    }
+    const rf = parseResponseFormat(params.response_format);
+    if ('error' in rf)
+        return { response: rf.error };
+    const reasoning = parseReasoning(params.reasoning);
+    if ('error' in reasoning)
+        return { response: reasoning.error };
+    const web = parseWebSearch(params);
+    if ('error' in web)
+        return { response: web.error };
+    if (params.provider !== undefined && (!params.provider || typeof params.provider !== 'object' || Array.isArray(params.provider))) {
+        return { response: error(400, 'invalid_provider', 'provider preferences must be an object') };
+    }
+    const transforms = parseTransforms(params.transforms);
+    if ('error' in transforms)
+        return { response: transforms.error };
+    const logprobs = parseLogprobs(params);
+    if ('error' in logprobs)
+        return { response: logprobs.error };
+    const modalities = parseModalities(params.modalities);
+    if ('error' in modalities)
+        return { response: modalities.error };
+    const messages = params.messages;
+    const cached = cachedPromptTokens(messages);
+    return {
+        args: {
+            model,
+            messages,
+            n,
+            stream: params.stream === true,
+            ...(maxTokens !== undefined ? { maxTokens } : {}),
+            ...(params.tools !== undefined ? { tools: params.tools } : {}),
+            ...(Object.keys(rf.value).length ? { responseFormat: rf.value } : {}),
+            ...(Object.keys(reasoning.value).length ? { reasoning: reasoning.value } : {}),
+            ...(web.value ? { webSearch: web.value } : {}),
+            ...(params.provider !== undefined ? { provider: params.provider } : {}),
+            ...(cached > 0 ? { cachedTokens: cached } : {}),
+            ...(transforms.value ? { transforms: transforms.value } : {}),
+            ...(logprobs.value ? { logprobs: logprobs.value } : {}),
+            ...(modalities.value ? { modalities: modalities.value } : {}),
+        },
+    };
+}
+function reasoningTokens(args) {
+    if (!args.reasoning || args.reasoning.enabled === false)
+        return 0;
+    if (args.reasoning.max_tokens !== undefined)
+        return args.reasoning.max_tokens;
+    return { minimal: 4, low: 16, medium: 64, high: 256 }[args.reasoning.effort ?? 'medium'] ?? 64;
+}
+function schemaType(schema) {
+    const type = schema.type;
+    if (typeof type === 'string')
+        return type;
+    if (Array.isArray(type))
+        return type.find((item) => item !== 'null' && typeof item === 'string');
+    return undefined;
+}
+function schemaString(key) {
+    if (key.toLowerCase().includes('timestamp'))
+        return '2026-06-16T00:00:00.000Z';
+    if (key.toLowerCase().includes('url'))
+        return 'http://127.0.0.1/twin';
+    if (key.toLowerCase().includes('summary'))
+        return 'Twin structured-output stub completed the simulated QA session.';
+    if (key.toLowerCase().includes('description'))
+        return 'The tester completed a deterministic twin-simulated QA phase and reported that the page loaded successfully.';
+    if (key.toLowerCase().includes('feedback'))
+        return '';
+    return 'twin stub';
+}
+function synthesizeJsonSchemaValue(schema, key = 'value') {
+    if (!schema || typeof schema !== 'object' || Array.isArray(schema))
+        return {};
+    const s = schema;
+    if (Array.isArray(s.enum) && s.enum.length > 0)
+        return s.enum[0];
+    if (Array.isArray(s.const))
+        return s.const[0];
+    if (s.const !== undefined)
+        return s.const;
+    if (Array.isArray(s.anyOf) && s.anyOf.length > 0)
+        return synthesizeJsonSchemaValue(s.anyOf[0], key);
+    if (Array.isArray(s.oneOf) && s.oneOf.length > 0)
+        return synthesizeJsonSchemaValue(s.oneOf[0], key);
+    const type = schemaType(s);
+    if (type === 'object' || (!type && s.properties && typeof s.properties === 'object')) {
+        const out = {};
+        const props = (s.properties && typeof s.properties === 'object' && !Array.isArray(s.properties))
+            ? s.properties
+            : {};
+        for (const [propKey, propSchema] of Object.entries(props)) {
+            out[propKey] = synthesizeJsonSchemaValue(propSchema, propKey);
+        }
+        return out;
+    }
+    if (type === 'array')
+        return [];
+    if (type === 'string')
+        return schemaString(key);
+    if (type === 'number' || type === 'integer')
+        return 0;
+    if (type === 'boolean')
+        return true;
+    if (type === 'null')
+        return null;
+    return {};
+}
+function structuredJsonText(args) {
+    if (args.responseFormat?.type === 'json_schema') {
+        const jsonSchema = args.responseFormat.json_schema;
+        const schema = jsonSchema && typeof jsonSchema === 'object'
+            ? jsonSchema.schema
+            : undefined;
+        return JSON.stringify(synthesizeJsonSchemaValue(schema));
+    }
+    return JSON.stringify({ twin_stub: true, echo: lastUserText(args.messages) || 'empty prompt', model: args.model });
+}
+/** Resolve any scripted assistant turn for THIS generation request. Called exactly once per
+ *  request (never once per `n` choice, which would tick the engine's call counter n times);
+ *  a miss returns the teaching suffix the labeled stub carries, so an unmatched request says
+ *  where to author the handler instead of failing silently. */
+async function decideScripted(args, engine, signal) {
+    signal?.throwIfAborted();
+    if (!engine)
+        return { scripted: null, missTeach: '', matched: false };
+    const decision = await engine.serve({ model: args.model, messages: args.messages, ...(args.tools !== undefined ? { tools: args.tools } : {}) }, signal);
+    signal?.throwIfAborted();
+    if (decision.kind === 'fault')
+        return { scripted: null, missTeach: '', matched: true, fault: decision.result };
+    if (decision.kind === 'handler')
+        return { scripted: decision.respond === undefined ? null : realizeOpenRouterRespond(decision.respond), missTeach: '', matched: true };
+    return {
+        scripted: null,
+        matched: false,
+        missTeach: `\n[twin-scenario miss — no handler matched. Author one in the world dir's handlers/openrouter.json (GET /twin explains; GET /twin/scenario lists handlers + misses). Features seen: ${JSON.stringify(decision.miss.features)}]`,
+    };
+}
+/** A fired handler's assistant turn, in the OpenAI-shaped choice envelope OpenRouter serves. */
+function scriptedChoice(scripted, index) {
+    const message = scripted.toolCalls.length
+        ? { role: 'assistant', content: scripted.text, tool_calls: scripted.toolCalls }
+        : { role: 'assistant', content: scripted.text ?? '' };
+    return {
+        choice: { index, message, finish_reason: scripted.finishReason, native_finish_reason: scripted.finishReason },
+        completionTokens: estimateTokens(JSON.stringify(scripted.toolCalls.length ? scripted.toolCalls : scripted.text ?? '')),
+    };
+}
+function buildChoice(args, index) {
+    const tool = firstToolCall(args.tools);
+    const annotations = args.webSearch ? webSearchAnnotations(args) : undefined;
+    if (tool) {
+        return {
+            choice: {
+                index,
+                message: { role: 'assistant', content: null, tool_calls: [tool], ...(annotations ? { annotations } : {}) },
+                finish_reason: 'tool_calls',
+                native_finish_reason: 'tool_calls',
+            },
+            completionTokens: estimateTokens(JSON.stringify(tool)),
+        };
+    }
+    let text = stubAssistantText(args.messages, args.model);
+    if (args.responseFormat && (args.responseFormat.type === 'json_object' || args.responseFormat.type === 'json_schema')) {
+        text = structuredJsonText(args);
+    }
+    let finish = 'stop';
+    if (args.maxTokens !== undefined && estimateTokens(text) > args.maxTokens) {
+        text = text.slice(0, args.maxTokens * 4);
+        finish = 'length';
+    }
+    const message = { role: 'assistant', content: text };
+    if (annotations)
+        message.annotations = annotations;
+    const reasoned = reasoningTokens(args);
+    if (args.reasoning && reasoned > 0 && args.reasoning.exclude !== true) {
+        message.reasoning = `[twin-stub:openrouter:reasoning] deterministic reasoning trace for ${args.model}`;
+        message.reasoning_details = [{ type: 'reasoning.text', text: message.reasoning, format: 'unknown' }];
+    }
+    // Image output modality: attach a clearly-labeled deterministic stub image so the multimodal
+    // output envelope (message.images[]) is faithful without producing real pixels.
+    if (args.modalities?.includes('image')) {
+        message.images = [{
+                type: 'image_url',
+                image_url: { url: `data:image/png;base64,${Buffer.from(`[twin-stub:openrouter:image] ${args.model}`).toString('base64')}` },
+            }];
+    }
+    const choice = { index, message, finish_reason: finish, native_finish_reason: finish };
+    if (args.logprobs)
+        choice.logprobs = buildLogprobs(text, args.logprobs.topLogprobs);
+    return { choice, completionTokens: estimateTokens(text) };
+}
+// Deterministic logprobs: token-by-token with a stable pseudo-logprob and `top_logprobs`
+// alternatives, faithful to the OpenAI/OpenRouter `choices[].logprobs.content[]` shape.
+function buildLogprobs(text, topLogprobs) {
+    const tokens = text.match(/\S+\s*/g) ?? [text];
+    const content = tokens.map((tok) => {
+        const lp = -Number(((parseInt(stableHash(tok), 16) % 500) / 100 + 0.01).toFixed(4));
+        const top = Array.from({ length: topLogprobs }, (_u, i) => ({
+            token: i === 0 ? tok : `${tok}#${i}`,
+            logprob: Number((lp - i * 0.5).toFixed(4)),
+            bytes: Array.from(Buffer.from(tok)),
+        }));
+        return { token: tok, logprob: lp, bytes: Array.from(Buffer.from(tok)), top_logprobs: top };
+    });
+    return { content };
+}
+function webSearchAnnotations(args) {
+    const query = lastUserText(args.messages) || 'twin web search';
+    const count = Math.min(args.webSearch.maxResults, 3);
+    return Array.from({ length: count }, (_unused, i) => ({
+        type: 'url_citation',
+        url_citation: {
+            url: `https://twin.local/search?q=${encodeURIComponent(query)}&r=${i}`,
+            title: `[twin-stub:openrouter:web_search] result ${i + 1}`,
+            content: `Deterministic web-search stub result ${i + 1} via ${args.webSearch.engine} engine.`,
+            start_index: 0,
+            end_index: 0,
+        },
+    }));
+}
+async function recordGeneration(args, id, usage, root, occurredAt, streamed = false, finishReason = 'stop') {
+    const cost = Number(((usage.prompt_tokens * 0.0000005) + (usage.completion_tokens * 0.000003)).toFixed(8));
+    const stat = {
+        id: `generation_${id}`,
+        object: 'generation',
+        api_type: 'chat',
+        model: args.model,
+        provider_name: 'twin',
+        created_at: nowIso(occurredAt),
+        request_id: id,
+        finish_reason: finishReason,
+        native_finish_reason: finishReason,
+        total_cost: cost,
+        tokens_prompt: usage.prompt_tokens,
+        tokens_completion: usage.completion_tokens,
+        native_tokens_prompt: usage.prompt_tokens,
+        native_tokens_completion: usage.completion_tokens,
+        usage: cost,
+        app_id: null,
+        streamed,
+    };
+    await applyTwinWrite(SERVICE, {
+        operation: 'generation.record',
+        subjectType: 'generation',
+        subjectId: stat.id,
+        fields: stat,
+        occurredAt: occurredAt ?? FIXED_NOW,
+        actor: { kind: 'system' },
+    }, root);
+}
+async function chatCompletion(req, params, localGeneration) {
+    const validated = validateChat(params);
+    if ('response' in validated)
+        return validated.response;
+    const args = validated.args;
+    const choices = [];
+    let completionTokens = 0;
+    // Scenario handlers: a fired handler scripts the assistant turn; a miss teaches in the stub.
+    const { scripted, missTeach, matched, fault } = await decideScripted(args, req.scenarioEngine, req.signal);
+    if (fault)
+        return fault;
+    if (!matched && localGeneration)
+        return localGeneration();
+    for (let i = 0; i < args.n; i++) {
+        const built = scripted ? scriptedChoice(scripted, i) : buildChoice(args, i);
+        if (!scripted && missTeach) {
+            const message = built.choice.message;
+            if (typeof message.content === 'string')
+                message.content += missTeach;
+        }
+        choices.push(built.choice);
+        completionTokens += built.completionTokens;
+    }
+    const promptTokens = countPromptTokens(args.messages);
+    const cachedTokens = Math.min(args.cachedTokens ?? 0, promptTokens);
+    const usage = {
+        prompt_tokens: promptTokens,
+        completion_tokens: completionTokens,
+        total_tokens: promptTokens + completionTokens,
+    };
+    const reasoned = reasoningTokens(args);
+    const id = `chatcmpl-or-twin-${stableHash({ args, usage })}`;
+    const body = {
+        id,
+        object: 'chat.completion',
+        created: nowEpoch(req.occurredAt),
+        model: args.model,
+        choices,
+        usage: {
+            ...usage,
+            prompt_tokens_details: { cached_tokens: cachedTokens },
+            completion_tokens_details: { reasoning_tokens: reasoned },
+            cost: Number(((usage.prompt_tokens * 0.0000005) + (usage.completion_tokens * 0.000003)).toFixed(8)),
+        },
+        system_fingerprint: 'fp_openrouter_twin',
+    };
+    if (args.provider)
+        body.provider = 'twin';
+    if (args.transforms)
+        body.transforms = args.transforms;
+    req.signal?.throwIfAborted();
+    await recordGeneration(args, id, usage, req.root, req.occurredAt, args.stream, String(choices[0]?.finish_reason ?? 'stop'));
+    req.signal?.throwIfAborted();
+    if (args.stream && req.sseSink)
+        streamChat(body, req.sseSink);
+    return { status: 200, body };
+}
+function streamChat(body, sink) {
+    const base = { id: body.id, object: 'chat.completion.chunk', created: body.created, model: body.model, system_fingerprint: body.system_fingerprint };
+    sink({ data: { ...base, choices: [{ index: 0, delta: { role: 'assistant' }, finish_reason: null }] } });
+    const choice = body.choices[0];
+    if (choice.message.tool_calls) {
+        const call = choice.message.tool_calls[0];
+        sink({ data: { ...base, choices: [{ index: 0, delta: { tool_calls: [{ index: 0, id: call.id, type: 'function', function: { name: call.function.name } }] }, finish_reason: null }] } });
+        sink({ data: { ...base, choices: [{ index: 0, delta: { tool_calls: [{ index: 0, function: { arguments: call.function.arguments } }] }, finish_reason: null }] } });
+    }
+    else {
+        const text = String(choice.message.content ?? '');
+        for (let i = 0; i < text.length; i += 24) {
+            sink({ data: { ...base, choices: [{ index: 0, delta: { content: text.slice(i, i + 24) }, finish_reason: null }] } });
+        }
+    }
+    sink({ data: { ...base, choices: [{ index: 0, delta: {}, finish_reason: choice.finish_reason }], usage: body.usage } });
+    sink({ done: true });
+}
+function responsesInputToMessages(input) {
+    if (typeof input === 'string')
+        return [{ role: 'user', content: input }];
+    if (!Array.isArray(input))
+        return null;
+    const messages = [];
+    for (const item of input) {
+        if (!item || typeof item !== 'object')
+            return null;
+        const role = typeof item.role === 'string' ? item.role : 'user';
+        let content = item.content;
+        if (Array.isArray(content)) {
+            content = content.map((p) => (p && typeof p === 'object' && 'text' in p ? String(p.text ?? '') : '')).join(' ').trim();
+        }
+        messages.push({ role, content });
+    }
+    return messages.length ? messages : null;
+}
+async function createResponse(req, params, localGeneration) {
+    const model = typeof params.model === 'string' && params.model ? params.model : 'openai/gpt-4o';
+    if (!findOpenRouterModel(model.replace(/:online$/, '')))
+        return error(404, 'not_found', `Model not found: ${model}`, 'not_found_error');
+    if (params.input === undefined && params.messages === undefined)
+        return error(400, 'invalid_input', 'input is required');
+    const messages = responsesInputToMessages(params.input ?? params.messages);
+    if (!messages)
+        return error(400, 'invalid_input', 'input could not be parsed into messages');
+    const reasoning = parseReasoning(params.reasoning);
+    if ('error' in reasoning)
+        return reasoning.error;
+    const web = parseWebSearch({ ...params, plugins: params.plugins, web_search_options: params.web_search_options });
+    if ('error' in web)
+        return web.error;
+    const tools = Array.isArray(params.tools) ? params.tools : undefined;
+    const args = {
+        model: model.replace(/:online$/, ''),
+        messages,
+        n: 1,
+        stream: false,
+        ...(tools ? { tools } : {}),
+        ...(Object.keys(reasoning.value).length ? { reasoning: reasoning.value } : {}),
+        ...(web.value ? { webSearch: web.value } : {}),
+    };
+    const { scripted, missTeach, matched, fault } = await decideScripted(args, req.scenarioEngine, req.signal);
+    if (fault)
+        return fault;
+    if (!matched && localGeneration)
+        return localGeneration();
+    const built = scripted ? scriptedChoice(scripted, 0) : buildChoice(args, 0);
+    const msg = built.choice.message;
+    if (!scripted && missTeach && typeof msg.content === 'string')
+        msg.content += missTeach;
+    const promptTokens = countPromptTokens(messages);
+    const reasoned = reasoningTokens(args);
+    const id = `resp_or_twin_${stableHash({ args })}`;
+    const output = [];
+    if (msg.reasoning) {
+        output.push({ id: `rs_${stableHash(msg.reasoning).slice(0, 8)}`, type: 'reasoning', summary: [{ type: 'summary_text', text: msg.reasoning }] });
+    }
+    if (msg.tool_calls) {
+        const call = msg.tool_calls[0];
+        output.push({ id: `fc_${call.id}`, type: 'function_call', call_id: call.id, name: call.function.name, arguments: call.function.arguments, status: 'completed' });
+    }
+    else {
+        output.push({
+            id: `msg_${stableHash(String(msg.content)).slice(0, 8)}`,
+            type: 'message',
+            role: 'assistant',
+            status: 'completed',
+            content: [{ type: 'output_text', text: String(msg.content ?? ''), annotations: msg.annotations ?? [] }],
+        });
+    }
+    const status = built.choice.finish_reason === 'tool_calls' ? 'completed' : 'completed';
+    const body = {
+        id,
+        object: 'response',
+        created_at: nowEpoch(req.occurredAt),
+        status,
+        model: args.model,
+        output,
+        output_text: msg.tool_calls ? '' : String(msg.content ?? ''),
+        usage: {
+            input_tokens: promptTokens,
+            output_tokens: built.completionTokens,
+            total_tokens: promptTokens + built.completionTokens,
+            output_tokens_details: { reasoning_tokens: reasoned },
+        },
+        system_fingerprint: 'fp_openrouter_twin',
+    };
+    req.signal?.throwIfAborted();
+    return { status: 200, body };
+}
+// ── Embeddings ──────────────────────────────────────────────────────────────
+const EMBED_DIM = 8;
+function embedVector(text) {
+    // Deterministic pseudo-embedding seeded from the text hash; L2-normalized.
+    const seed = parseInt(stableHash(text), 16) || 1;
+    let x = seed;
+    const raw = Array.from({ length: EMBED_DIM }, () => {
+        x = (Math.imul(x, 1103515245) + 12345) & 0x7fffffff;
+        return (x / 0x7fffffff) * 2 - 1;
+    });
+    const norm = Math.sqrt(raw.reduce((s, v) => s + v * v, 0)) || 1;
+    return raw.map((v) => Number((v / norm).toFixed(6)));
+}
+function createEmbeddings(req, params) {
+    const model = typeof params.model === 'string' && params.model ? params.model : 'openai/text-embedding-3-small';
+    if (params.input === undefined)
+        return error(400, 'invalid_input', 'input is required');
+    const inputs = Array.isArray(params.input) ? params.input : [params.input];
+    if (inputs.length === 0)
+        return error(400, 'invalid_input', 'input must be a non-empty string or array');
+    for (const i of inputs)
+        if (typeof i !== 'string')
+            return error(400, 'invalid_input', 'each embedding input must be a string');
+    const data = inputs.map((text, index) => ({ object: 'embedding', index, embedding: embedVector(text) }));
+    const promptTokens = inputs.reduce((s, t) => s + estimateTokens(t), 0);
+    return {
+        status: 200,
+        body: { object: 'list', data, model, usage: { prompt_tokens: promptTokens, total_tokens: promptTokens } },
+    };
+}
+// ── Anthropic Messages compatibility ─────────────────────────────────────────
+function anthropicContentToText(content) {
+    if (typeof content === 'string')
+        return content;
+    if (Array.isArray(content)) {
+        return content.map((p) => (p && typeof p === 'object' && p.type === 'text' ? String(p.text ?? '') : '')).filter(Boolean).join(' ');
+    }
+    return '';
+}
+function anthropicMessages(req, params) {
+    const model = typeof params.model === 'string' && params.model ? params.model : 'anthropic/claude-sonnet-4.5';
+    if (!findOpenRouterModel(model))
+        return error(404, 'not_found', `Model not found: ${model}`, 'not_found_error');
+    if (!Array.isArray(params.messages) || params.messages.length === 0)
+        return error(400, 'invalid_messages', 'messages must be a non-empty array');
+    if (params.max_tokens === undefined)
+        return error(400, 'invalid_max_tokens', 'max_tokens is required for the Anthropic Messages API');
+    const messages = params.messages.map((m) => ({ role: String(m.role ?? 'user'), content: anthropicContentToText(m.content) }));
+    if (typeof params.system === 'string' && params.system)
+        messages.unshift({ role: 'system', content: params.system });
+    const text = stubAssistantText(messages, model);
+    const inputTokens = countPromptTokens(messages);
+    const outputTokens = estimateTokens(text);
+    return {
+        status: 200,
+        body: {
+            id: `msg_or_twin_${stableHash({ model, messages }).slice(0, 12)}`,
+            type: 'message',
+            role: 'assistant',
+            model,
+            content: [{ type: 'text', text }],
+            stop_reason: 'end_turn',
+            stop_sequence: null,
+            usage: { input_tokens: inputTokens, output_tokens: outputTokens },
+        },
+    };
+}
+// ── Rerank ───────────────────────────────────────────────────────────────────
+function rerank(req, params) {
+    const model = typeof params.model === 'string' && params.model ? params.model : 'twin/rerank-1';
+    if (typeof params.query !== 'string' || !params.query)
+        return error(400, 'invalid_query', 'query is required');
+    if (!Array.isArray(params.documents) || params.documents.length === 0)
+        return error(400, 'invalid_documents', 'documents must be a non-empty array');
+    for (const d of params.documents)
+        if (typeof d !== 'string')
+            return error(400, 'invalid_documents', 'each document must be a string');
+    const topN = params.top_n === undefined ? params.documents.length : Number(params.top_n);
+    if (!Number.isInteger(topN) || topN < 1)
+        return error(400, 'invalid_top_n', 'top_n must be an integer >= 1');
+    const queryTokens = new Set(params.query.toLowerCase().split(/\W+/).filter(Boolean));
+    const scored = params.documents.map((doc, index) => {
+        const docTokens = doc.toLowerCase().split(/\W+/).filter(Boolean);
+        const overlap = docTokens.filter((t) => queryTokens.has(t)).length;
+        const score = Number((overlap / Math.max(1, docTokens.length)).toFixed(6));
+        return { index, relevance_score: score, document: { text: doc } };
+    });
+    scored.sort((a, b) => b.relevance_score - a.relevance_score || a.index - b.index);
+    return { status: 200, body: { id: `rerank_or_twin_${stableHash(params).slice(0, 10)}`, model, results: scored.slice(0, topN) } };
+}
+// ── Generic CRUD resource families (api keys, byok, presets) ─────────────────
+function genId(prefix, seed) {
+    return `${prefix}-${stableHash(seed).slice(0, 12)}`;
+}
+async function createApiKey(req, params) {
+    if (typeof params.name !== 'string' || !params.name)
+        return error(400, 'invalid_name', 'name is required');
+    const hash = genId('hash', { name: params.name, at: req.occurredAt });
+    const limit = params.limit === undefined ? null : Number(params.limit);
+    if (limit !== null && (!Number.isFinite(limit) || limit < 0))
+        return error(400, 'invalid_limit', 'limit must be a non-negative number');
+    const key = {
+        id: `key_${hash}`,
+        hash,
+        name: params.name,
+        label: `sk-or-v1-...${hash.slice(-4)}`,
+        disabled: false,
+        limit,
+        usage: 0,
+        created_at: nowIso(req.occurredAt),
+        updated_at: nowIso(req.occurredAt),
+        ...(typeof params.include_byok_in_limit === 'boolean' ? { include_byok_in_limit: params.include_byok_in_limit } : { include_byok_in_limit: false }),
+    };
+    await applyTwinWrite(SERVICE, { operation: 'api_key.create', subjectType: 'api_key', subjectId: key.id, fields: key, occurredAt: req.occurredAt ?? FIXED_NOW, actor: { kind: 'system' } }, req.root);
+    return { status: 200, body: { data: { ...stripPrefix(key), key: `sk-or-v1-twin-${hash}` } } };
+}
+function stripPrefix(row) {
+    return { ...row, id: String(row.id).replace(/^[a-z_]+_/, '') };
+}
+function listApiKeys(req) {
+    return { status: 200, body: { data: rowsOfType('api_key', req.root).filter((r) => !r.deleted).map(stripPrefix) } };
+}
+async function updateApiKey(req, hash, params, del) {
+    const row = rowsOfType('api_key', req.root).find((r) => r.hash === hash || String(r.id) === `key_${hash}`);
+    if (!row)
+        return error(404, 'not_found', 'API key not found', 'not_found_error');
+    if (del) {
+        await applyTwinWrite(SERVICE, { operation: 'api_key.delete', subjectType: 'api_key', subjectId: String(row.id), fields: { disabled: true, deleted: true }, occurredAt: req.occurredAt ?? FIXED_NOW, actor: { kind: 'system' } }, req.root);
+        return { status: 200, body: { data: { ...stripPrefix({ ...row, disabled: true }), deleted: true } } };
+    }
+    const patch = { updated_at: nowIso(req.occurredAt) };
+    if (typeof params.name === 'string')
+        patch.name = params.name;
+    if (typeof params.disabled === 'boolean')
+        patch.disabled = params.disabled;
+    if (params.limit !== undefined)
+        patch.limit = params.limit === null ? null : Number(params.limit);
+    await applyTwinWrite(SERVICE, { operation: 'api_key.update', subjectType: 'api_key', subjectId: String(row.id), fields: patch, occurredAt: req.occurredAt ?? FIXED_NOW, actor: { kind: 'system' } }, req.root);
+    return { status: 200, body: { data: stripPrefix({ ...row, ...patch }) } };
+}
+async function createByok(req, params) {
+    if (typeof params.provider_name !== 'string' || !params.provider_name)
+        return error(400, 'invalid_provider_name', 'provider_name is required');
+    if (typeof params.api_key !== 'string' || !params.api_key)
+        return error(400, 'invalid_api_key', 'api_key is required');
+    if (!OPENROUTER_PROVIDERS.some((p) => p.slug === params.provider_name))
+        return error(400, 'unknown_provider', `unknown provider: ${params.provider_name}`);
+    const id = `byok_${genId('cred', { p: params.provider_name, at: req.occurredAt })}`;
+    const row = {
+        id,
+        provider_name: params.provider_name,
+        enabled: params.enabled === undefined ? true : params.enabled === true,
+        api_key_preview: `...${String(params.api_key).slice(-4)}`,
+        created_at: nowIso(req.occurredAt),
+        updated_at: nowIso(req.occurredAt),
+    };
+    await applyTwinWrite(SERVICE, { operation: 'byok.create', subjectType: 'byok', subjectId: id, fields: row, occurredAt: req.occurredAt ?? FIXED_NOW, actor: { kind: 'system' } }, req.root);
+    return { status: 200, body: { data: stripPrefix(row) } };
+}
+function listByok(req) {
+    return { status: 200, body: { data: rowsOfType('byok', req.root).filter((r) => !r.deleted).map(stripPrefix) } };
+}
+async function updateByok(req, provider, params, del) {
+    const row = rowsOfType('byok', req.root).find((r) => r.provider_name === provider && !r.deleted);
+    if (!row)
+        return error(404, 'not_found', 'BYOK credential not found', 'not_found_error');
+    if (del) {
+        await applyTwinWrite(SERVICE, { operation: 'byok.delete', subjectType: 'byok', subjectId: String(row.id), fields: { deleted: true, enabled: false }, occurredAt: req.occurredAt ?? FIXED_NOW, actor: { kind: 'system' } }, req.root);
+        return { status: 200, body: { data: { deleted: true, provider_name: provider } } };
+    }
+    const patch = { updated_at: nowIso(req.occurredAt) };
+    if (typeof params.enabled === 'boolean')
+        patch.enabled = params.enabled;
+    if (typeof params.api_key === 'string' && params.api_key)
+        patch.api_key_preview = `...${params.api_key.slice(-4)}`;
+    await applyTwinWrite(SERVICE, { operation: 'byok.update', subjectType: 'byok', subjectId: String(row.id), fields: patch, occurredAt: req.occurredAt ?? FIXED_NOW, actor: { kind: 'system' } }, req.root);
+    return { status: 200, body: { data: stripPrefix({ ...row, ...patch }) } };
+}
+async function createPreset(req, params) {
+    if (typeof params.name !== 'string' || !params.name)
+        return error(400, 'invalid_name', 'name is required');
+    const model = typeof params.model === 'string' ? params.model : 'openai/gpt-4o';
+    if (!findOpenRouterModel(model.replace(/:online$/, '')))
+        return error(404, 'not_found', `Model not found: ${model}`, 'not_found_error');
+    const id = `preset_${genId('preset', { name: params.name, at: req.occurredAt })}`;
+    const row = {
+        id,
+        name: params.name,
+        slug: String(params.name).toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, ''),
+        description: typeof params.description === 'string' ? params.description : '',
+        model,
+        parameters: params.parameters && typeof params.parameters === 'object' ? params.parameters : {},
+        source: 'chat',
+        created_at: nowIso(req.occurredAt),
+        updated_at: nowIso(req.occurredAt),
+    };
+    await applyTwinWrite(SERVICE, { operation: 'preset.create', subjectType: 'preset', subjectId: id, fields: row, occurredAt: req.occurredAt ?? FIXED_NOW, actor: { kind: 'system' } }, req.root);
+    return { status: 200, body: { data: stripPrefix(row) } };
+}
+function listPresets(req) {
+    return { status: 200, body: { data: rowsOfType('preset', req.root).map(stripPrefix) } };
+}
+function getPreset(req, slug) {
+    const row = rowsOfType('preset', req.root).find((r) => r.slug === slug || String(r.id) === `preset_${slug}`);
+    return row ? { status: 200, body: { data: stripPrefix(row) } } : error(404, 'not_found', 'Preset not found', 'not_found_error');
+}
+async function createPresetFromResponses(req, params) {
+    if (typeof params.name !== 'string' || !params.name)
+        return error(400, 'invalid_name', 'name is required');
+    const model = typeof params.model === 'string' ? params.model : 'openai/gpt-4o';
+    if (!findOpenRouterModel(model.replace(/:online$/, '')))
+        return error(404, 'not_found', `Model not found: ${model}`, 'not_found_error');
+    const id = `preset_${genId('preset', { name: params.name, src: 'responses', at: req.occurredAt })}`;
+    const row = {
+        id,
+        name: params.name,
+        slug: String(params.name).toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, ''),
+        description: typeof params.description === 'string' ? params.description : '',
+        model,
+        parameters: params.parameters && typeof params.parameters === 'object' ? params.parameters : {},
+        source: 'responses',
+        created_at: nowIso(req.occurredAt),
+        updated_at: nowIso(req.occurredAt),
+    };
+    await applyTwinWrite(SERVICE, { operation: 'preset.create', subjectType: 'preset', subjectId: id, fields: row, occurredAt: req.occurredAt ?? FIXED_NOW, actor: { kind: 'system' } }, req.root);
+    return { status: 200, body: { data: stripPrefix(row) } };
+}
+// ── Files ─────────────────────────────────────────────────────────────────────
+async function uploadFile(req, params) {
+    const filename = typeof params.filename === 'string' && params.filename ? params.filename : undefined;
+    if (!filename)
+        return error(400, 'invalid_filename', 'filename is required');
+    const purpose = typeof params.purpose === 'string' && params.purpose ? params.purpose : 'user_data';
+    if (!['user_data', 'fine-tune', 'assistants', 'batch', 'vision'].includes(purpose)) {
+        return error(400, 'invalid_purpose', `unsupported purpose: ${purpose}`);
+    }
+    const content = typeof params.content === 'string' ? params.content : '';
+    const id = `file_${genId('file', { filename, at: req.occurredAt, content })}`;
+    const row = {
+        id,
+        object: 'file',
+        filename,
+        purpose,
+        bytes: Buffer.byteLength(content, 'utf8'),
+        created_at: nowEpoch(req.occurredAt),
+        status: 'processed',
+    };
+    await applyTwinWrite(SERVICE, { operation: 'file.upload', subjectType: 'file', subjectId: id, fields: row, occurredAt: req.occurredAt ?? FIXED_NOW, actor: { kind: 'system' } }, req.root);
+    return { status: 200, body: stripPrefix(row) };
+}
+function listFiles(req) {
+    return { status: 200, body: { object: 'list', data: rowsOfType('file', req.root).filter((r) => !r.deleted).map(stripPrefix) } };
+}
+function getFile(req, fileId) {
+    const row = rowsOfType('file', req.root).find((r) => String(r.id) === `file_${fileId}` && !r.deleted);
+    return row ? { status: 200, body: stripPrefix(row) } : error(404, 'not_found', 'File not found', 'not_found_error');
+}
+async function deleteFile(req, fileId) {
+    const row = rowsOfType('file', req.root).find((r) => String(r.id) === `file_${fileId}` && !r.deleted);
+    if (!row)
+        return error(404, 'not_found', 'File not found', 'not_found_error');
+    await applyTwinWrite(SERVICE, { operation: 'file.delete', subjectType: 'file', subjectId: String(row.id), fields: { deleted: true }, occurredAt: req.occurredAt ?? FIXED_NOW, actor: { kind: 'system' } }, req.root);
+    return { status: 200, body: { id: fileId, object: 'file', deleted: true } };
+}
+// ── OAuth (PKCE) ───────────────────────────────────────────────────────────────
+// OpenRouter's OAuth PKCE flow: the app sends the user to /auth?callback_url&code_challenge,
+// the user approves, OpenRouter redirects back with a `code`, and the app POSTs the code to
+// /api/v1/auth/keys with the code_verifier to exchange it for a real API key.
+function base64url(input) {
+    return input.toString('base64').replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+}
+async function oauthAuthorize(req, params) {
+    const callback = typeof params.callback_url === 'string' && params.callback_url ? params.callback_url : undefined;
+    if (!callback)
+        return error(400, 'invalid_callback_url', 'callback_url is required');
+    const challenge = typeof params.code_challenge === 'string' ? params.code_challenge : undefined;
+    if (!challenge)
+        return error(400, 'invalid_code_challenge', 'code_challenge is required');
+    const method = typeof params.code_challenge_method === 'string' ? params.code_challenge_method : 'S256';
+    if (!['S256', 'plain'].includes(method))
+        return error(400, 'invalid_code_challenge_method', 'code_challenge_method must be S256 or plain');
+    const code = genId('orc', { challenge, callback, at: req.occurredAt });
+    const row = {
+        id: `oauthcode_${code}`,
+        code,
+        code_challenge: challenge,
+        code_challenge_method: method,
+        callback_url: callback,
+        consumed: false,
+        created_at: nowIso(req.occurredAt),
+    };
+    await applyTwinWrite(SERVICE, { operation: 'oauth_code.create', subjectType: 'oauth_code', subjectId: row.id, fields: row, occurredAt: req.occurredAt ?? FIXED_NOW, actor: { kind: 'system' } }, req.root);
+    const redirect = `${callback}${callback.includes('?') ? '&' : '?'}code=${code}`;
+    return { status: 200, body: { data: { code, redirect_url: redirect } } };
+}
+async function oauthExchange(req, params) {
+    const code = typeof params.code === 'string' ? params.code : undefined;
+    if (!code)
+        return error(400, 'invalid_code', 'code is required');
+    const verifier = typeof params.code_verifier === 'string' ? params.code_verifier : undefined;
+    const row = rowsOfType('oauth_code', req.root).find((r) => r.code === code);
+    if (!row)
+        return error(400, 'invalid_code', 'authorization code not found', 'invalid_request_error');
+    if (row.consumed)
+        return error(400, 'code_already_used', 'authorization code already exchanged');
+    const method = row.code_challenge_method ?? 'S256';
+    if (row.code_challenge) {
+        if (!verifier)
+            return error(400, 'invalid_code_verifier', 'code_verifier is required');
+        const computed = method === 'plain' ? verifier : base64url(createHash('sha256').update(verifier).digest());
+        if (computed !== row.code_challenge)
+            return error(400, 'invalid_code_verifier', 'code_verifier does not match code_challenge');
+    }
+    const keyHash = genId('hash', { code, at: req.occurredAt });
+    const key = {
+        id: `key_${keyHash}`,
+        hash: keyHash,
+        name: 'OAuth provisioned key',
+        label: `sk-or-v1-...${keyHash.slice(-4)}`,
+        disabled: false,
+        limit: null,
+        usage: 0,
+        include_byok_in_limit: false,
+        created_at: nowIso(req.occurredAt),
+        updated_at: nowIso(req.occurredAt),
+    };
+    await applyTwinWrite(SERVICE, { operation: 'api_key.create', subjectType: 'api_key', subjectId: key.id, fields: key, occurredAt: req.occurredAt ?? FIXED_NOW, actor: { kind: 'system' } }, req.root);
+    await applyTwinWrite(SERVICE, { operation: 'oauth_code.consume', subjectType: 'oauth_code', subjectId: String(row.id), fields: { consumed: true }, occurredAt: req.occurredAt ?? FIXED_NOW, actor: { kind: 'system' } }, req.root);
+    return { status: 200, body: { key: `sk-or-v1-twin-${keyHash}`, user_id: 'user_twin' } };
+}
+// ── Guardrails ─────────────────────────────────────────────────────────────────
+async function createGuardrail(req, params) {
+    if (typeof params.name !== 'string' || !params.name)
+        return error(400, 'invalid_name', 'name is required');
+    const id = `guardrail_${genId('gr', { name: params.name, at: req.occurredAt })}`;
+    const row = {
+        id,
+        name: params.name,
+        description: typeof params.description === 'string' ? params.description : '',
+        enabled: params.enabled === undefined ? true : params.enabled === true,
+        rules: Array.isArray(params.rules) ? params.rules : [],
+        created_at: nowIso(req.occurredAt),
+        updated_at: nowIso(req.occurredAt),
+    };
+    await applyTwinWrite(SERVICE, { operation: 'guardrail.create', subjectType: 'guardrail', subjectId: id, fields: row, occurredAt: req.occurredAt ?? FIXED_NOW, actor: { kind: 'system' } }, req.root);
+    return { status: 200, body: { data: stripPrefix(row) } };
+}
+function listGuardrails(req) {
+    return { status: 200, body: { data: rowsOfType('guardrail', req.root).filter((r) => !r.deleted).map(stripPrefix) } };
+}
+function getGuardrail(req, id) {
+    const row = rowsOfType('guardrail', req.root).find((r) => String(r.id) === `guardrail_${id}` && !r.deleted);
+    return row ? { status: 200, body: { data: stripPrefix(row) } } : error(404, 'not_found', 'Guardrail not found', 'not_found_error');
+}
+async function updateGuardrail(req, id, params, del) {
+    const row = rowsOfType('guardrail', req.root).find((r) => String(r.id) === `guardrail_${id}` && !r.deleted);
+    if (!row)
+        return error(404, 'not_found', 'Guardrail not found', 'not_found_error');
+    if (del) {
+        await applyTwinWrite(SERVICE, { operation: 'guardrail.delete', subjectType: 'guardrail', subjectId: String(row.id), fields: { deleted: true }, occurredAt: req.occurredAt ?? FIXED_NOW, actor: { kind: 'system' } }, req.root);
+        return { status: 200, body: { data: { id, deleted: true } } };
+    }
+    const patch = { updated_at: nowIso(req.occurredAt) };
+    if (typeof params.name === 'string')
+        patch.name = params.name;
+    if (typeof params.description === 'string')
+        patch.description = params.description;
+    if (typeof params.enabled === 'boolean')
+        patch.enabled = params.enabled;
+    if (Array.isArray(params.rules))
+        patch.rules = params.rules;
+    await applyTwinWrite(SERVICE, { operation: 'guardrail.update', subjectType: 'guardrail', subjectId: String(row.id), fields: patch, occurredAt: req.occurredAt ?? FIXED_NOW, actor: { kind: 'system' } }, req.root);
+    return { status: 200, body: { data: stripPrefix({ ...row, ...patch }) } };
+}
+async function setGuardrailAssignments(req, id, params) {
+    const row = rowsOfType('guardrail', req.root).find((r) => String(r.id) === `guardrail_${id}` && !r.deleted);
+    if (!row)
+        return error(404, 'not_found', 'Guardrail not found', 'not_found_error');
+    const keyHashes = Array.isArray(params.key_hashes) ? params.key_hashes.map(String) : undefined;
+    if (!keyHashes)
+        return error(400, 'invalid_assignments', 'key_hashes must be an array');
+    await applyTwinWrite(SERVICE, { operation: 'guardrail.assign', subjectType: 'guardrail', subjectId: String(row.id), fields: { key_hashes: keyHashes, updated_at: nowIso(req.occurredAt) }, occurredAt: req.occurredAt ?? FIXED_NOW, actor: { kind: 'system' } }, req.root);
+    return { status: 200, body: { data: { id, key_hashes: keyHashes } } };
+}
+function getGuardrailAssignments(req, id) {
+    const row = rowsOfType('guardrail', req.root).find((r) => String(r.id) === `guardrail_${id}` && !r.deleted);
+    if (!row)
+        return error(404, 'not_found', 'Guardrail not found', 'not_found_error');
+    return { status: 200, body: { data: { id, key_hashes: Array.isArray(row.key_hashes) ? row.key_hashes : [] } } };
+}
+// ── Organization members ───────────────────────────────────────────────────────
+const ORG_MEMBERS = [
+    { id: 'user_twin_owner', name: 'Twin Owner', email: 'owner@twin.local', role: 'owner' },
+    { id: 'user_twin_admin', name: 'Twin Admin', email: 'admin@twin.local', role: 'admin' },
+    { id: 'user_twin_member', name: 'Twin Member', email: 'member@twin.local', role: 'member' },
+];
+function listOrgMembers() {
+    return { status: 200, body: { data: ORG_MEMBERS } };
+}
+// ── Workspaces ─────────────────────────────────────────────────────────────────
+async function createWorkspace(req, params) {
+    if (typeof params.name !== 'string' || !params.name)
+        return error(400, 'invalid_name', 'name is required');
+    const id = `workspace_${genId('ws', { name: params.name, at: req.occurredAt })}`;
+    const row = {
+        id,
+        name: params.name,
+        slug: String(params.name).toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, ''),
+        description: typeof params.description === 'string' ? params.description : '',
+        members: [],
+        created_at: nowIso(req.occurredAt),
+        updated_at: nowIso(req.occurredAt),
+    };
+    await applyTwinWrite(SERVICE, { operation: 'workspace.create', subjectType: 'workspace', subjectId: id, fields: row, occurredAt: req.occurredAt ?? FIXED_NOW, actor: { kind: 'system' } }, req.root);
+    return { status: 200, body: { data: stripPrefix(row) } };
+}
+function listWorkspaces(req) {
+    return { status: 200, body: { data: rowsOfType('workspace', req.root).filter((r) => !r.deleted).map(stripPrefix) } };
+}
+function getWorkspace(req, id) {
+    const row = rowsOfType('workspace', req.root).find((r) => String(r.id) === `workspace_${id}` && !r.deleted);
+    return row ? { status: 200, body: { data: stripPrefix(row) } } : error(404, 'not_found', 'Workspace not found', 'not_found_error');
+}
+async function updateWorkspace(req, id, params, del) {
+    const row = rowsOfType('workspace', req.root).find((r) => String(r.id) === `workspace_${id}` && !r.deleted);
+    if (!row)
+        return error(404, 'not_found', 'Workspace not found', 'not_found_error');
+    if (del) {
+        await applyTwinWrite(SERVICE, { operation: 'workspace.delete', subjectType: 'workspace', subjectId: String(row.id), fields: { deleted: true }, occurredAt: req.occurredAt ?? FIXED_NOW, actor: { kind: 'system' } }, req.root);
+        return { status: 200, body: { data: { id, deleted: true } } };
+    }
+    const patch = { updated_at: nowIso(req.occurredAt) };
+    if (typeof params.name === 'string')
+        patch.name = params.name;
+    if (typeof params.description === 'string')
+        patch.description = params.description;
+    await applyTwinWrite(SERVICE, { operation: 'workspace.update', subjectType: 'workspace', subjectId: String(row.id), fields: patch, occurredAt: req.occurredAt ?? FIXED_NOW, actor: { kind: 'system' } }, req.root);
+    return { status: 200, body: { data: stripPrefix({ ...row, ...patch }) } };
+}
+async function updateWorkspaceMembers(req, id, params) {
+    const row = rowsOfType('workspace', req.root).find((r) => String(r.id) === `workspace_${id}` && !r.deleted);
+    if (!row)
+        return error(404, 'not_found', 'Workspace not found', 'not_found_error');
+    const add = Array.isArray(params.add) ? params.add.map(String) : [];
+    const remove = Array.isArray(params.remove) ? params.remove.map(String) : [];
+    if (add.length === 0 && remove.length === 0)
+        return error(400, 'invalid_members', 'add or remove must be a non-empty array');
+    const current = new Set((Array.isArray(row.members) ? row.members : []).map(String));
+    for (const m of add)
+        current.add(m);
+    for (const m of remove)
+        current.delete(m);
+    const members = [...current];
+    await applyTwinWrite(SERVICE, { operation: 'workspace.members', subjectType: 'workspace', subjectId: String(row.id), fields: { members, updated_at: nowIso(req.occurredAt) }, occurredAt: req.occurredAt ?? FIXED_NOW, actor: { kind: 'system' } }, req.root);
+    return { status: 200, body: { data: { id, members } } };
+}
+// ── Datasets ───────────────────────────────────────────────────────────────────
+async function createDataset(req, params) {
+    if (typeof params.name !== 'string' || !params.name)
+        return error(400, 'invalid_name', 'name is required');
+    const id = `dataset_${genId('ds', { name: params.name, at: req.occurredAt })}`;
+    const row = {
+        id,
+        name: params.name,
+        description: typeof params.description === 'string' ? params.description : '',
+        row_count: 0,
+        status: 'ready',
+        created_at: nowIso(req.occurredAt),
+        updated_at: nowIso(req.occurredAt),
+    };
+    await applyTwinWrite(SERVICE, { operation: 'dataset.create', subjectType: 'dataset', subjectId: id, fields: row, occurredAt: req.occurredAt ?? FIXED_NOW, actor: { kind: 'system' } }, req.root);
+    return { status: 200, body: { data: stripPrefix(row) } };
+}
+function listDatasets(req) {
+    return { status: 200, body: { data: rowsOfType('dataset', req.root).filter((r) => !r.deleted).map(stripPrefix) } };
+}
+// ── Analytics (computed from recorded generations) ──────────────────────────────
+function dayOf(iso) {
+    return iso.slice(0, 10);
+}
+function analyticsActivity(req) {
+    // Group recorded generations by (date, model) like OpenRouter's activity endpoint.
+    const groups = new Map();
+    for (const g of generationRows(req.root)) {
+        const date = dayOf(g.created_at);
+        const key = `${date}::${g.model}`;
+        const cur = groups.get(key) ?? { date, model: g.model, requests: 0, prompt_tokens: 0, completion_tokens: 0, usage: 0 };
+        cur.requests += 1;
+        cur.prompt_tokens += g.tokens_prompt;
+        cur.completion_tokens += g.tokens_completion;
+        cur.usage = Number((cur.usage + g.total_cost).toFixed(8));
+        groups.set(key, cur);
+    }
+    const data = [...groups.values()].sort((a, b) => (a.date < b.date ? -1 : a.date > b.date ? 1 : a.model < b.model ? -1 : 1));
+    return { status: 200, body: { data } };
+}
+function analyticsDailyTokens(req) {
+    const groups = new Map();
+    for (const g of generationRows(req.root)) {
+        const date = dayOf(g.created_at);
+        const cur = groups.get(date) ?? { date, prompt_tokens: 0, completion_tokens: 0, total_tokens: 0, requests: 0, usage: 0 };
+        cur.prompt_tokens += g.tokens_prompt;
+        cur.completion_tokens += g.tokens_completion;
+        cur.total_tokens += g.tokens_prompt + g.tokens_completion;
+        cur.requests += 1;
+        cur.usage = Number((cur.usage + g.total_cost).toFixed(8));
+        groups.set(date, cur);
+    }
+    const data = [...groups.values()].sort((a, b) => (a.date < b.date ? -1 : 1));
+    return { status: 200, body: { data } };
+}
+function analyticsQuery(req, params) {
+    // A small metric/dimension query over recorded generations.
+    const metric = typeof params.metric === 'string' ? params.metric : 'requests';
+    if (!['requests', 'prompt_tokens', 'completion_tokens', 'total_tokens', 'usage'].includes(metric)) {
+        return error(400, 'invalid_metric', `unsupported metric: ${metric}`);
+    }
+    const dimension = typeof params.dimension === 'string' ? params.dimension : 'model';
+    if (!['model', 'date'].includes(dimension))
+        return error(400, 'invalid_dimension', `unsupported dimension: ${dimension}`);
+    const groups = new Map();
+    for (const g of generationRows(req.root)) {
+        const keyVal = dimension === 'model' ? g.model : dayOf(g.created_at);
+        const total = g.tokens_prompt + g.tokens_completion;
+        const value = metric === 'requests' ? 1
+            : metric === 'prompt_tokens' ? g.tokens_prompt
+                : metric === 'completion_tokens' ? g.tokens_completion
+                    : metric === 'total_tokens' ? total
+                        : g.total_cost;
+        groups.set(keyVal, Number(((groups.get(keyVal) ?? 0) + value).toFixed(8)));
+    }
+    const data = [...groups.entries()].map(([key, value]) => ({ [dimension]: key, [metric]: value })).sort((a, b) => (Number(b[metric]) - Number(a[metric])));
+    return { status: 200, body: { metric, dimension, data } };
+}
+// ── Rankings (deterministic local catalog) ──────────────────────────────────────
+function rankingsApps(req) {
+    // Top apps by token usage, derived from any locally recorded generations that carry an app_id,
+    // plus a deterministic seed so the endpoint is meaningful even on a fresh store.
+    const byApp = new Map();
+    for (const g of generationRows(req.root)) {
+        if (g.app_id != null)
+            byApp.set(String(g.app_id), (byApp.get(String(g.app_id)) ?? 0) + g.tokens_prompt + g.tokens_completion);
+    }
+    const seeded = [
+        { app_id: 'twin-app-1', title: 'Twin Playground', total_tokens: 1_000_000 },
+        { app_id: 'twin-app-2', title: 'Twin Agents', total_tokens: 750_000 },
+        { app_id: 'twin-app-3', title: 'Twin Search', total_tokens: 500_000 },
+    ];
+    for (const s of seeded)
+        s.total_tokens += byApp.get(s.app_id) ?? 0;
+    const data = seeded.sort((a, b) => b.total_tokens - a.total_tokens).map((s, i) => ({ rank: i + 1, ...s }));
+    return { status: 200, body: { data } };
+}
+const BENCHMARKS = [
+    { source: 'artificial-analysis', model: 'openai/gpt-4o', intelligence_index: 71, output_speed_tps: 95, latency_s: 0.45 },
+    { source: 'artificial-analysis', model: 'anthropic/claude-sonnet-4.5', intelligence_index: 74, output_speed_tps: 88, latency_s: 0.6 },
+    { source: 'design-arena', model: 'google/gemini-3-flash-preview', elo: 1240, votes: 12000 },
+];
+function rankingsBenchmarks(req) {
+    const source = new URL(req.path, 'http://twin.local').searchParams.get('source');
+    const data = source ? BENCHMARKS.filter((b) => b.source === source) : BENCHMARKS;
+    return { status: 200, body: { data } };
+}
+// ── Observability destinations (CRUD) ───────────────────────────────────────────
+async function createDestination(req, params) {
+    if (typeof params.type !== 'string' || !params.type)
+        return error(400, 'invalid_type', 'type is required');
+    if (!['datadog', 'webhook', 's3', 'langfuse'].includes(params.type))
+        return error(400, 'invalid_type', `unsupported destination type: ${params.type}`);
+    const id = `destination_${genId('dest', { type: params.type, at: req.occurredAt })}`;
+    const row = {
+        id,
+        type: params.type,
+        name: typeof params.name === 'string' ? params.name : String(params.type),
+        enabled: params.enabled === undefined ? true : params.enabled === true,
+        config: params.config && typeof params.config === 'object' ? params.config : {},
+        created_at: nowIso(req.occurredAt),
+        updated_at: nowIso(req.occurredAt),
+    };
+    await applyTwinWrite(SERVICE, { operation: 'destination.create', subjectType: 'destination', subjectId: id, fields: row, occurredAt: req.occurredAt ?? FIXED_NOW, actor: { kind: 'system' } }, req.root);
+    return { status: 200, body: { data: stripPrefix(row) } };
+}
+function listDestinations(req) {
+    return { status: 200, body: { data: rowsOfType('destination', req.root).filter((r) => !r.deleted).map(stripPrefix) } };
+}
+async function updateDestination(req, id, params, del) {
+    const row = rowsOfType('destination', req.root).find((r) => String(r.id) === `destination_${id}` && !r.deleted);
+    if (!row)
+        return error(404, 'not_found', 'Destination not found', 'not_found_error');
+    if (del) {
+        await applyTwinWrite(SERVICE, { operation: 'destination.delete', subjectType: 'destination', subjectId: String(row.id), fields: { deleted: true }, occurredAt: req.occurredAt ?? FIXED_NOW, actor: { kind: 'system' } }, req.root);
+        return { status: 200, body: { data: { id, deleted: true } } };
+    }
+    const patch = { updated_at: nowIso(req.occurredAt) };
+    if (typeof params.name === 'string')
+        patch.name = params.name;
+    if (typeof params.enabled === 'boolean')
+        patch.enabled = params.enabled;
+    if (params.config && typeof params.config === 'object')
+        patch.config = params.config;
+    await applyTwinWrite(SERVICE, { operation: 'destination.update', subjectType: 'destination', subjectId: String(row.id), fields: patch, occurredAt: req.occurredAt ?? FIXED_NOW, actor: { kind: 'system' } }, req.root);
+    return { status: 200, body: { data: stripPrefix({ ...row, ...patch }) } };
+}
+// ── Audio: speech + transcription (protocol stubs) ──────────────────────────────
+function createSpeech(req, params) {
+    const model = typeof params.model === 'string' && params.model ? params.model : undefined;
+    if (!model)
+        return error(400, 'invalid_model', 'model is required');
+    if (typeof params.input !== 'string' || !params.input)
+        return error(400, 'invalid_input', 'input is required');
+    const voice = typeof params.voice === 'string' ? params.voice : 'alloy';
+    const format = typeof params.response_format === 'string' ? params.response_format : 'mp3';
+    // Deterministic, clearly-labeled stub audio payload — the API surface is the request/response
+    // envelope and the (base64) audio container, not real waveform synthesis.
+    const marker = `[twin-stub:openrouter:speech] model=${model} voice=${voice} text=${params.input}`;
+    const audio = Buffer.from(marker).toString('base64');
+    return { status: 200, body: { model, voice, format, audio, object: 'audio.speech', stub: true } };
+}
+function createTranscription(req, params) {
+    const model = typeof params.model === 'string' && params.model ? params.model : undefined;
+    if (!model)
+        return error(400, 'invalid_model', 'model is required');
+    if (params.file === undefined && params.audio === undefined)
+        return error(400, 'invalid_file', 'file is required');
+    const text = `[twin-stub:openrouter:transcription] deterministic transcript for ${model}`;
+    return { status: 200, body: { text, model, object: 'audio.transcription', stub: true } };
+}
+// ── Video generation (protocol stub: submit + poll/download) ─────────────────────
+async function submitVideo(req, params) {
+    const model = typeof params.model === 'string' && params.model ? params.model : undefined;
+    if (!model)
+        return error(400, 'invalid_model', 'model is required');
+    if (typeof params.prompt !== 'string' || !params.prompt)
+        return error(400, 'invalid_prompt', 'prompt is required');
+    const id = `video_${genId('vid', { model, prompt: params.prompt, at: req.occurredAt })}`;
+    const row = {
+        id,
+        object: 'video.generation',
+        model,
+        prompt: params.prompt,
+        status: 'completed', // deterministic: the twin completes immediately
+        progress: 100,
+        created_at: nowEpoch(req.occurredAt),
+        download_url: `http://twin.local/v1/video/${id.replace(/^video_/, '')}/content`,
+        stub: true,
+    };
+    await applyTwinWrite(SERVICE, { operation: 'video.submit', subjectType: 'video', subjectId: id, fields: row, occurredAt: req.occurredAt ?? FIXED_NOW, actor: { kind: 'system' } }, req.root);
+    return { status: 200, body: stripPrefix(row) };
+}
+function pollVideo(req, id) {
+    const row = rowsOfType('video', req.root).find((r) => String(r.id) === `video_${id}`);
+    return row ? { status: 200, body: stripPrefix(row) } : error(404, 'not_found', 'Video generation not found', 'not_found_error');
+}
+function downloadVideo(req, id) {
+    const row = rowsOfType('video', req.root).find((r) => String(r.id) === `video_${id}`);
+    if (!row)
+        return error(404, 'not_found', 'Video generation not found', 'not_found_error');
+    const content = Buffer.from(`[twin-stub:openrouter:video] ${row.model} :: ${row.prompt}`).toString('base64');
+    return { status: 200, body: { id, object: 'video.content', content, stub: true } };
+}
+const VIDEO_MODELS = [
+    { id: 'twin/video-gen-1', name: 'Twin Video Gen 1', max_duration_s: 8 },
+    { id: 'twin/video-gen-pro', name: 'Twin Video Gen Pro', max_duration_s: 16 },
+];
+function listVideoModels() {
+    return { status: 200, body: { data: VIDEO_MODELS } };
+}
+/** The legacy handler remains JSON-shaped; only the fetch adapter can select a local handoff. */
+export async function handleOpenRouterTwinRequest(req) {
+    const result = await handleOpenRouterTwinRequestWithGeneration(req);
+    if (result instanceof Response)
+        throw new Error('Unexpected local generation in the legacy twin handler');
+    return result;
+}
+export async function handleOpenRouterTwinRequestWithGeneration(req, localGeneration) {
+    const method = req.method.toUpperCase();
+    const path = apiPath(req.path);
+    const url = new URL(req.path, 'http://twin.local');
+    if (method === 'GET' && path === '/v1/models')
+        return { status: 200, body: { data: OPENROUTER_MODELS } };
+    if (method === 'GET' && path === '/v1/models/count')
+        return { status: 200, body: { data: { count: OPENROUTER_MODELS.length } } };
+    if (method === 'GET' && path.startsWith('/v1/models/') && path.endsWith('/endpoints')) {
+        const modelId = decodeURIComponent(path.slice('/v1/models/'.length, -'/endpoints'.length));
+        const model = findOpenRouterModel(modelId);
+        return model ? { status: 200, body: { data: { ...model, endpoints: [{ name: 'OpenRouter Twin', provider_name: 'twin', context_length: model.context_length }] } } } : error(404, 'not_found', 'Model not found');
+    }
+    if (method === 'GET' && path.startsWith('/v1/models/')) {
+        const model = findOpenRouterModel(decodeURIComponent(path.slice('/v1/models/'.length)));
+        return model ? { status: 200, body: { data: model } } : error(404, 'not_found', 'Model not found');
+    }
+    if (method === 'GET' && path === '/v1/providers') {
+        return { status: 200, body: { data: OPENROUTER_PROVIDERS } };
+    }
+    if (method === 'GET' && path === '/v1/key') {
+        return { status: 200, body: { data: { label: 'twin-key', limit: null, limit_reset: null, limit_remaining: null, include_byok_in_limit: false, usage: 0 } } };
+    }
+    if (method === 'GET' && path === '/v1/credits') {
+        return { status: 200, body: { data: { total_credits: 100, total_usage: 0 } } };
+    }
+    if (method === 'GET' && path === '/v1/generation') {
+        const id = url.searchParams.get('id');
+        const generationId = id?.startsWith('generation_') ? id : `generation_${id ?? ''}`;
+        const found = generationRows(req.root).find((g) => g.id === generationId);
+        return found ? { status: 200, body: { data: found } } : error(404, 'not_found', 'Generation not found');
+    }
+    if (method === 'GET' && path === '/v1/generations') {
+        return { status: 200, body: { data: generationRows(req.root) } };
+    }
+    // BYOK provider credentials (more-specific than /v1/keys, so route first)
+    if (path === '/v1/keys/byok' || path === '/v1/byok') {
+        if (method === 'GET')
+            return listByok(req);
+        if (method === 'POST')
+            return req.readOnly ? error(405, 'read_only', 'read-only') : createByok(req, parseJson(req.body));
+    }
+    if (path.startsWith('/v1/keys/byok/') || path.startsWith('/v1/byok/')) {
+        const provider = decodeURIComponent(path.replace(/^\/v1\/(keys\/)?byok\//, ''));
+        if (method === 'PATCH')
+            return req.readOnly ? error(405, 'read_only', 'read-only') : updateByok(req, provider, parseJson(req.body), false);
+        if (method === 'DELETE')
+            return req.readOnly ? error(405, 'read_only', 'read-only') : updateByok(req, provider, {}, true);
+    }
+    // API keys
+    if (path === '/v1/keys') {
+        if (method === 'GET')
+            return listApiKeys(req);
+        if (method === 'POST')
+            return req.readOnly ? error(405, 'read_only', 'This OpenRouter twin was started read-only') : createApiKey(req, parseJson(req.body));
+    }
+    if (path.startsWith('/v1/keys/')) {
+        const hash = decodeURIComponent(path.slice('/v1/keys/'.length));
+        if (method === 'GET') {
+            const row = rowsOfType('api_key', req.root).find((r) => r.hash === hash || String(r.id) === `key_${hash}`);
+            return row ? { status: 200, body: { data: stripPrefix(row) } } : error(404, 'not_found', 'API key not found', 'not_found_error');
+        }
+        if (method === 'PATCH')
+            return req.readOnly ? error(405, 'read_only', 'read-only') : updateApiKey(req, hash, parseJson(req.body), false);
+        if (method === 'DELETE')
+            return req.readOnly ? error(405, 'read_only', 'read-only') : updateApiKey(req, hash, {}, true);
+    }
+    // Presets (responses-sourced create is more specific than the slug getter, so route it first)
+    if (method === 'POST' && path === '/v1/presets/responses') {
+        return req.readOnly ? error(405, 'read_only', 'read-only') : createPresetFromResponses(req, parseJson(req.body));
+    }
+    if (path === '/v1/presets') {
+        if (method === 'GET')
+            return listPresets(req);
+        if (method === 'POST')
+            return req.readOnly ? error(405, 'read_only', 'read-only') : createPreset(req, parseJson(req.body));
+    }
+    if (path.startsWith('/v1/presets/')) {
+        if (method === 'GET')
+            return getPreset(req, decodeURIComponent(path.slice('/v1/presets/'.length)));
+    }
+    // Files
+    if (path === '/v1/files') {
+        if (method === 'GET')
+            return listFiles(req);
+        if (method === 'POST')
+            return req.readOnly ? error(405, 'read_only', 'read-only') : uploadFile(req, parseJson(req.body));
+    }
+    if (path.startsWith('/v1/files/')) {
+        const fileId = decodeURIComponent(path.slice('/v1/files/'.length));
+        if (method === 'GET')
+            return getFile(req, fileId);
+        if (method === 'DELETE')
+            return req.readOnly ? error(405, 'read_only', 'read-only') : deleteFile(req, fileId);
+    }
+    // OAuth (PKCE)
+    if (method === 'POST' && path === '/v1/auth/authorize') {
+        return req.readOnly ? error(405, 'read_only', 'read-only') : oauthAuthorize(req, parseJson(req.body));
+    }
+    if (method === 'POST' && (path === '/v1/auth/keys' || path === '/v1/auth/exchange')) {
+        return req.readOnly ? error(405, 'read_only', 'read-only') : oauthExchange(req, parseJson(req.body));
+    }
+    // Guardrails
+    if (path === '/v1/guardrails') {
+        if (method === 'GET')
+            return listGuardrails(req);
+        if (method === 'POST')
+            return req.readOnly ? error(405, 'read_only', 'read-only') : createGuardrail(req, parseJson(req.body));
+    }
+    if (path.startsWith('/v1/guardrails/') && path.endsWith('/assignments')) {
+        const id = decodeURIComponent(path.slice('/v1/guardrails/'.length, -'/assignments'.length));
+        if (method === 'GET')
+            return getGuardrailAssignments(req, id);
+        if (method === 'PUT' || method === 'POST')
+            return req.readOnly ? error(405, 'read_only', 'read-only') : setGuardrailAssignments(req, id, parseJson(req.body));
+    }
+    if (path.startsWith('/v1/guardrails/')) {
+        const id = decodeURIComponent(path.slice('/v1/guardrails/'.length));
+        if (method === 'GET')
+            return getGuardrail(req, id);
+        if (method === 'PATCH')
+            return req.readOnly ? error(405, 'read_only', 'read-only') : updateGuardrail(req, id, parseJson(req.body), false);
+        if (method === 'DELETE')
+            return req.readOnly ? error(405, 'read_only', 'read-only') : updateGuardrail(req, id, {}, true);
+    }
+    // Organization
+    if (method === 'GET' && (path === '/v1/organization/members' || path === '/v1/me/members')) {
+        return listOrgMembers();
+    }
+    // Workspaces
+    if (path === '/v1/workspaces') {
+        if (method === 'GET')
+            return listWorkspaces(req);
+        if (method === 'POST')
+            return req.readOnly ? error(405, 'read_only', 'read-only') : createWorkspace(req, parseJson(req.body));
+    }
+    if (path.startsWith('/v1/workspaces/') && path.endsWith('/members')) {
+        const id = decodeURIComponent(path.slice('/v1/workspaces/'.length, -'/members'.length));
+        if (method === 'POST' || method === 'PATCH')
+            return req.readOnly ? error(405, 'read_only', 'read-only') : updateWorkspaceMembers(req, id, parseJson(req.body));
+    }
+    if (path.startsWith('/v1/workspaces/')) {
+        const id = decodeURIComponent(path.slice('/v1/workspaces/'.length));
+        if (method === 'GET')
+            return getWorkspace(req, id);
+        if (method === 'PATCH')
+            return req.readOnly ? error(405, 'read_only', 'read-only') : updateWorkspace(req, id, parseJson(req.body), false);
+        if (method === 'DELETE')
+            return req.readOnly ? error(405, 'read_only', 'read-only') : updateWorkspace(req, id, {}, true);
+    }
+    // Datasets
+    if (path === '/v1/datasets') {
+        if (method === 'GET')
+            return listDatasets(req);
+        if (method === 'POST')
+            return req.readOnly ? error(405, 'read_only', 'read-only') : createDataset(req, parseJson(req.body));
+    }
+    // Analytics (computed from recorded generations)
+    if (method === 'GET' && path === '/v1/analytics/activity')
+        return analyticsActivity(req);
+    if (method === 'GET' && (path === '/v1/analytics/daily' || path === '/v1/analytics/daily-tokens'))
+        return analyticsDailyTokens(req);
+    if ((method === 'GET' || method === 'POST') && path === '/v1/analytics/query') {
+        return analyticsQuery(req, method === 'POST' ? parseJson(req.body) : Object.fromEntries(url.searchParams.entries()));
+    }
+    // Rankings
+    if (method === 'GET' && path === '/v1/rankings/apps')
+        return rankingsApps(req);
+    if (method === 'GET' && path === '/v1/rankings/benchmarks')
+        return rankingsBenchmarks(req);
+    // Observability destinations
+    if (path === '/v1/observability/destinations') {
+        if (method === 'GET')
+            return listDestinations(req);
+        if (method === 'POST')
+            return req.readOnly ? error(405, 'read_only', 'read-only') : createDestination(req, parseJson(req.body));
+    }
+    if (path.startsWith('/v1/observability/destinations/')) {
+        const id = decodeURIComponent(path.slice('/v1/observability/destinations/'.length));
+        if (method === 'PATCH')
+            return req.readOnly ? error(405, 'read_only', 'read-only') : updateDestination(req, id, parseJson(req.body), false);
+        if (method === 'DELETE')
+            return req.readOnly ? error(405, 'read_only', 'read-only') : updateDestination(req, id, {}, true);
+    }
+    // Audio (protocol stubs)
+    if (method === 'POST' && path === '/v1/audio/speech') {
+        return req.readOnly ? error(405, 'read_only', 'read-only') : createSpeech(req, parseJson(req.body));
+    }
+    if (method === 'POST' && path === '/v1/audio/transcriptions') {
+        return req.readOnly ? error(405, 'read_only', 'read-only') : createTranscription(req, parseJson(req.body));
+    }
+    // Video generation (protocol stub)
+    if (method === 'GET' && path === '/v1/video/models')
+        return listVideoModels();
+    if (method === 'POST' && path === '/v1/video') {
+        return req.readOnly ? error(405, 'read_only', 'read-only') : submitVideo(req, parseJson(req.body));
+    }
+    if (path.startsWith('/v1/video/') && path.endsWith('/content')) {
+        const id = decodeURIComponent(path.slice('/v1/video/'.length, -'/content'.length));
+        if (method === 'GET')
+            return downloadVideo(req, id);
+    }
+    if (method === 'GET' && path.startsWith('/v1/video/')) {
+        return pollVideo(req, decodeURIComponent(path.slice('/v1/video/'.length)));
+    }
+    if (method === 'POST' && path === '/v1/chat/completions') {
+        if (req.readOnly)
+            return error(405, 'read_only', 'This OpenRouter twin was started read-only');
+        return chatCompletion(req, parseJson(req.body), localGeneration);
+    }
+    if (method === 'POST' && path === '/v1/responses') {
+        if (req.readOnly)
+            return error(405, 'read_only', 'This OpenRouter twin was started read-only');
+        return createResponse(req, parseJson(req.body), localGeneration);
+    }
+    if (method === 'POST' && path === '/v1/embeddings') {
+        if (req.readOnly)
+            return error(405, 'read_only', 'This OpenRouter twin was started read-only');
+        return createEmbeddings(req, parseJson(req.body));
+    }
+    if (method === 'POST' && (path === '/v1/messages' || path === '/v1/anthropic/v1/messages')) {
+        if (req.readOnly)
+            return error(405, 'read_only', 'This OpenRouter twin was started read-only');
+        return anthropicMessages(req, parseJson(req.body));
+    }
+    if (method === 'POST' && path === '/v1/rerank') {
+        if (req.readOnly)
+            return error(405, 'read_only', 'This OpenRouter twin was started read-only');
+        return rerank(req, parseJson(req.body));
+    }
+    return error(404, 'not_found', `OpenRouter operation not modeled: ${method} ${path}`, 'not_found_error');
+}