@jini-ai/daemon 0.3.7 → 0.5.0

package/dist/http/model-proxy.js

@@ -0,0 +1,642 @@
+/**
+ * @module model-proxy
+ *
+ * `POST /api/proxy/{anthropic,openai,azure,google,ollama}/stream`, plus a
+ * generic `POST /api/proxy/:provider/stream` catch-all — thin SSE route
+ * wrappers over `@jini-ai/agent-runtime`'s `run{Anthropic,OpenAi,Azure,Google,
+ * Ollama}ToolTurn` wire-adapter/turn-runners. Implements the placement
+ * decision in `ADS-memory/reports/proposals/
+ * PROP-http-route-packs-chat-model-proxy-2026-07-21.md`: OD's
+ * `apps/daemon/src/routes/chat.ts` (2267 lines) genuinely is the largest
+ * reusable route pack this package's routes-classification table ever
+ * found, but its provider-specific wire-protocol knowledge (Anthropic
+ * Messages API / OpenAI Chat Completions SSE parsing, tool-call-fragment
+ * accumulation, the role-marker-guard contamination loop) does not belong
+ * in generic HTTP transport. The provider-specific implementation stays in
+ * the runtime, following the proposal to extend `@jini-ai/agent-runtime`'s existing `providers/` pattern instead.
+ * This module is the `@jini-ai/daemon/http` transport half of that split: request parsing,
+ * same-origin enforcement, and SSE transport (`sse.ts`, the same primitive
+ * `runs.ts`/`memory.ts` already consume) — no knowledge of what an
+ * Anthropic `content_block_delta`, an OpenAI `tool_calls[].function.
+ * arguments` fragment, or a Gemini `candidates[0].content.parts[]` entry
+ * looks like lives here.
+ *
+ * **2026-07-21 pass**: Anthropic and OpenAI only, per the proposal's own
+ * phased recommendation ("the two most-used... deferring Azure/Google/
+ * Ollama as mechanical repeats once the pattern is proven").
+ *
+ * **2026-07-22 pass (this addition)**: picks up exactly that deferred item
+ * — Azure, Google, and Ollama proxy routes are now built, each a thin
+ * sibling `registerProxyStreamRoute` call following the identical request-
+ * parsing/SSE-wiring shape, once `@jini-ai/agent-runtime` grew the matching
+ * per-vendor turn-runner (see that package's `archived provenance ledger`'s own
+ * 2026-07-22 dated section). Also adds the generic `POST
+ * /api/proxy/:provider/stream` catch-all described below.
+ *
+ * **OpenRouter is still not built — open, not rejected.** Evaluated as part
+ * of the OD route-parity audit this pass drew on; the user wants to discuss
+ * OpenRouter's specific placement (gateway vs. native-provider shape) further
+ * before it gets ported. Flagged here explicitly, the same way the
+ * 2026-07-21 pass flagged Azure/Google/Ollama, so it isn't mistaken for a
+ * decision that's already been made either way.
+ *
+ * **Deliberately excluded regardless of this decision** (confirmed
+ * OD-PRODUCT per the proposal): `POST /api/runs/:id/feedback` and the two
+ * "Critique Theater" routes. Not touched by this module at all.
+ *
+ * **BYOK, not server-held credentials.** Every request carries its own
+ * `apiKey` (and optional `baseUrl`/`extraHeaders`) in the POST body, exactly
+ * like `@jini-ai/agent-runtime`'s existing `providers/model-catalog.ts` BYOK
+ * surface — this route never stores or reads a server-side credential.
+ * `apiKey` is required for all five providers, including Ollama — an earlier
+ * version of this module made it optional for Ollama on a "local install
+ * needs no auth" rationale that a live comparison against a running Open
+ * Design daemon proved doesn't match OD's real behavior (OD's default
+ * Ollama target is Ollama Cloud, which does require a key; see
+ * `@jini-ai/agent-runtime`'s `ollama-chat.ts` module doc for the full
+ * corrected design).
+ *
+ * **Tool execution is out of scope for this pass.** `ModelProxyHttpDeps`'s
+ * `executeTool` hooks are optional and default to unset, matching
+ * `packages/deploy/archived provenance ledger`'s precedent for "deferred real
+ * `ToolExecutor` wiring." With no executor supplied, a turn still streams
+ * back any `tool_use`/`tool_calls` the model requests (so a caller can act
+ * on them itself and start a fresh request with the results appended to
+ * `messages`) — the turn-runner just does not attempt the server-side
+ * tool-execution loop. See `anthropic-messages.ts`/`openai-chat.ts`'s own
+ * docs for that behavior.
+ *
+ * **The `:provider` catch-all's relationship to the five fixed routes.**
+ * `registerModelProxyRoutes` registers the five literal-path routes first,
+ * then the generic `/api/proxy/:provider/stream` catch-all last. Express
+ * matches registered routes in registration order, so a request to
+ * `/api/proxy/anthropic/stream` (etc.) is always served by its own fixed,
+ * strongly-typed handler — the catch-all's own lookup-table entry for
+ * `'anthropic'` is real, tested code, but is only reachable via real HTTP
+ * traffic for a provider name that has no dedicated fixed route (a typo, or
+ * a future provider added to the registry before its own literal route
+ * lands). This is deliberate, not dead code left behind by accident: the
+ * catch-all exists for callers that want one parameterized endpoint rather
+ * than hardcoding five URLs, and for forward-compatibility, without taking
+ * over routing for the five providers that already have a dedicated, more
+ * specifically-typed path.
+ */
+import { randomUUID } from 'node:crypto';
+import { runAnthropicToolTurn, runAzureToolTurn, runGoogleToolTurn, runOllamaToolTurn, runOpenAiToolTurn, } from '@jini-ai/agent-runtime';
+import { createApiError } from '@jini-ai/protocol';
+import { validationError } from '@jini-ai/http-kit';
+import { sendApiError } from '@jini-ai/http-kit';
+import { guardSameOrigin } from '@jini-ai/http-kit';
+import { createSseChannel } from '@jini-ai/http-kit';
+import { err, ok } from '@jini-ai/http-kit';
+function defaultInternalErrorSink(context) {
+    // eslint-disable-next-line no-console
+    console.error(`[@jini-ai/http-kit] internal error (model-proxy/${context.provider}, correlationId=${context.correlationId})`, context.error);
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function nonEmptyString(value) {
+    return typeof value === 'string' && value.trim().length > 0 ? value : null;
+}
+/**
+ * Validates only the transport-level shape every proxied request shares
+ * (non-empty `apiKey`/`model`, a `messages` array, and the optional numeric/
+ * record fields' primitive types) — never the *contents* of `messages` or
+ * `tools`, which is provider wire-protocol knowledge this package does not
+ * have (see module doc). A malformed message/tool shape is instead rejected
+ * by the real provider API and surfaces as a normal `'error'` SSE event,
+ * exactly like any other upstream rejection.
+ *
+ * SECURITY: `apiKey` travels in this JSON body, not an `Authorization` header
+ * — a deliberate BYOK design choice (see module doc), not an oversight, but
+ * one that only stays safe because every caller of this function is reached
+ * through `runProxyStream`/`registerGenericProxyStreamRoute`, both of which
+ * call `guardSameOrigin` before this parser ever runs (confirmed 2026-08-23;
+ * see the "rejects a cross-origin request with 403 before touching fetch"
+ * regression test per provider, plus the catch-all's own, in
+ * `__tests__/model-proxy.test.ts` — each proves the credential is never
+ * forwarded to `fetch` for a rejected cross-origin request). Do not loosen or
+ * remove that same-origin enforcement without first moving `apiKey` to a
+ * header — a body-carried credential is not safe to accept cross-origin.
+ */
+function parseCommon(body) {
+    if (!isRecord(body))
+        return err({ error: validationError({ message: 'body must be a JSON object' }) });
+    const apiKey = nonEmptyString(body.apiKey);
+    if (!apiKey) {
+        return err({ error: validationError({ message: 'apiKey must be a non-empty string' }, { issues: [{ path: 'apiKey', message: 'required non-empty string' }] }) });
+    }
+    const model = nonEmptyString(body.model);
+    if (!model) {
+        return err({ error: validationError({ message: 'model must be a non-empty string' }, { issues: [{ path: 'model', message: 'required non-empty string' }] }) });
+    }
+    if (!Array.isArray(body.messages) || body.messages.length === 0) {
+        return err({ error: validationError({ message: 'messages must be a non-empty array' }, { issues: [{ path: 'messages', message: 'required non-empty array' }] }) });
+    }
+    if (body.baseUrl !== undefined && typeof body.baseUrl !== 'string') {
+        return err({ error: validationError({ message: 'baseUrl must be a string when provided' }) });
+    }
+    if (body.temperature !== undefined && typeof body.temperature !== 'number') {
+        return err({ error: validationError({ message: 'temperature must be a number when provided' }) });
+    }
+    if (body.maxTokens !== undefined && typeof body.maxTokens !== 'number') {
+        return err({ error: validationError({ message: 'maxTokens must be a number when provided' }) });
+    }
+    if (body.maxToolTurns !== undefined && typeof body.maxToolTurns !== 'number') {
+        return err({ error: validationError({ message: 'maxToolTurns must be a number when provided' }) });
+    }
+    if (body.extraHeaders !== undefined && !isRecord(body.extraHeaders)) {
+        return err({ error: validationError({ message: 'extraHeaders must be an object when provided' }) });
+    }
+    return ok({
+        value: {
+            apiKey,
+            model,
+            messages: body.messages,
+            ...(body.baseUrl !== undefined ? { baseUrl: body.baseUrl } : {}),
+            ...(body.temperature !== undefined ? { temperature: body.temperature } : {}),
+            ...(body.maxTokens !== undefined ? { maxTokens: body.maxTokens } : {}),
+            ...(body.maxToolTurns !== undefined ? { maxToolTurns: body.maxToolTurns } : {}),
+            ...(body.extraHeaders !== undefined ? { extraHeaders: body.extraHeaders } : {}),
+        }
+    });
+}
+function parseAnthropicProxyRequest(body) {
+    const common = parseCommon(body);
+    if (!common.ok)
+        return common;
+    const record = body;
+    if (typeof record.maxTokens !== 'number' || !Number.isFinite(record.maxTokens) || record.maxTokens <= 0) {
+        return err({ error: validationError({ message: 'maxTokens must be a positive number' }, { issues: [{ path: 'maxTokens', message: 'required positive number' }] }) });
+    }
+    if (record.apiVersion !== undefined && typeof record.apiVersion !== 'string') {
+        return err({ error: validationError({ message: 'apiVersion must be a string when provided' }) });
+    }
+    if (record.system !== undefined && typeof record.system !== 'string') {
+        return err({ error: validationError({ message: 'system must be a string when provided' }) });
+    }
+    if (record.tools !== undefined && !Array.isArray(record.tools)) {
+        return err({ error: validationError({ message: 'tools must be an array when provided' }) });
+    }
+    return ok({
+        value: {
+            ...common.value,
+            maxTokens: record.maxTokens,
+            ...(record.apiVersion !== undefined ? { apiVersion: record.apiVersion } : {}),
+            ...(record.system !== undefined ? { system: record.system } : {}),
+            ...(record.tools !== undefined ? { tools: record.tools } : {}),
+        }
+    });
+}
+function parseOpenAiProxyRequest(body) {
+    const common = parseCommon(body);
+    if (!common.ok)
+        return common;
+    const record = body;
+    if (record.tools !== undefined && !Array.isArray(record.tools)) {
+        return err({ error: validationError({ message: 'tools must be an array when provided' }) });
+    }
+    return ok({
+        value: {
+            ...common.value,
+            ...(record.tools !== undefined ? { tools: record.tools } : {}),
+        }
+    });
+}
+function parseAzureProxyRequest(body) {
+    const common = parseCommon(body);
+    if (!common.ok)
+        return common;
+    const record = body;
+    if (!common.value.baseUrl) {
+        return err({ error: validationError({ message: 'baseUrl must be a non-empty string' }, { issues: [{ path: 'baseUrl', message: 'required non-empty string' }] }) });
+    }
+    if (typeof record.apiVersion !== 'string' || record.apiVersion.trim().length === 0) {
+        return err({ error: validationError({ message: 'apiVersion must be a non-empty string' }, { issues: [{ path: 'apiVersion', message: 'required non-empty string' }] }) });
+    }
+    if (record.tools !== undefined && !Array.isArray(record.tools)) {
+        return err({ error: validationError({ message: 'tools must be an array when provided' }) });
+    }
+    return ok({
+        value: {
+            ...common.value,
+            baseUrl: common.value.baseUrl,
+            apiVersion: record.apiVersion,
+            ...(record.tools !== undefined ? { tools: record.tools } : {}),
+        }
+    });
+}
+/** `parsed.messages` carries Gemini's own `contents: [{role, parts}]` shape at the call site below (cast, same convention as `parsed.messages as unknown as readonly AnthropicMessageParam[]`) — the HTTP JSON body schema stays uniform across all five providers; only each turn-runner's own field name differs. */
+function parseGoogleProxyRequest(body) {
+    const common = parseCommon(body);
+    if (!common.ok)
+        return common;
+    const record = body;
+    if (record.system !== undefined && typeof record.system !== 'string') {
+        return err({ error: validationError({ message: 'system must be a string when provided' }) });
+    }
+    if (record.tools !== undefined && !Array.isArray(record.tools)) {
+        return err({ error: validationError({ message: 'tools must be an array when provided' }) });
+    }
+    if (record.maxOutputTokens !== undefined && typeof record.maxOutputTokens !== 'number') {
+        return err({ error: validationError({ message: 'maxOutputTokens must be a number when provided' }) });
+    }
+    return ok({
+        value: {
+            ...common.value,
+            ...(record.system !== undefined ? { system: record.system } : {}),
+            ...(record.tools !== undefined ? { tools: record.tools } : {}),
+            ...(record.maxOutputTokens !== undefined ? { maxOutputTokens: record.maxOutputTokens } : {}),
+        }
+    });
+}
+function parseOllamaProxyRequest(body) {
+    const common = parseCommon(body);
+    if (!common.ok)
+        return common;
+    const record = body;
+    if (record.tools !== undefined && !Array.isArray(record.tools)) {
+        return err({ error: validationError({ message: 'tools must be an array when provided' }) });
+    }
+    return ok({
+        value: {
+            ...common.value,
+            ...(record.tools !== undefined ? { tools: record.tools } : {}),
+        }
+    });
+}
+/** Wraps a raw turn-runner event for `sse.ts`'s generic channel: `kind` drives both the wire `event:` field and `createSseChannel`'s `isEndEvent` auto-close, `data` preserves the exact event shape agent-runtime produced. */
+function toStreamEvent(seq, event) {
+    return { opaqueCursor: String(seq), kind: event.type, data: event };
+}
+/**
+ * The actual request handler body, shared by every fixed-path route and the `:provider`
+ * catch-all: same-origin guard, request parsing, SSE channel lifecycle, and the SEC-005 catch-all
+ * for a turn-runner promise that rejects outright (see module doc). Provider-specific pieces
+ * (`provider`, `parse`, `run`) are injected — extracted into its own function (rather than living
+ * inline inside `registerProxyStreamRoute`'s `app.post` callback, as it did before this pass) so
+ * the generic catch-all route below can invoke the identical logic with a `provider` value read
+ * from `req.params` instead of a fixed string, without duplicating the SSE-wiring/error-handling
+ * code a second time.
+ */
+async function runProxyStream(req, res, adapter, provider, onInternalError, parse, run) {
+    // Both `channel` and `seq` are declared ahead of the try so the catch block below can still
+    // reach them however far execution got — including a throw from `guardSameOrigin`/`parse`,
+    // before either exists yet.
+    let seq = 0;
+    let channel;
+    try {
+        const origin = guardSameOrigin({ req, origin: adapter });
+        if (!origin.ok) {
+            sendApiError({ res, status: 403, error: origin.error });
+            return;
+        }
+        const parsed = parse(req.body);
+        if (!parsed.ok) {
+            sendApiError({ res, status: 400, error: parsed.error });
+            return;
+        }
+        channel = createSseChannel({ res }, { isEndEvent: ({ event }) => event.kind === 'end' });
+        channel.open();
+        await run(parsed.value, (event) => channel.enqueue({ event: toStreamEvent(seq++, event) }));
+        // No `channel.end()` call here: every reachable exit path inside every turn-runner emits
+        // exactly one `'end'`-kind event before its promise resolves (the duplicate-end-event fix —
+        // see each provider module's own `turn-end-guard.ts` usage, and each function's own
+        // `while (true)` loop, which cannot exit without first calling `emitEnd`), and `isEndEvent`
+        // above already auto-closed the channel the instant that event was enqueued.
+    }
+    catch (error) {
+        // This catch now covers the whole handler, not just `run(...)`: neither caller of this
+        // function (`registerProxyStreamRoute`'s fixed routes, `registerGenericProxyStreamRoute`'s
+        // catch-all) awaits or `.catch()`s the promise this function returns — exactly how Express
+        // itself invokes every handler. `guardSameOrigin`/`parse` are Result-returning by contract and
+        // don't throw today, but nothing enforces that; if either ever did, the throw used to become
+        // an unhandled rejection with no process-level guard anywhere in this package's path, which is
+        // Node's documented crash-the-process default. See the paired regression test in
+        // `__tests__/model-proxy.test.ts`.
+        const correlationId = randomUUID();
+        onInternalError({ provider, correlationId, error });
+        if (channel) {
+            // `enqueue` is a documented no-op once the channel is already closed (`sse.ts`), so these
+            // two synthetic events are safe to send unconditionally: normally the channel is still open
+            // here (an exception escaping `run` — e.g. a caller-supplied `executeTool` throwing — means
+            // no `'end'` event was ever emitted for this connection), and the synthetic `'end'`-kind
+            // event's own `isEndEvent` match closes the channel via the same path as a real one.
+            channel.enqueue({
+                event: toStreamEvent(seq++, {
+                    type: 'error',
+                    message: 'an internal error occurred',
+                    code: correlationId,
+                })
+            });
+            channel.enqueue({ event: toStreamEvent(seq++, { type: 'end', reason: 'error' }) });
+        }
+        else if (!res.headersSent) {
+            // The SSE channel was never opened (the throw happened before it), so no stream headers
+            // were ever committed — a normal JSON error response is still possible here, matching how
+            // `mountJsonRoute`'s own SEC-005 catch responds to a pre-response failure.
+            sendApiError({ res, status: 500, error: createApiError({ code: 'INTERNAL_ERROR', message: 'an internal error occurred' }, { requestId: correlationId }) });
+        }
+        else if (!res.writableEnded) {
+            res.end();
+        }
+    }
+}
+/** Registers one fixed-path provider route (`registerModelProxyRoutes`'s five calls below). Thin wrapper over {@link runProxyStream} — `provider` is a fixed string, not read from `req.params`. */
+function registerProxyStreamRoute(app, path, adapter, provider, onInternalError, parse, run) {
+    app.post(path, (req, res) => runProxyStream(req, res, adapter, provider, onInternalError, parse, run));
+}
+/** Builds the `provider name -> {parse, run}` table the generic catch-all dispatches through. Each entry's `run` closure captures `deps` for the same optional `executeTool` wiring the five fixed routes use. */
+function buildProxyProviderRegistry(deps) {
+    return {
+        anthropic: {
+            parse: parseAnthropicProxyRequest,
+            run: ((parsed, onEvent) => runAnthropicToolTurn({
+                apiKey: parsed.apiKey,
+                model: parsed.model,
+                maxTokens: parsed.maxTokens,
+                messages: parsed.messages,
+                onEvent
+            }, {
+                ...(parsed.baseUrl !== undefined ? { baseUrl: parsed.baseUrl } : {}),
+                ...(parsed.apiVersion !== undefined ? { apiVersion: parsed.apiVersion } : {}),
+                ...(parsed.system !== undefined ? { system: parsed.system } : {}),
+                ...(parsed.tools !== undefined ? { tools: parsed.tools } : {}),
+                ...(parsed.temperature !== undefined ? { temperature: parsed.temperature } : {}),
+                ...(parsed.maxToolTurns !== undefined ? { maxToolTurns: parsed.maxToolTurns } : {}),
+                ...(parsed.extraHeaders !== undefined ? { extraHeaders: parsed.extraHeaders } : {}),
+                ...(deps.fetchImpl ? { fetchImpl: deps.fetchImpl } : {}),
+                ...(deps.dnsLookup ? { dnsLookup: deps.dnsLookup } : {}),
+                ...(deps.anthropicExecuteTool
+                    ? { executeTool: (call) => deps.anthropicExecuteTool(call) }
+                    : {})
+            })),
+        },
+        openai: {
+            parse: parseOpenAiProxyRequest,
+            run: ((parsed, onEvent) => runOpenAiToolTurn({
+                apiKey: parsed.apiKey,
+                model: parsed.model,
+                messages: parsed.messages,
+                onEvent
+            }, {
+                ...(parsed.baseUrl !== undefined ? { baseUrl: parsed.baseUrl } : {}),
+                ...(parsed.tools !== undefined ? { tools: parsed.tools } : {}),
+                ...(parsed.temperature !== undefined ? { temperature: parsed.temperature } : {}),
+                ...(parsed.maxTokens !== undefined ? { maxTokens: parsed.maxTokens } : {}),
+                ...(parsed.maxToolTurns !== undefined ? { maxToolTurns: parsed.maxToolTurns } : {}),
+                ...(parsed.extraHeaders !== undefined ? { extraHeaders: parsed.extraHeaders } : {}),
+                ...(deps.fetchImpl ? { fetchImpl: deps.fetchImpl } : {}),
+                ...(deps.dnsLookup ? { dnsLookup: deps.dnsLookup } : {}),
+                ...(deps.openaiExecuteTool
+                    ? { executeTool: (call) => deps.openaiExecuteTool(call) }
+                    : {})
+            })),
+        },
+        azure: {
+            parse: parseAzureProxyRequest,
+            run: ((parsed, onEvent) => runAzureToolTurn({
+                apiKey: parsed.apiKey,
+                baseUrl: parsed.baseUrl,
+                model: parsed.model,
+                messages: parsed.messages,
+                onEvent
+            }, {
+                apiVersion: parsed.apiVersion,
+                ...(parsed.tools !== undefined ? { tools: parsed.tools } : {}),
+                ...(parsed.temperature !== undefined ? { temperature: parsed.temperature } : {}),
+                ...(parsed.maxTokens !== undefined ? { maxTokens: parsed.maxTokens } : {}),
+                ...(parsed.maxToolTurns !== undefined ? { maxToolTurns: parsed.maxToolTurns } : {}),
+                ...(parsed.extraHeaders !== undefined ? { extraHeaders: parsed.extraHeaders } : {}),
+                ...(deps.fetchImpl ? { fetchImpl: deps.fetchImpl } : {}),
+                ...(deps.dnsLookup ? { dnsLookup: deps.dnsLookup } : {}),
+                ...(deps.azureExecuteTool
+                    ? { executeTool: (call) => deps.azureExecuteTool(call) }
+                    : {})
+            })),
+        },
+        google: {
+            parse: parseGoogleProxyRequest,
+            run: ((parsed, onEvent) => runGoogleToolTurn({
+                apiKey: parsed.apiKey,
+                model: parsed.model,
+                contents: parsed.messages,
+                onEvent
+            }, {
+                ...(parsed.baseUrl !== undefined ? { baseUrl: parsed.baseUrl } : {}),
+                ...(parsed.system !== undefined ? { system: parsed.system } : {}),
+                ...(parsed.tools !== undefined ? { tools: parsed.tools } : {}),
+                ...(parsed.temperature !== undefined ? { temperature: parsed.temperature } : {}),
+                ...(parsed.maxOutputTokens !== undefined ? { maxOutputTokens: parsed.maxOutputTokens } : {}),
+                ...(parsed.maxToolTurns !== undefined ? { maxToolTurns: parsed.maxToolTurns } : {}),
+                ...(parsed.extraHeaders !== undefined ? { extraHeaders: parsed.extraHeaders } : {}),
+                ...(deps.fetchImpl ? { fetchImpl: deps.fetchImpl } : {}),
+                ...(deps.dnsLookup ? { dnsLookup: deps.dnsLookup } : {}),
+                ...(deps.googleExecuteTool
+                    ? { executeTool: (call) => deps.googleExecuteTool(call) }
+                    : {})
+            })),
+        },
+        ollama: {
+            parse: parseOllamaProxyRequest,
+            run: ((parsed, onEvent) => runOllamaToolTurn({
+                apiKey: parsed.apiKey,
+                model: parsed.model,
+                messages: parsed.messages,
+                onEvent
+            }, {
+                ...(parsed.baseUrl !== undefined ? { baseUrl: parsed.baseUrl } : {}),
+                ...(parsed.tools !== undefined ? { tools: parsed.tools } : {}),
+                ...(parsed.temperature !== undefined ? { temperature: parsed.temperature } : {}),
+                ...(parsed.maxTokens !== undefined ? { maxTokens: parsed.maxTokens } : {}),
+                ...(parsed.maxToolTurns !== undefined ? { maxToolTurns: parsed.maxToolTurns } : {}),
+                ...(parsed.extraHeaders !== undefined ? { extraHeaders: parsed.extraHeaders } : {}),
+                ...(deps.fetchImpl ? { fetchImpl: deps.fetchImpl } : {}),
+                ...(deps.dnsLookup ? { dnsLookup: deps.dnsLookup } : {}),
+                ...(deps.ollamaExecuteTool
+                    ? { executeTool: (call) => deps.ollamaExecuteTool(call) }
+                    : {})
+            })),
+        },
+    };
+}
+const RECOGNIZED_PROVIDERS = new Set([
+    'anthropic',
+    'openai',
+    'azure',
+    'google',
+    'ollama',
+]);
+function isRecognizedProvider(value) {
+    return RECOGNIZED_PROVIDERS.has(value);
+}
+/**
+ * Mounts `POST /api/proxy/:provider/stream` — see module doc's "the `:provider` catch-all's
+ * relationship to the five fixed routes" section for why an unrecognized-but-registry-present
+ * provider name is the only branch of this handler real HTTP traffic can reach for the five known
+ * provider ids.
+ */
+function registerGenericProxyStreamRoute(app, adapter, onInternalError, registry) {
+    app.post('/api/proxy/:provider/stream', async (req, res) => {
+        // Unlike the five fixed routes, this catch-all's own `guardSameOrigin` call sits ahead of
+        // `runProxyStream` (the registry lookup below has to happen first, to even know which
+        // `provider` string to hand `onInternalError`) — so it needs its own guard against the same
+        // failure class `runProxyStream`'s catch already documents: `guardSameOrigin` is
+        // Result-returning by contract but not guaranteed never to throw (`isLocalSameOrigin` really
+        // does throw on a malformed `JINI_ALLOWED_ORIGINS` entry — see `origin-validation.ts`), and
+        // this handler's returned promise is never awaited or `.catch()`-ed by Express, so an
+        // uncaught throw here becomes an unhandled rejection with no process-level guard. See the
+        // paired regression test in `__tests__/model-proxy.test.ts`.
+        //
+        // Read ahead of the try: plain property/index access on `req.params`/`registry`, never
+        // throws, and the catch below needs it regardless of how far execution got.
+        const providerParam = req.params.provider ?? '';
+        try {
+            const origin = guardSameOrigin({ req, origin: adapter });
+            if (!origin.ok) {
+                sendApiError({ res, status: 403, error: origin.error });
+                return;
+            }
+            const entry = registry[providerParam];
+            if (!entry || !isRecognizedProvider(providerParam)) {
+                sendApiError({ res, status: 400, error: createApiError({ code: 'BAD_REQUEST', message: `unknown provider: ${providerParam}` }) });
+                return;
+            }
+            await runProxyStream(req, res, adapter, providerParam, onInternalError, entry.parse, entry.run);
+        }
+        catch (error) {
+            // No SSE channel can exist yet at this point — `runProxyStream` owns opening one, and this
+            // catch only reaches errors thrown before that call. A plain JSON error response is always
+            // still possible, matching `runProxyStream`'s own "channel never opened" branch.
+            const correlationId = randomUUID();
+            // `onInternalError`'s contract only accepts the 5 recognized provider literals; a throw
+            // this early (e.g. `guardSameOrigin`) may have happened before the provider name was even
+            // validated, so an unrecognized/empty `providerParam` logs directly instead of lying to
+            // that typed contract with a provider that was never actually confirmed.
+            if (isRecognizedProvider(providerParam)) {
+                onInternalError({ provider: providerParam, correlationId, error });
+            }
+            else {
+                // eslint-disable-next-line no-console
+                console.error(`[@jini-ai/http-kit] internal error (model-proxy/${providerParam || 'unknown'}, correlationId=${correlationId})`, error);
+            }
+            if (!res.headersSent) {
+                sendApiError({ res, status: 500, error: createApiError({ code: 'INTERNAL_ERROR', message: 'an internal error occurred' }, { requestId: correlationId }) });
+            }
+            else if (!res.writableEnded) {
+                res.end();
+            }
+        }
+    });
+}
+/** Mounts `POST /api/proxy/{anthropic,openai,azure,google,ollama}/stream` and the generic `POST /api/proxy/:provider/stream` catch-all. */
+export function registerModelProxyRoutes({ app, deps, adapter }, _optional = {}) {
+    const onInternalError = deps.onInternalError ?? defaultInternalErrorSink;
+    registerProxyStreamRoute(app, '/api/proxy/anthropic/stream', adapter, 'anthropic', onInternalError, parseAnthropicProxyRequest, (parsed, onEvent) => runAnthropicToolTurn({
+        apiKey: parsed.apiKey,
+        model: parsed.model,
+        maxTokens: parsed.maxTokens,
+        messages: parsed.messages,
+        onEvent
+    }, {
+        ...(parsed.baseUrl !== undefined ? { baseUrl: parsed.baseUrl } : {}),
+        ...(parsed.apiVersion !== undefined ? { apiVersion: parsed.apiVersion } : {}),
+        ...(parsed.system !== undefined ? { system: parsed.system } : {}),
+        ...(parsed.tools !== undefined ? { tools: parsed.tools } : {}),
+        ...(parsed.temperature !== undefined ? { temperature: parsed.temperature } : {}),
+        ...(parsed.maxToolTurns !== undefined ? { maxToolTurns: parsed.maxToolTurns } : {}),
+        ...(parsed.extraHeaders !== undefined ? { extraHeaders: parsed.extraHeaders } : {}),
+        ...(deps.fetchImpl ? { fetchImpl: deps.fetchImpl } : {}),
+        ...(deps.dnsLookup ? { dnsLookup: deps.dnsLookup } : {}),
+        ...(deps.anthropicExecuteTool
+            ? {
+                executeTool: (call) => deps.anthropicExecuteTool(call),
+            }
+            : {})
+    }));
+    registerProxyStreamRoute(app, '/api/proxy/openai/stream', adapter, 'openai', onInternalError, parseOpenAiProxyRequest, (parsed, onEvent) => runOpenAiToolTurn({
+        apiKey: parsed.apiKey,
+        model: parsed.model,
+        messages: parsed.messages,
+        onEvent
+    }, {
+        ...(parsed.baseUrl !== undefined ? { baseUrl: parsed.baseUrl } : {}),
+        ...(parsed.tools !== undefined ? { tools: parsed.tools } : {}),
+        ...(parsed.temperature !== undefined ? { temperature: parsed.temperature } : {}),
+        ...(parsed.maxTokens !== undefined ? { maxTokens: parsed.maxTokens } : {}),
+        ...(parsed.maxToolTurns !== undefined ? { maxToolTurns: parsed.maxToolTurns } : {}),
+        ...(parsed.extraHeaders !== undefined ? { extraHeaders: parsed.extraHeaders } : {}),
+        ...(deps.fetchImpl ? { fetchImpl: deps.fetchImpl } : {}),
+        ...(deps.dnsLookup ? { dnsLookup: deps.dnsLookup } : {}),
+        ...(deps.openaiExecuteTool
+            ? {
+                executeTool: (call) => deps.openaiExecuteTool(call),
+            }
+            : {})
+    }));
+    registerProxyStreamRoute(app, '/api/proxy/azure/stream', adapter, 'azure', onInternalError, parseAzureProxyRequest, (parsed, onEvent) => runAzureToolTurn({
+        apiKey: parsed.apiKey,
+        baseUrl: parsed.baseUrl,
+        model: parsed.model,
+        messages: parsed.messages,
+        onEvent
+    }, {
+        apiVersion: parsed.apiVersion,
+        ...(parsed.tools !== undefined ? { tools: parsed.tools } : {}),
+        ...(parsed.temperature !== undefined ? { temperature: parsed.temperature } : {}),
+        ...(parsed.maxTokens !== undefined ? { maxTokens: parsed.maxTokens } : {}),
+        ...(parsed.maxToolTurns !== undefined ? { maxToolTurns: parsed.maxToolTurns } : {}),
+        ...(parsed.extraHeaders !== undefined ? { extraHeaders: parsed.extraHeaders } : {}),
+        ...(deps.fetchImpl ? { fetchImpl: deps.fetchImpl } : {}),
+        ...(deps.dnsLookup ? { dnsLookup: deps.dnsLookup } : {}),
+        ...(deps.azureExecuteTool
+            ? {
+                executeTool: (call) => deps.azureExecuteTool(call),
+            }
+            : {})
+    }));
+    registerProxyStreamRoute(app, '/api/proxy/google/stream', adapter, 'google', onInternalError, parseGoogleProxyRequest, (parsed, onEvent) => runGoogleToolTurn({
+        apiKey: parsed.apiKey,
+        model: parsed.model,
+        contents: parsed.messages,
+        onEvent
+    }, {
+        ...(parsed.baseUrl !== undefined ? { baseUrl: parsed.baseUrl } : {}),
+        ...(parsed.system !== undefined ? { system: parsed.system } : {}),
+        ...(parsed.tools !== undefined ? { tools: parsed.tools } : {}),
+        ...(parsed.temperature !== undefined ? { temperature: parsed.temperature } : {}),
+        ...(parsed.maxOutputTokens !== undefined ? { maxOutputTokens: parsed.maxOutputTokens } : {}),
+        ...(parsed.maxToolTurns !== undefined ? { maxToolTurns: parsed.maxToolTurns } : {}),
+        ...(parsed.extraHeaders !== undefined ? { extraHeaders: parsed.extraHeaders } : {}),
+        ...(deps.fetchImpl ? { fetchImpl: deps.fetchImpl } : {}),
+        ...(deps.dnsLookup ? { dnsLookup: deps.dnsLookup } : {}),
+        ...(deps.googleExecuteTool
+            ? {
+                executeTool: (call) => deps.googleExecuteTool(call),
+            }
+            : {})
+    }));
+    registerProxyStreamRoute(app, '/api/proxy/ollama/stream', adapter, 'ollama', onInternalError, parseOllamaProxyRequest, (parsed, onEvent) => runOllamaToolTurn({
+        apiKey: parsed.apiKey,
+        model: parsed.model,
+        messages: parsed.messages,
+        onEvent
+    }, {
+        ...(parsed.baseUrl !== undefined ? { baseUrl: parsed.baseUrl } : {}),
+        ...(parsed.tools !== undefined ? { tools: parsed.tools } : {}),
+        ...(parsed.temperature !== undefined ? { temperature: parsed.temperature } : {}),
+        ...(parsed.maxTokens !== undefined ? { maxTokens: parsed.maxTokens } : {}),
+        ...(parsed.maxToolTurns !== undefined ? { maxToolTurns: parsed.maxToolTurns } : {}),
+        ...(parsed.extraHeaders !== undefined ? { extraHeaders: parsed.extraHeaders } : {}),
+        ...(deps.fetchImpl ? { fetchImpl: deps.fetchImpl } : {}),
+        ...(deps.dnsLookup ? { dnsLookup: deps.dnsLookup } : {}),
+        ...(deps.ollamaExecuteTool
+            ? {
+                executeTool: (call) => deps.ollamaExecuteTool(call),
+            }
+            : {})
+    }));
+    registerGenericProxyStreamRoute(app, adapter, onInternalError, buildProxyProviderRegistry(deps));
+}
+//# sourceMappingURL=model-proxy.js.map