@jini-ai/daemon 0.6.8 → 0.6.10

package/dist/http/model-proxy.js

@@ -89,15 +89,31 @@ 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';
+import { firstOptionalFieldError, isArray, isNumber, isRecord, isString, nonEmptyString, pickDefined, requiredFieldError, } from './model-proxy-fields.js';
 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;
+const TOOLS_CHECK = ['tools', isArray, 'tools must be an array when provided'];
+const SYSTEM_CHECK = ['system', isString, 'system must be a string when provided'];
+/** The shared optional fields, in the order `parseCommon` reports them. */
+const COMMON_OPTIONAL_CHECKS = [
+    ['baseUrl', isString, 'baseUrl must be a string when provided'],
+    ['temperature', isNumber, 'temperature must be a number when provided'],
+    ['maxTokens', isNumber, 'maxTokens must be a number when provided'],
+    ['maxToolTurns', isNumber, 'maxToolTurns must be a number when provided'],
+    ['extraHeaders', isRecord, 'extraHeaders must be an object when provided'],
+];
+/** The required shared fields, in the order `parseCommon` reports them. */
+function firstRequiredFieldError(body) {
+    if (!nonEmptyString(body.apiKey))
+        return requiredFieldError('apiKey', 'apiKey must be a non-empty string', 'required non-empty string');
+    if (!nonEmptyString(body.model))
+        return requiredFieldError('model', 'model must be a non-empty string', 'required non-empty string');
+    if (!Array.isArray(body.messages) || body.messages.length === 0) {
+        return requiredFieldError('messages', 'messages must be a non-empty array', 'required non-empty array');
+    }
+    return undefined;
 }
 /**
  * Validates only the transport-level shape every proxied request shares
@@ -123,164 +139,101 @@ function nonEmptyString(value) {
 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' }) });
-    }
+    const error = firstRequiredFieldError(body) ?? firstOptionalFieldError(body, COMMON_OPTIONAL_CHECKS);
+    if (error)
+        return err({ error });
     return ok({
         value: {
-            apiKey,
-            model,
+            apiKey: body.apiKey,
+            model: body.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 } : {}),
-        }
+            ...pickDefined(body, COMMON_OPTIONAL_CHECKS.map(([field]) => field)),
+        },
     });
 }
+/** Shared tail of every provider parser: rejects the first badly-typed provider-specific optional field, otherwise returns `base` plus `required` plus whichever of those optional fields are present. */
+function extendParsed({ base, record, checks }, { required = {} } = {}) {
+    const error = firstOptionalFieldError(record, checks);
+    if (error)
+        return err({ error });
+    const optional = pickDefined(record, checks.map(([field]) => field));
+    return ok({ value: { ...base, ...required, ...optional } });
+}
+const ANTHROPIC_OPTIONAL_CHECKS = [
+    ['apiVersion', isString, 'apiVersion must be a string when provided'],
+    SYSTEM_CHECK,
+    TOOLS_CHECK,
+];
+function isPositiveFiniteNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value > 0;
+}
 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 (!isPositiveFiniteNumber(record.maxTokens)) {
+        return err({ error: requiredFieldError('maxTokens', 'maxTokens must be a positive number', 'required positive number') });
     }
-    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 } : {}),
-        }
-    });
+    return extendParsed({ base: common.value, record, checks: ANTHROPIC_OPTIONAL_CHECKS }, { required: { maxTokens: record.maxTokens } });
 }
-function parseOpenAiProxyRequest(body) {
+function parseToolsProxyRequest(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 } : {}),
-        }
-    });
+    return extendParsed({ base: common.value, record: body, checks: [TOOLS_CHECK] });
 }
 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' }] }) });
+    const { baseUrl } = common.value;
+    // Truthiness only, unlike `apiVersion`'s trim check: a whitespace-only baseUrl passes here and
+    // fails inside the turn-runner instead (pinned as "reported, not fixed").
+    if (!baseUrl) {
+        return err({ error: requiredFieldError('baseUrl', 'baseUrl must be a non-empty string', 'required non-empty string') });
     }
-    if (record.tools !== undefined && !Array.isArray(record.tools)) {
-        return err({ error: validationError({ message: 'tools must be an array when provided' }) });
+    const apiVersion = nonEmptyString(record.apiVersion);
+    if (!apiVersion) {
+        return err({ error: requiredFieldError('apiVersion', 'apiVersion must be a non-empty string', 'required non-empty string') });
     }
-    return ok({
-        value: {
-            ...common.value,
-            baseUrl: common.value.baseUrl,
-            apiVersion: record.apiVersion,
-            ...(record.tools !== undefined ? { tools: record.tools } : {}),
-        }
-    });
+    return extendParsed({ base: common.value, record, checks: [TOOLS_CHECK] }, { required: { baseUrl, apiVersion } });
 }
+const GOOGLE_OPTIONAL_CHECKS = [
+    SYSTEM_CHECK,
+    TOOLS_CHECK,
+    ['maxOutputTokens', isNumber, 'maxOutputTokens must be a number when provided'],
+];
 /** `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 } : {}),
-        }
-    });
+    return extendParsed({ base: common.value, record: body, checks: GOOGLE_OPTIONAL_CHECKS });
 }
 /** 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 };
 }
+/** Answers a failure that happened before any SSE stream existed: a redacted JSON 500 if nothing was sent yet, otherwise just end the response (matching `mountJsonRoute`'s own SEC-005 catch). */
+function respondInternalError(res, correlationId) {
+    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();
+    }
+}
 /**
  * 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.
+ * (`provider`, `entry.parse`, `entry.run`) are injected, 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) {
+async function runProxyStream({ req, res, adapter, provider, onInternalError, entry }) {
     // 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.
@@ -292,14 +245,15 @@ async function runProxyStream(req, res, adapter, provider, onInternalError, pars
             sendApiError({ res, status: 403, error: origin.error });
             return;
         }
-        const parsed = parse(req.body);
+        const parsed = entry.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) }));
+        const openChannel = createSseChannel({ res }, { isEndEvent: ({ event }) => event.kind === 'end' });
+        channel = openChannel;
+        openChannel.open();
+        await entry.run(parsed.value, (event) => openChannel.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
@@ -308,176 +262,132 @@ async function runProxyStream(req, res, adapter, provider, onInternalError, pars
     }
     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
+        // function (the 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) {
+        if (!channel) {
             // 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();
+            respondInternalError(res, correlationId);
+            return;
         }
+        // `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' }) });
     }
 }
-/** 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));
+/** Erases one provider's concrete parse/run types into the registry's shared entry shape — the single cast every entry needs. */
+function defineProvider(entry) {
+    return entry;
+}
+/** The test-seam transport options every turn-runner accepts; each is forwarded only when the host supplied it (see `ModelProxyHttpDeps.fetchImpl`). */
+function transportOptions(deps) {
+    return {
+        ...(deps.fetchImpl ? { fetchImpl: deps.fetchImpl } : {}),
+        ...(deps.dnsLookup ? { dnsLookup: deps.dnsLookup } : {}),
+    };
+}
+/** `tools` cast to the turn-runner's own tool-definition type, forwarded only when present (the parser never inspects tool contents — see `parseCommon`). */
+function toolsOption(tools) {
+    return tools !== undefined ? { tools: tools } : {};
 }
-/** 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. */
+/**
+ * Builds the `provider name -> {parse, run}` table that both the five fixed routes and the generic
+ * catch-all dispatch through. Each entry's `run` closure captures `deps` for the optional
+ * `executeTool` wiring and the transport test seams. `executeTool` is a fresh wrapper that calls
+ * `deps.<provider>ExecuteTool` as a method at call time, so the host function sees exactly one
+ * argument.
+ */
 function buildProxyProviderRegistry(deps) {
     return {
-        anthropic: {
+        anthropic: defineProvider({
             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: {
+            run: (parsed, onEvent) => runAnthropicToolTurn({ apiKey: parsed.apiKey, model: parsed.model, maxTokens: parsed.maxTokens, messages: parsed.messages, onEvent }, {
+                ...pickDefined(parsed, ['baseUrl', 'apiVersion', 'system', 'temperature', 'maxToolTurns', 'extraHeaders']),
+                ...toolsOption(parsed.tools),
+                ...transportOptions(deps),
+                ...(deps.anthropicExecuteTool ? { executeTool: (call) => deps.anthropicExecuteTool(call) } : {}),
+            }),
+        }),
+        openai: defineProvider({
+            parse: parseToolsProxyRequest,
+            run: (parsed, onEvent) => runOpenAiToolTurn({ apiKey: parsed.apiKey, model: parsed.model, messages: parsed.messages, onEvent }, {
+                ...pickDefined(parsed, ['baseUrl', 'temperature', 'maxTokens', 'maxToolTurns', 'extraHeaders']),
+                ...toolsOption(parsed.tools),
+                ...transportOptions(deps),
+                ...(deps.openaiExecuteTool ? { executeTool: (call) => deps.openaiExecuteTool(call) } : {}),
+            }),
+        }),
+        azure: defineProvider({
             parse: parseAzureProxyRequest,
-            run: ((parsed, onEvent) => runAzureToolTurn({
-                apiKey: parsed.apiKey,
-                baseUrl: parsed.baseUrl,
-                model: parsed.model,
-                messages: parsed.messages,
-                onEvent
-            }, {
+            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: {
+                ...pickDefined(parsed, ['temperature', 'maxTokens', 'maxToolTurns', 'extraHeaders']),
+                ...toolsOption(parsed.tools),
+                ...transportOptions(deps),
+                ...(deps.azureExecuteTool ? { executeTool: (call) => deps.azureExecuteTool(call) } : {}),
+            }),
+        }),
+        google: defineProvider({
             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) }
-                    : {})
-            })),
-        },
+            run: (parsed, onEvent) => runGoogleToolTurn({ apiKey: parsed.apiKey, model: parsed.model, contents: parsed.messages, onEvent }, {
+                ...pickDefined(parsed, ['baseUrl', 'system', 'temperature', 'maxOutputTokens', 'maxToolTurns', 'extraHeaders']),
+                ...toolsOption(parsed.tools),
+                ...transportOptions(deps),
+                ...(deps.googleExecuteTool ? { executeTool: (call) => deps.googleExecuteTool(call) } : {}),
+            }),
+        }),
+        ollama: defineProvider({
+            parse: parseToolsProxyRequest,
+            run: (parsed, onEvent) => runOllamaToolTurn({ apiKey: parsed.apiKey, model: parsed.model, messages: parsed.messages, onEvent }, {
+                ...pickDefined(parsed, ['baseUrl', 'temperature', 'maxTokens', 'maxToolTurns', 'extraHeaders']),
+                ...toolsOption(parsed.tools),
+                ...transportOptions(deps),
+                ...(deps.ollamaExecuteTool ? { executeTool: (call) => deps.ollamaExecuteTool(call) } : {}),
+            }),
+        }),
     };
 }
-const RECOGNIZED_PROVIDERS = new Set([
-    'anthropic',
-    'openai',
-    'azure',
-    'google',
-    'ollama',
-]);
+/** Fixed-route registration order; load-bearing, since Express matches in registration order and the catch-all must come after all five. */
+const PROXY_PROVIDERS = ['anthropic', 'openai', 'azure', 'google', 'ollama'];
+const RECOGNIZED_PROVIDERS = new Set(PROXY_PROVIDERS);
 function isRecognizedProvider(value) {
     return RECOGNIZED_PROVIDERS.has(value);
 }
+/** Reports a throw from the catch-all before `runProxyStream` took over. */
+function reportCatchAllError(providerParam, onInternalError, error) {
+    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);
+    }
+    return correlationId;
+}
 /**
  * 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) {
+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
@@ -498,145 +408,33 @@ function registerGenericProxyStreamRoute(app, adapter, onInternalError, registry
                 sendApiError({ res, status: 403, error: origin.error });
                 return;
             }
+            // Both checks are needed: `registry` is a plain object, so an inherited key such as
+            // `constructor` yields a truthy `entry` that only the recognized-provider set rejects.
             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);
+            await runProxyStream({ req, res, adapter, provider: providerParam, onInternalError, entry });
         }
         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();
-            }
+            respondInternalError(res, reportCatchAllError(providerParam, onInternalError, error));
         }
     });
 }
 /** 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));
+    const registry = buildProxyProviderRegistry(deps);
+    // Each fixed route is a thin wrapper over `runProxyStream` with `provider` fixed, not read from
+    // `req.params`.
+    for (const provider of PROXY_PROVIDERS) {
+        const entry = registry[provider];
+        app.post(`/api/proxy/${provider}/stream`, (req, res) => runProxyStream({ req, res, adapter, provider, onInternalError, entry }));
+    }
+    registerGenericProxyStreamRoute({ app, adapter, onInternalError, registry });
 }
 //# sourceMappingURL=model-proxy.js.map