@mcoda/codali 0.1.133 → 0.1.135-codali.2

package/dist/providers/ConfiguredProvider.js

@@ -0,0 +1,238 @@
+import { createHash, randomUUID } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import { CryptoHelper, PathHelper, mswarmClientProductHeaders } from "@mcoda/shared";
+import { resolveCredential } from "../runcontext/CredentialFile.js";
+import { resolveBinding } from "../config/OrchestrationConfig.js";
+import { OpenAiCompatibleProvider } from "./OpenAiCompatibleProvider.js";
+import { ModelServiceError } from "./ModelServiceError.js";
+import { registerSecretValue } from "../runtime/SecretRedaction.js";
+export const normalizeModelCaller = (caller = {}) => {
+    const clientIdentity = caller.clientIdentity?.trim();
+    const clientProduct = caller.clientProduct?.trim().toLowerCase() ?? "codali";
+    if (clientIdentity !== undefined && !/^[A-Za-z0-9._:-]{1,128}$/.test(clientIdentity))
+        throw new Error("Invalid model client identity");
+    if (!/^[a-z0-9](?:[a-z0-9_-]{0,62}[a-z0-9])?$/.test(clientProduct))
+        throw new Error("Invalid model client product");
+    return { ...(clientIdentity ? { clientIdentity } : {}), clientProduct };
+};
+const modelCallerHeaders = (caller) => ({
+    ...mswarmClientProductHeaders(caller.clientProduct),
+    ...(caller.clientIdentity ? { "x-mswarm-client-identity": caller.clientIdentity, "x-mswarm-client": caller.clientIdentity } : {}),
+});
+const record = (v) => v && typeof v === "object" && !Array.isArray(v) ? v : {};
+/** Discovery failed before inference; a caller may release its local token reservation. */
+export class NativeReasoningTransportError extends Error {
+    constructor(message) { super(message); this.name = "NativeReasoningTransportError"; }
+}
+export const providerCredential = async (provider) => {
+    if (!provider.credentialRef)
+        return undefined;
+    const name = provider.credentialRef.slice(4);
+    const direct = resolveCredential(name);
+    if (direct) {
+        registerSecretValue(direct);
+        return direct;
+    }
+    if (provider.adapter === "mswarm" && resolveCredential("CODALI_MSWARM_LOGGED_OUT") === "1")
+        throw new Error("Logged out; use codali login");
+    // Migrate by reading the existing user store; never read repository credentials.
+    if (provider.adapter === "mswarm" && name === "MCODA_MSWARM_API_KEY") {
+        try {
+            const config = JSON.parse(await readFile(PathHelper.getGlobalConfigPath(), "utf8"));
+            const existing = config.mswarm;
+            if (existing?.encryptedApiKey && new URL(existing.baseUrl ?? "https://api.mswarm.org").origin === new URL(provider.baseUrl).origin) {
+                const key = await CryptoHelper.decryptSecret(existing.encryptedApiKey);
+                registerSecretValue(key);
+                return key;
+            }
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw new Error("Stored mSwarm credentials could not be loaded; use codali login");
+        }
+    }
+    throw new Error(`Missing credential ${name}; use codali login or set the environment variable`);
+};
+export class ModelServiceClient {
+    constructor(provider, credentialOverride, caller) {
+        this.provider = provider;
+        this.credentialOverride = credentialOverride;
+        this.caller = normalizeModelCaller(caller);
+        if (credentialOverride)
+            registerSecretValue(credentialOverride);
+    }
+    credential() { return this.credentialOverride === undefined ? providerCredential(this.provider) : Promise.resolve(this.credentialOverride); }
+    async json(url, options = {}) {
+        if (new URL(url).origin !== new URL(this.provider.baseUrl).origin)
+            throw new Error("Refusing credentials to an unconfigured origin");
+        const key = await this.credential();
+        const controller = new AbortController();
+        const abort = () => controller.abort(options.signal?.reason);
+        options.signal?.throwIfAborted();
+        options.signal?.addEventListener("abort", abort, { once: true });
+        const timer = setTimeout(() => controller.abort(new Error("Service request timed out")), options.timeoutMs ?? 30000);
+        try {
+            const response = await fetch(url, {
+                redirect: "error", method: options.method ?? "GET", signal: controller.signal,
+                headers: { accept: "application/json", ...(key ? this.provider.adapter === "mswarm" ? { "x-api-key": key } : { authorization: `Bearer ${key}` } : {}), ...(this.provider.adapter === "mswarm" ? modelCallerHeaders(this.caller) : {}), ...(options.body ? { "content-type": "application/json" } : {}) },
+                body: options.body === undefined ? undefined : JSON.stringify(options.body),
+            });
+            if (!response.ok)
+                throw await ModelServiceError.fromResponse(response);
+            if (!response.body)
+                throw new Error("Empty service response");
+            const reader = response.body.getReader();
+            const chunks = [];
+            let size = 0;
+            try {
+                while (true) {
+                    const next = await reader.read();
+                    if (next.done)
+                        break;
+                    size += next.value.byteLength;
+                    if (size > 96 * 1024 * 1024) {
+                        await reader.cancel();
+                        throw new Error("Service response exceeds size limit");
+                    }
+                    chunks.push(next.value);
+                }
+            }
+            finally {
+                reader.releaseLock();
+            }
+            return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+        }
+        finally {
+            clearTimeout(timer);
+            options.signal?.removeEventListener("abort", abort);
+        }
+    }
+    async catalog(signal, refresh = false) {
+        const credential = await this.credential();
+        const key = createHash("sha256").update(credential ?? "anonymous").digest("hex");
+        if (!refresh && this.cache?.key === key && this.cache.expires > Date.now())
+            return this.cache.entries;
+        const base = new URL(this.provider.baseUrl);
+        const url = this.provider.catalogUrl ?? (this.provider.adapter === "mswarm" ? new URL("/v1/swarm/self-hosted/agents", base).toString() : `${this.provider.baseUrl.replace(/\/$/, "")}/models`);
+        const payload = record(await this.json(url, { signal }));
+        const items = payload.agents ?? payload.data;
+        if (!Array.isArray(items))
+            throw new Error("Invalid model catalog response");
+        const entries = items.map(item => {
+            const raw = record(item);
+            const aliases = [raw.slug, raw.public_model_id, raw.default_model, raw.id].filter((v) => typeof v === "string" && !!v);
+            return { id: aliases[0] ?? "", aliases, backend: raw.adapter === "strata-local" ? "strata" : typeof raw.backend === "string" ? raw.backend : typeof raw.adapter === "string" ? raw.adapter : undefined,
+                health: String(raw.health_status ?? "unknown"), supportsTools: raw.supports_tools === true,
+                contextWindow: typeof raw.context_window === "number" ? raw.context_window : undefined,
+                operations: Array.isArray(raw.operations) ? raw.operations.map(v => typeof v === "string" ? v : String(record(v).type ?? "")) : [], raw };
+        }).filter(x => x.id);
+        this.cache = { key, expires: Date.now() + 30000, entries };
+        return entries;
+    }
+    async usage(signal) {
+        if (this.provider.adapter !== "mswarm" && !this.provider.usageUrl)
+            return { available: false };
+        return this.json(this.provider.usageUrl ?? new URL("/v1/swarm/runtime/usage-limits", this.provider.baseUrl).toString(), { signal });
+    }
+    /** The proxy and selected node must both advertise this transport contract.
+     * A model's supports_reasoning flag alone says nothing about request forwarding. */
+    async requireNativeReasoning(modelId, parameters, signal) {
+        if (this.provider.adapter !== "mswarm" || parameters.length === 0)
+            return;
+        const endpoint = new URL(this.provider.baseUrl);
+        endpoint.pathname = endpoint.pathname.replace(/\/$/, "");
+        endpoint.pathname = ["", "/v1"].includes(endpoint.pathname)
+            ? "/v1/swarm/self-hosted/openai/models" : `${endpoint.pathname}/models`;
+        const payload = record(await this.json(endpoint.href, { signal }).catch(error => {
+            throw new NativeReasoningTransportError(`Native reasoning preflight failed before inference: ${error instanceof Error ? error.message : String(error)}`);
+        }));
+        const models = Array.isArray(payload.data) ? payload.data.map(record) : [];
+        const model = models.find(item => [item.id, item.agent_slug, item.remote_slug].includes(modelId));
+        const contract = record(model?.native_reasoning);
+        const supported = Array.isArray(contract.parameters) ? contract.parameters : [];
+        if (contract.transport_version !== 1 || parameters.some(parameter => !supported.includes(parameter))) {
+            throw new NativeReasoningTransportError(`Native reasoning transport is unavailable for ${modelId}; upgrade the mSwarm proxy and selected node, or remove unsupported native reasoning settings from the configuration`);
+        }
+    }
+}
+export class ConfiguredProvider {
+    constructor(resolved, binding = "lead", options = {}) {
+        this.resolved = resolved;
+        this.binding = binding;
+        this.options = options;
+        this.name = "configured";
+        this.supportsToolCalls = true;
+        this.clients = new Map();
+        this.caller = normalizeModelCaller(options.caller);
+        this.credentials = Object.freeze(Object.assign(Object.create(null), options.credentials));
+        for (const [id, credential] of Object.entries(this.credentials)) {
+            if (!Object.prototype.hasOwnProperty.call(resolved.config.providers, id) || typeof credential !== "string" || !credential.trim())
+                throw new Error("Invalid host provider credential mapping");
+            registerSecretValue(credential);
+        }
+    }
+    client(providerId) {
+        const provider = this.resolved.config.providers[providerId];
+        if (!provider)
+            throw new Error(`Unknown configured provider: ${providerId}`);
+        if (!this.clients.has(providerId))
+            this.clients.set(providerId, new ModelServiceClient(provider, this.credentials[providerId], this.caller));
+        return this.clients.get(providerId);
+    }
+    async select(operation, signal, requireTools = false) {
+        const candidates = resolveBinding(this.resolved.config, this.binding, operation);
+        const reasons = [];
+        for (const candidate of candidates) {
+            const { id, model } = candidate;
+            const catalog = await this.client(model.provider).catalog(signal);
+            const actual = catalog.find(entry => entry.aliases.includes(model.catalogId));
+            if (!actual) {
+                reasons.push(`${id}: not entitled/advertised`);
+                continue;
+            }
+            if (!["healthy", "unknown", "ready"].includes(actual.health)) {
+                reasons.push(`${id}: ${actual.health}`);
+                continue;
+            }
+            if (model.backend && actual.backend !== model.backend) {
+                reasons.push(`${id}: backend identity not verified`);
+                continue;
+            }
+            if (actual.operations.length && !actual.operations.includes(operation)) {
+                reasons.push(`${id}: unsupported operation`);
+                continue;
+            }
+            if (requireTools && (!model.supportsTools || this.resolved.config.providers[model.provider].adapter === "mswarm" && !actual.supportsTools)) {
+                reasons.push(`${id}: tools unavailable`);
+                continue;
+            }
+            return { id, model, actual, provider: this.resolved.config.providers[model.provider] };
+        }
+        throw new Error(`No eligible configured ${this.binding} route: ${reasons.join("; ")}`);
+    }
+    async generate(request) {
+        request.signal?.throwIfAborted();
+        const { id, model, provider, actual } = await this.select("chat.completions", request.signal, !!request.tools?.length);
+        const invocation = { id: randomUUID(), binding: this.binding, configHash: this.resolved.hash, modelId: id, catalogId: model.catalogId, backend: actual.backend, host: model.host };
+        const nativeReasoning = this.options.effort ? model.reasoning?.[this.options.effort] : undefined;
+        if (nativeReasoning)
+            invocation.nativeReasoningRequest = { ...nativeReasoning };
+        if (nativeReasoning)
+            await this.client(model.provider).requireNativeReasoning(model.catalogId, Object.keys(nativeReasoning), request.signal);
+        const maxTokens = Math.min(request.maxTokens ?? model.maxOutputTokens, model.maxOutputTokens);
+        const inputEstimate = Math.ceil(JSON.stringify([request.messages, request.tools]).length / 3);
+        if (inputEstimate + maxTokens > Math.min(model.contextWindow, actual.contextWindow ?? model.contextWindow))
+            throw new Error("Context budget exceeded; checkpoint and compact before continuing");
+        const bounded = { ...request, maxTokens, stream: request.stream === true && model.supportsStreaming === true };
+        await this.options.beforeRequest?.(invocation, bounded);
+        const adapter = new OpenAiCompatibleProvider({
+            model: model.catalogId, baseUrl: provider.baseUrl, apiKey: this.credentials[model.provider] ?? await providerCredential(provider), timeoutMs: 300000,
+            supportsStreaming: model.supportsStreaming ?? true, supportsTools: model.supportsTools,
+            headers: provider.adapter === "mswarm" ? modelCallerHeaders(this.caller) : undefined, retryTransient: false,
+            extraBody: nativeReasoning,
+        });
+        const result = await adapter.generate(bounded);
+        await this.options.afterRequest?.(invocation, result);
+        return { ...result, route: invocation };
+    }
+}

package/dist/providers/ModelServiceError.d.ts

@@ -0,0 +1,10 @@
+export type ModelServiceErrorCode = "authentication_failed" | "entitlement_missing" | "quota_exhausted" | "rate_limited" | "service_unavailable" | "model_unavailable" | "invalid_request";
+/** Transport diagnostics contain stable classifications, never an upstream body. */
+export declare class ModelServiceError extends Error {
+    readonly code: ModelServiceErrorCode;
+    readonly status: number;
+    readonly retryAfterSeconds?: number | undefined;
+    constructor(code: ModelServiceErrorCode, status: number, retryAfterSeconds?: number | undefined);
+    static fromResponse(response: Response): Promise<ModelServiceError>;
+}
+//# sourceMappingURL=ModelServiceError.d.ts.map

package/dist/providers/ModelServiceError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ModelServiceError.d.ts","sourceRoot":"","sources":["../../src/providers/ModelServiceError.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,qBAAqB,GAAG,uBAAuB,GAAG,qBAAqB,GAAG,iBAAiB,GAAG,cAAc,GAAG,qBAAqB,GAAG,mBAAmB,GAAG,iBAAiB,CAAC;AAE3L,oFAAoF;AACpF,qBAAa,iBAAkB,SAAQ,KAAK;IAC9B,QAAQ,CAAC,IAAI,EAAE,qBAAqB;IAAE,QAAQ,CAAC,MAAM,EAAE,MAAM;IAAE,QAAQ,CAAC,iBAAiB,CAAC,EAAE,MAAM;gBAAzF,IAAI,EAAE,qBAAqB,EAAW,MAAM,EAAE,MAAM,EAAW,iBAAiB,CAAC,EAAE,MAAM,YAAA;WAKjG,YAAY,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC,iBAAiB,CAAC;CAoB1E"}

package/dist/providers/ModelServiceError.js

@@ -0,0 +1,45 @@
+/** Transport diagnostics contain stable classifications, never an upstream body. */
+export class ModelServiceError extends Error {
+    constructor(code, status, retryAfterSeconds) {
+        super(`Model service HTTP ${status}: ${code}${code === "authentication_failed" ? "; authenticate with codali login" : ""}`);
+        this.code = code;
+        this.status = status;
+        this.retryAfterSeconds = retryAfterSeconds;
+        this.name = "ModelServiceError";
+    }
+    static async fromResponse(response) {
+        let serverCode = "";
+        if (response.body) {
+            const reader = response.body.getReader();
+            const chunks = [];
+            let bytes = 0;
+            try {
+                while (true) {
+                    const part = await reader.read();
+                    if (part.done)
+                        break;
+                    bytes += part.value.byteLength;
+                    if (bytes > 8192)
+                        break;
+                    chunks.push(part.value);
+                }
+                const payload = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+                if (typeof (payload.error?.code ?? payload.code) === "string")
+                    serverCode = String(payload.error?.code ?? payload.code);
+            }
+            catch { /* The status still supplies a safe classification. */ }
+            finally {
+                await reader.cancel().catch(() => undefined);
+                reader.releaseLock();
+            }
+        }
+        const code = response.status === 401 ? "authentication_failed"
+            : response.status === 403 ? "entitlement_missing"
+                : ["quota_exceeded", "quota_exhausted", "insufficient_quota", "credits_exhausted", "insufficient_credits"].includes(serverCode) || response.status === 402 ? "quota_exhausted"
+                    : response.status === 429 ? "rate_limited"
+                        : response.status === 404 ? "model_unavailable"
+                            : response.status >= 500 ? "service_unavailable" : "invalid_request";
+        const retry = Number(response.headers.get("retry-after"));
+        return new ModelServiceError(code, response.status, response.headers.has("retry-after") && Number.isFinite(retry) && retry >= 0 ? Math.min(retry, 3600) : undefined);
+    }
+}

package/dist/providers/MswarmWorkerProvider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MswarmWorkerProvider.d.ts","sourceRoot":"","sources":["../../src/providers/MswarmWorkerProvider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,QAAQ,EAER,eAAe,EACf,gBAAgB,EAEjB,MAAM,oBAAoB,CAAC;AA8C5B,qBAAa,oBAAqB,YAAW,QAAQ;IAQvC,OAAO,CAAC,QAAQ,CAAC,MAAM;IAPnC,+EAA+E;IAC/E,QAAQ,CAAC,iBAAiB,SAAS;IAEnC,QAAQ,CAAC,IAAI,mBAAmB;IAChC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;gBAEH,MAAM,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE;IAWvG,QAAQ,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,gBAAgB,CAAC;CA+DpE"}
+{"version":3,"file":"MswarmWorkerProvider.d.ts","sourceRoot":"","sources":["../../src/providers/MswarmWorkerProvider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,QAAQ,EAER,eAAe,EACf,gBAAgB,EAEjB,MAAM,oBAAoB,CAAC;AA8C5B,qBAAa,oBAAqB,YAAW,QAAQ;IAQvC,OAAO,CAAC,QAAQ,CAAC,MAAM;IAPnC,+EAA+E;IAC/E,QAAQ,CAAC,iBAAiB,SAAS;IAEnC,QAAQ,CAAC,IAAI,mBAAmB;IAChC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;gBAEH,MAAM,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE;IAWvG,QAAQ,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,gBAAgB,CAAC;CAmEpE"}

package/dist/providers/MswarmWorkerProvider.js

@@ -52,7 +52,10 @@ export class MswarmWorkerProvider {
         this.apiKey = config.apiKey;
     }
     async generate(request) {
+        request.signal?.throwIfAborted();
         const controller = new AbortController();
+        const onAbort = () => controller.abort(request.signal?.reason);
+        request.signal?.addEventListener("abort", onAbort, { once: true });
         const timeout = this.config.timeoutMs && this.config.timeoutMs > 0
             ? setTimeout(() => controller.abort(), this.config.timeoutMs)
             : undefined;
@@ -106,6 +109,7 @@ export class MswarmWorkerProvider {
             };
         }
         finally {
+            request.signal?.removeEventListener("abort", onAbort);
             if (timeout) {
                 clearTimeout(timeout);
             }

package/dist/providers/OpenAiCompatibleProvider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"OpenAiCompatibleProvider.d.ts","sourceRoot":"","sources":["../../src/providers/OpenAiCompatibleProvider.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EACV,QAAQ,EACR,cAAc,EAEd,eAAe,EACf,gBAAgB,EAGjB,MAAM,oBAAoB,CAAC;AAgJ5B,eAAO,MAAM,uBAAuB,GAClC,KAAK,MAAM,EACX,MAAM,WAAW,EACjB,aAAa,eAAe,KAC3B,OAAO,CAAC,QAAQ,CAclB,CAAC;AAEF,qBAAa,wBAAyB,YAAW,QAAQ;IAS3C,OAAO,CAAC,MAAM;IAR1B,+EAA+E;IAC/E,QAAQ,CAAC,iBAAiB,QAAQ;IAElC,IAAI,SAAuB;IAC3B,OAAO,CAAC,WAAW,CAAoC;IACvD,OAAO,CAAC,QAAQ,CAAsB;IACtC,OAAO,CAAC,sBAAsB,CAAoC;gBAE9C,MAAM,EAAE,cAAc;IAWpC,QAAQ,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAiNnE,OAAO,CAAC,WAAW;CA0BpB"}
+{"version":3,"file":"OpenAiCompatibleProvider.d.ts","sourceRoot":"","sources":["../../src/providers/OpenAiCompatibleProvider.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EACV,QAAQ,EACR,cAAc,EAEd,eAAe,EACf,gBAAgB,EAGjB,MAAM,oBAAoB,CAAC;AAkK5B,eAAO,MAAM,uBAAuB,GAClC,KAAK,MAAM,EACX,MAAM,WAAW,EACjB,aAAa,eAAe,KAC3B,OAAO,CAAC,QAAQ,CAclB,CAAC;AAEF,qBAAa,wBAAyB,YAAW,QAAQ;IAS3C,OAAO,CAAC,MAAM;IAR1B,+EAA+E;IAC/E,QAAQ,CAAC,iBAAiB,QAAQ;IAElC,IAAI,SAAuB;IAC3B,OAAO,CAAC,WAAW,CAAoC;IACvD,OAAO,CAAC,QAAQ,CAAsB;IACtC,OAAO,CAAC,sBAAsB,CAAoC;gBAE9C,MAAM,EAAE,cAAc;IAWpC,QAAQ,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAoPnE,OAAO,CAAC,WAAW;CA0BpB"}

package/dist/providers/OpenAiCompatibleProvider.js

@@ -1,4 +1,5 @@
 import { normalizeLocalOpenAiCompatibleRunnerConfig, } from "@mcoda/shared";
+import { ModelServiceError } from "./ModelServiceError.js";
 const parseToolArgs = (raw) => {
     try {
         return JSON.parse(raw);
@@ -7,6 +8,11 @@ const parseToolArgs = (raw) => {
         return raw;
     }
 };
+// JSON permits lone UTF-16 surrogates, but native tokenizers often require
+// Unicode scalar values. Keep their visible source spelling in model context
+// instead of losing them to replacement characters. With /u, valid pairs are
+// matched as one astral code point and are therefore outside this range.
+const modelContextText = (value) => value.replace(/[\uD800-\uDFFF]/gu, (unit) => `\\u${unit.charCodeAt(0).toString(16).padStart(4, "0")}`);
 const normalizeBaseUrl = (baseUrl) => {
     const root = baseUrl ?? "https://api.openai.com/v1";
     return root.endsWith("/") ? root : `${root}/`;
@@ -45,7 +51,16 @@ const toResponseFormat = (format, strategy = "openai") => {
         return { type: "json_object" };
     }
     if (format.type === "json_schema") {
-        return { type: "json_schema", json_schema: format.schema ?? {} };
+        const schema = format.schema ?? {};
+        // ProviderResponseFormat carries a JSON Schema; OpenAI-compatible servers
+        // require it inside a named json_schema envelope. Preserve callers that
+        // already supply that envelope.
+        const wrapped = typeof schema.name === "string" &&
+            schema.schema !== null && typeof schema.schema === "object";
+        return {
+            type: "json_schema",
+            json_schema: wrapped ? schema : { name: "codali_response", schema },
+        };
     }
     if (format.type === "text") {
         return { type: "text" };
@@ -139,6 +154,7 @@ export class OpenAiCompatibleProvider {
         this.responseFormatStrategy = normalizedLocal.config.responseFormatStrategy ?? "openai";
     }
     async generate(request) {
+        request.signal?.throwIfAborted();
         const baseUrl = normalizeBaseUrl(this.localRunner.baseUrl ?? this.config.baseUrl);
         const url = new URL("chat/completions", baseUrl).toString();
         const auth = this.resolveAuth();
@@ -159,12 +175,29 @@ export class OpenAiCompatibleProvider {
             : undefined;
         const messages = request.messages.map((message) => ({
             role: message.role,
-            content: message.content,
+            content: modelContextText(message.content),
             name: message.name,
             tool_call_id: message.toolCallId,
+            tool_calls: message.toolCalls?.map((call) => ({
+                id: call.id,
+                type: "function",
+                function: {
+                    name: call.name,
+                    arguments: typeof call.args === "string" ? modelContextText(call.args) : JSON.stringify(call.args ?? {}),
+                },
+            })),
         }));
         if (promptOnlyInstruction) {
-            messages.unshift({ role: "system", content: promptOnlyInstruction });
+            // Local chat templates may accept only one initial system message.
+            if (messages[0]?.role === "system") {
+                messages[0] = {
+                    ...messages[0],
+                    content: `${messages[0].content}\n\n${promptOnlyInstruction}`,
+                };
+            }
+            else {
+                messages.unshift({ role: "system", content: promptOnlyInstruction });
+            }
         }
         const body = {
             ...(this.localRunner.requireModelInRequest === false ? {} : { model: this.config.model }),
@@ -173,7 +206,7 @@ export class OpenAiCompatibleProvider {
                 type: "function",
                 function: {
                     name: tool.name,
-                    description: tool.description,
+                    description: tool.description === undefined ? undefined : modelContextText(tool.description),
                     parameters: tool.inputSchema ?? {},
                 },
             })),
@@ -202,20 +235,23 @@ export class OpenAiCompatibleProvider {
             }
         }
         const controller = new AbortController();
+        const onAbort = () => controller.abort(request.signal?.reason);
+        request.signal?.addEventListener("abort", onAbort, { once: true });
         const timeoutMs = this.config.timeoutMs ?? 60000;
         const timeout = setTimeout(() => controller.abort(), timeoutMs);
         try {
-            const response = await fetchWithTransientRetry(url, {
+            const requestFetch = this.config.retryTransient === false ? (url, init) => fetch(url, init) : fetchWithTransientRetry;
+            const response = await requestFetch(url, {
                 method: "POST",
                 headers,
                 body: JSON.stringify(body),
                 signal: controller.signal,
+                redirect: "error",
             }, controller);
             if (!response.ok) {
-                const errorBody = await response.text();
-                throw new Error(`OpenAI-compatible error ${response.status}: ${errorBody}`);
+                throw await ModelServiceError.fromResponse(response);
             }
-            if (request.stream) {
+            if (request.stream && !response.headers.get("content-type")?.includes("application/json")) {
                 if (!response.body) {
                     throw new Error("OpenAI-compatible streaming response missing body");
                 }
@@ -223,55 +259,85 @@ export class OpenAiCompatibleProvider {
                 const decoder = new TextDecoder();
                 let buffer = "";
                 let content = "";
+                let ended = false;
+                let finishReason;
                 const toolCallMap = new Map();
                 let usage;
-                while (true) {
-                    const { value, done } = await reader.read();
-                    if (done)
-                        break;
-                    buffer += decoder.decode(value, { stream: true });
-                    const lines = buffer.split("\n");
-                    buffer = lines.pop() ?? "";
-                    for (const line of lines) {
-                        const trimmed = line.trim();
-                        if (!trimmed.startsWith("data:"))
-                            continue;
-                        const data = trimmed.slice(5).trim();
-                        if (!data || data === "[DONE]")
-                            continue;
-                        try {
-                            const chunk = JSON.parse(data);
-                            const delta = chunk.choices?.[0]?.delta;
-                            if (delta?.content) {
-                                content += delta.content;
-                                emitToken(delta.content);
-                            }
-                            if (Array.isArray(delta?.tool_calls)) {
-                                for (const call of delta.tool_calls) {
-                                    const index = call.index ?? 0;
-                                    const existing = toolCallMap.get(index) ?? {
-                                        id: call.id ?? `call_${index + 1}`,
-                                        name: "",
-                                        args: "",
-                                    };
-                                    if (call.function?.name) {
-                                        existing.name = call.function.name;
-                                    }
-                                    if (typeof call.function?.arguments === "string") {
-                                        existing.args += call.function.arguments;
-                                    }
-                                    toolCallMap.set(index, existing);
-                                }
-                            }
-                            if (chunk.usage) {
-                                usage = chunk.usage;
-                            }
+                const consume = (line) => {
+                    const trimmed = line.trim();
+                    if (!trimmed.startsWith("data:"))
+                        return;
+                    const data = trimmed.slice(5).trim();
+                    if (!data)
+                        return;
+                    if (data === "[DONE]") {
+                        ended = true;
+                        return;
+                    }
+                    const chunk = JSON.parse(data);
+                    if (chunk.error) {
+                        const detail = typeof chunk.error === "string" ? chunk.error : JSON.stringify(chunk.error);
+                        throw new Error(`OpenAI-compatible stream error: ${this.config.apiKey ? detail.split(this.config.apiKey).join("[redacted]").slice(0, 600) : detail.slice(0, 600)}`);
+                    }
+                    const delta = chunk.choices?.[0]?.delta;
+                    if (typeof chunk.choices?.[0]?.finish_reason === "string")
+                        finishReason = chunk.choices[0].finish_reason;
+                    if (typeof delta?.content === "string") {
+                        content += delta.content;
+                        if (content.length > 4000000)
+                            throw new Error("Model stream exceeds output limit");
+                        emitToken(delta.content);
+                    }
+                    if (Array.isArray(delta?.tool_calls))
+                        for (const call of delta.tool_calls) {
+                            const index = call.index ?? 0;
+                            if (!Number.isInteger(index) || index < 0 || index > 128)
+                                throw new Error("Invalid streamed tool index");
+                            const existing = toolCallMap.get(index) ?? { id: call.id ?? `call_${index + 1}`, name: "", args: "" };
+                            if (typeof call.id === "string")
+                                existing.id = call.id;
+                            if (typeof call.function?.name === "string")
+                                existing.name = call.function.name;
+                            if (typeof call.function?.arguments === "string")
+                                existing.args += call.function.arguments;
+                            if (existing.args.length > 2000000)
+                                throw new Error("Tool arguments exceed stream limit");
+                            toolCallMap.set(index, existing);
                         }
-                        catch {
-                            // ignore malformed chunks
+                    if (chunk.usage)
+                        usage = chunk.usage;
+                };
+                try {
+                    while (true) {
+                        const { value, done } = await reader.read();
+                        if (done) {
+                            buffer += decoder.decode();
+                            if (buffer.trim())
+                                consume(buffer);
+                            break;
                         }
+                        buffer += decoder.decode(value, { stream: true });
+                        if (buffer.length > 2000000)
+                            throw new Error("Model stream frame exceeds limit");
+                        const lines = buffer.split("\n");
+                        buffer = lines.pop() ?? "";
+                        for (const line of lines)
+                            consume(line);
                     }
                 }
+                finally {
+                    await reader.cancel().catch(() => undefined);
+                    reader.releaseLock();
+                }
+                if ((!ended && !finishReason) || finishReason === "length")
+                    throw new Error("Model stream ended before a complete response");
+                if (!content && !toolCallMap.size)
+                    throw new Error("Model stream returned no content or tool calls");
+                for (const call of toolCallMap.values()) {
+                    if (!call.name || !call.id)
+                        throw new Error("Incomplete streamed tool call");
+                    JSON.parse(call.args);
+                }
                 const toolCalls = toolCallMap.size > 0
                     ? Array.from(toolCallMap.entries()).map(([index, call]) => ({
                         id: call.id ?? `call_${index + 1}`,
@@ -293,7 +359,22 @@ export class OpenAiCompatibleProvider {
                 };
             }
             const raw = (await response.json());
-            const choice = raw.choices[0]?.message;
+            // A relay can send HTTP 200 keepalives before inference fails. Inspect
+            // the final envelope instead of treating those headers as success.
+            if (raw?.error) {
+                const error = raw.error;
+                const record = typeof error === "object" && error !== null
+                    ? error
+                    : {};
+                const detail = typeof error === "string" ? error
+                    : typeof record.message === "string" ? record.message : "Model gateway failed";
+                const code = typeof record.code === "string" ? record.code : "upstream_error";
+                const message = `OpenAI-compatible error ${code}: ${detail}`;
+                const redacted = this.config.apiKey
+                    ? message.split(this.config.apiKey).join("[redacted]") : message;
+                throw new Error(redacted.slice(0, 600));
+            }
+            const choice = raw?.choices?.[0]?.message;
             if (!choice) {
                 throw new Error("OpenAI-compatible response missing choices");
             }
@@ -319,6 +400,7 @@ export class OpenAiCompatibleProvider {
             };
         }
         finally {
+            request.signal?.removeEventListener("abort", onAbort);
             clearTimeout(timeout);
         }
     }

package/dist/providers/ProviderTypes.d.ts

@@ -43,6 +43,8 @@ export interface ProviderMessage {
     content: string;
     name?: string;
     toolCallId?: string;
+    /** Assistant calls retained alongside the matching tool result messages. */
+    toolCalls?: ProviderToolCall[];
 }
 export interface ProviderUsage {
     inputTokens?: number;
@@ -50,6 +52,7 @@ export interface ProviderUsage {
     totalTokens?: number;
 }
 export interface ProviderRequest {
+    signal?: AbortSignal;
     messages: ProviderMessage[];
     tools?: ProviderToolDefinition[];
     toolChoice?: "auto" | "none" | {
@@ -68,8 +71,19 @@ export interface ProviderResponse {
     toolCalls?: ProviderToolCall[];
     usage?: ProviderUsage;
     raw?: unknown;
+    /** Selected configured route; host labels are configuration metadata, not hardware attestation. */
+    route?: {
+        id: string;
+        binding: string;
+        configHash: string;
+        modelId: string;
+        catalogId: string;
+        backend?: string;
+        host?: string;
+    };
 }
 export interface ProviderConfig {
+    retryTransient?: boolean;
     model: string;
     /** Agent this provider serves, so failures can name it. */
     agentSlug?: string;