@abot-ai/runtime 1.9.0 → 2.0.0

package/dist/src/model-gateway/observability/input-token-count-diagnostics.js

@@ -0,0 +1,178 @@
+import { randomUUID } from "node:crypto";
+import { traceDebug } from "../../runtime/observability/debug-logger.js";
+import { classifyRuntimeErrorType } from "../../runtime/observability/error-type.js";
+const TRANSPORT_CODES = new Set([
+    "ETIMEDOUT", "ECONNRESET", "ECONNREFUSED", "ECONNABORTED", "EPIPE",
+    "ENOTFOUND", "EAI_AGAIN", "ENETUNREACH", "EHOSTUNREACH",
+    "UND_ERR_CONNECT_TIMEOUT", "UND_ERR_HEADERS_TIMEOUT", "UND_ERR_BODY_TIMEOUT",
+    "UND_ERR_SOCKET", "UND_ERR_ABORTED", "ABORT_ERR", "ERR_INVALID_URL",
+    "CERT_HAS_EXPIRED", "DEPTH_ZERO_SELF_SIGNED_CERT", "UNABLE_TO_VERIFY_LEAF_SIGNATURE",
+]);
+function boundedDiagnosticId(value) {
+    if (typeof value !== "string")
+        return undefined;
+    if (!/^[a-zA-Z0-9_.:/-]{1,200}$/.test(value))
+        return undefined;
+    return value;
+}
+function record(value) {
+    if (value === null || typeof value !== "object")
+        return {};
+    return value;
+}
+function serializedBytes(value) {
+    try {
+        const serialized = JSON.stringify(value);
+        if (serialized === undefined)
+            return undefined;
+        return Buffer.byteLength(serialized);
+    }
+    catch {
+        return undefined;
+    }
+}
+function countRequestShape(request) {
+    const messages = Array.isArray(request.messages) ? request.messages : [];
+    let contentChars = 0;
+    let toolCallCount = 0;
+    let toolResultCount = 0;
+    let attachmentCount = 0;
+    for (const item of messages) {
+        const message = record(item);
+        if (typeof message.content === "string")
+            contentChars += message.content.length;
+        if (Array.isArray(message.toolCalls))
+            toolCallCount += message.toolCalls.length;
+        if (message.role === "tool")
+            toolResultCount += 1;
+        if (Array.isArray(message.attachments))
+            attachmentCount += message.attachments.length;
+    }
+    return {
+        messageCount: messages.length, contentChars, toolCallCount, toolResultCount,
+        attachmentCount, requestBytes: serializedBytes(request),
+        formatBytes: serializedBytes(request.format),
+    };
+}
+/** Only trusted classifications and allowlisted transport codes leave error objects. */
+function countErrorDetails(error) {
+    const pending = [
+        { value: error, relation: "error", depth: 0 },
+    ];
+    const seen = new Set();
+    const entries = [];
+    while (pending.length > 0 && entries.length < 8) {
+        const current = pending.shift();
+        if (seen.has(current.value))
+            continue;
+        seen.add(current.value);
+        const value = record(current.value);
+        const code = typeof value.code === "string" && TRANSPORT_CODES.has(value.code)
+            ? value.code : undefined;
+        const aggregate = current.value instanceof AggregateError ? current.value : undefined;
+        entries.push({
+            relation: current.relation,
+            type: aggregate ? "AggregateError" : classifyRuntimeErrorType(current.value),
+            ...(code ? { code } : {}),
+            ...(typeof value.errno === "number" && Number.isSafeInteger(value.errno)
+                ? { errno: value.errno } : {}),
+            ...(aggregate ? { aggregateErrorCount: aggregate.errors.length } : {}),
+        });
+        if (current.depth >= 2)
+            continue;
+        if (value.cause !== undefined) {
+            pending.push({ value: value.cause, relation: "cause", depth: current.depth + 1 });
+        }
+        if (!aggregate)
+            continue;
+        for (const inner of aggregate.errors.slice(0, 4)) {
+            pending.push({ value: inner, relation: "aggregate", depth: current.depth + 1 });
+        }
+    }
+    return entries;
+}
+/** Request-local metadata only. It never reads response bodies or alters failures. */
+export class InputTokenCountDiagnostics {
+    scope;
+    requestBody;
+    startedAt = Date.now();
+    diagnosticId = randomUUID();
+    phase = "prepare";
+    invocation;
+    provider;
+    upstream = {};
+    constructor(scope, requestBody) {
+        this.scope = scope;
+        this.requestBody = requestBody;
+    }
+    setPhase(phase) { this.phase = phase; }
+    setProvider(provider) { this.provider = provider; }
+    bindInvocation(invocation) { this.invocation = invocation; }
+    observeFetch(fetchImpl) {
+        return async (input, init) => {
+            const startedAt = Date.now();
+            this.upstream = {
+                attempted: true,
+                requestBytes: typeof init?.body === "string" ? Buffer.byteLength(init.body) : undefined,
+            };
+            try {
+                const response = await fetchImpl(input, init);
+                this.upstream = {
+                    ...this.upstream, ...countFetchResponseMetadata(response, startedAt),
+                };
+                return response;
+            }
+            catch (error) {
+                this.upstream = {
+                    ...this.upstream, responseReceived: false, durationMs: Date.now() - startedAt,
+                    errors: safelyCountErrorDetails(error),
+                };
+                throw error;
+            }
+        };
+    }
+    failed(params) {
+        // Diagnostics must never replace the original terminal outcome.
+        try {
+            const invocation = this.invocation;
+            traceDebug(this.scope, "input_tokens.request.failed", {
+                diagnosticId: this.diagnosticId,
+                requestId: boundedDiagnosticId(this.requestBody.debugRequestId),
+                modelStep: boundedDiagnosticId(this.requestBody.modelStep),
+                phase: this.phase, failureKind: params.kind,
+                aborted: params.aborted, statusCode: params.statusCode,
+                durationMs: Date.now() - this.startedAt,
+                profileId: boundedDiagnosticId(invocation?.profile.id),
+                providerId: boundedDiagnosticId(invocation?.profile.providerId),
+                provider: boundedDiagnosticId(invocation?.profile.provider ?? this.provider),
+                model: boundedDiagnosticId(invocation?.model),
+                requestShape: countRequestShape(this.requestBody),
+                upstream: this.upstream,
+                ...(params.error !== undefined ? { errors: safelyCountErrorDetails(params.error) } : {}),
+            });
+        }
+        catch {
+            // The existing transport/error mapping remains authoritative.
+        }
+    }
+}
+function safelyCountErrorDetails(error) {
+    try {
+        return countErrorDetails(error);
+    }
+    catch {
+        return [{ type: "unknown", relation: "error" }];
+    }
+}
+function countFetchResponseMetadata(response, startedAt) {
+    const metadata = { responseReceived: true, durationMs: Date.now() - startedAt };
+    try {
+        return {
+            ...metadata, statusCode: response.status,
+            requestId: boundedDiagnosticId(response.headers.get("x-request-id")),
+        };
+    }
+    catch {
+        return metadata;
+    }
+}

package/dist/src/model-gateway/policy/invocation-policy.d.ts

@@ -1,4 +1,4 @@
-import type { ModelReasoningLevel } from "../../shared/types.js";
+export { normalizeReasoning, resolveThink } from "./reasoning-policy.js";
 import type { ModelGatewayRequest, ResolvedModelInvocation } from "../types.js";
 export type ModelInvocationResolutionErrorCode = "invalid_model_preference" | "model_profile_required" | "unknown_model_profile";
 export declare class ModelInvocationResolutionError extends Error {
@@ -6,6 +6,4 @@ export declare class ModelInvocationResolutionError extends Error {
     readonly statusCode = 400;
     constructor(code: ModelInvocationResolutionErrorCode, detail: string);
 }
-export declare function resolveThink(agentMode: unknown): ModelReasoningLevel;
-export declare function normalizeReasoning(value: unknown): ModelReasoningLevel | undefined;
 export declare function resolveModelInvocation(requestBody: ModelGatewayRequest): ResolvedModelInvocation;

package/dist/src/model-gateway/policy/invocation-policy.js

@@ -1,3 +1,5 @@
+import { resolveInvocationReasoning } from "./reasoning-policy.js";
+export { normalizeReasoning, resolveThink } from "./reasoning-policy.js";
 import { normalizeModelPreference, resolveClientPreferenceProfile, resolveConfiguredInvocationProfile, resolveProfileById, } from "./invocation-profile-policy.js";
 export class ModelInvocationResolutionError extends Error {
     code;
@@ -8,32 +10,6 @@ export class ModelInvocationResolutionError extends Error {
         this.name = "ModelInvocationResolutionError";
     }
 }
-export function resolveThink(agentMode) {
-    const mode = String(agentMode || "reasoning").toLowerCase();
-    if (mode === "deep")
-        return "high";
-    if (mode === "fast")
-        return "none";
-    return "medium";
-}
-export function normalizeReasoning(value) {
-    const normalized = String(value || "")
-        .trim()
-        .toLowerCase();
-    if (normalized === "none")
-        return "none";
-    if (normalized === "minimal")
-        return "minimal";
-    if (normalized === "low")
-        return "low";
-    if (normalized === "medium")
-        return "medium";
-    if (normalized === "high")
-        return "high";
-    if (normalized === "xhigh")
-        return "xhigh";
-    return undefined;
-}
 function applyInvocationProfileOverlay(candidate) {
     const overlay = candidate.invocationProfile;
     if (!overlay) {
@@ -161,13 +137,10 @@ export function resolveModelInvocation(requestBody) {
         ? { ...calibration.profile, model: overrideModel }
         : calibration.profile;
     const selectedInvocationProfile = calibration.invocationProfile ?? selectedCandidate.invocationProfile;
-    const think = normalizeReasoning(requestBody?.reasoningOverride) ??
-        profile.generation.reasoningEffort ??
-        resolveThink(requestBody?.agentMode);
     return {
         model: profile.model,
         profile,
-        think: profile.supportsThinking ? think : undefined,
+        ...resolveInvocationReasoning(requestBody, profile),
         ...(selectedInvocationProfile?.format
             ? { format: selectedInvocationProfile.format }
             : {}),

package/dist/src/model-gateway/policy/reasoning-mode-budget.d.ts

@@ -0,0 +1,5 @@
+import type { ModelReasoningBudget } from "../../shared/model-reasoning.js";
+import type { ModelReasoningBudgetByMode } from "../../shared/model-reasoning-modes.js";
+import type { ModelGatewayRequest } from "../types.js";
+/** Conversation presets never replace a utility step's calibrated budget. */
+export declare function resolveReasoningModeBudget(request: ModelGatewayRequest, mapping: ModelReasoningBudgetByMode | undefined): ModelReasoningBudget | undefined;

package/dist/src/model-gateway/policy/reasoning-mode-budget.js

@@ -0,0 +1,13 @@
+import { isRegisteredModelStepInLane } from "../../shared/model-step-registry.js";
+/** Conversation presets never replace a utility step's calibrated budget. */
+export function resolveReasoningModeBudget(request, mapping) {
+    if (!mapping)
+        return undefined;
+    if (request.modelStep !== undefined &&
+        !isRegisteredModelStepInLane(request.modelStep, "main"))
+        return undefined;
+    const mode = String(request.agentMode || "reasoning").toLowerCase();
+    if (!Object.hasOwn(mapping, mode))
+        return undefined;
+    return { mode: "tokens", tokens: mapping[mode] };
+}

package/dist/src/model-gateway/policy/reasoning-policy.d.ts

@@ -0,0 +1,10 @@
+import type { ModelReasoningLevel } from "../../shared/types.js";
+import { type ModelReasoningBudget } from "../../shared/model-reasoning.js";
+import type { ModelGatewayRequest, ModelProfile } from "../types.js";
+export declare function resolveThink(agentMode: unknown): ModelReasoningLevel;
+export declare function normalizeReasoning(value: unknown): ModelReasoningLevel | undefined;
+export declare function resolveInvocationReasoning(request: ModelGatewayRequest, profile: ModelProfile): {
+    think?: ModelReasoningLevel;
+    reasoningBudget?: ModelReasoningBudget;
+    reasoningControlSource?: "invocation" | "request" | "configuration" | "agent-mode";
+};

package/dist/src/model-gateway/policy/reasoning-policy.js

@@ -0,0 +1,124 @@
+import { parseModelReasoningBudgetByMode } from "../../shared/model-reasoning-modes.js";
+import { resolveReasoningModeBudget } from "./reasoning-mode-budget.js";
+import { isRegisteredModelStepInLane } from "../../shared/model-step-registry.js";
+import { ModelReasoningConfigurationError, parseModelReasoningBudget, parseModelReasoningPreference, supportsModelReasoningBudget, } from "../../shared/model-reasoning.js";
+import { resolveProfileById } from "./invocation-profile-policy.js";
+export function resolveThink(agentMode) {
+    const mode = String(agentMode || "reasoning").toLowerCase();
+    if (mode === "deep")
+        return "high";
+    if (mode === "fast")
+        return "none";
+    return "medium";
+}
+export function normalizeReasoning(value) {
+    const normalized = String(value || "")
+        .trim()
+        .toLowerCase();
+    if (normalized === "none")
+        return "none";
+    if (normalized === "minimal")
+        return "minimal";
+    if (normalized === "low")
+        return "low";
+    if (normalized === "medium")
+        return "medium";
+    if (normalized === "high")
+        return "high";
+    if (normalized === "xhigh")
+        return "xhigh";
+    return undefined;
+}
+function assertReasoningBudgetSupport(profile) {
+    if (supportsModelReasoningBudget(profile))
+        return;
+    throw new ModelReasoningConfigurationError("reasoning_budget_unsupported", `profile ${profile.id} does not declare numeric reasoning controls`);
+}
+function resolveRequestedPreference(request) {
+    const preference = parseModelReasoningPreference(request.reasoningPreference);
+    if (!preference)
+        return undefined;
+    const boundProfile = resolveProfileById(preference.profileId, request.modelPolicy);
+    if (!boundProfile) {
+        throw new ModelReasoningConfigurationError("invalid_reasoning_preference", `unknown profile ${preference.profileId}`);
+    }
+    assertReasoningBudgetSupport(boundProfile);
+    return preference;
+}
+function canApplyReasoningPreference(request, profile, preference) {
+    if (!preference)
+        return false;
+    if (preference.profileId !== profile.id)
+        return false;
+    // Calls without a modelStep are direct public gateway calls. Registered
+    // utility calls retain their own calibration even when preference.scope=all.
+    if (request.modelStep === undefined)
+        return true;
+    return isRegisteredModelStepInLane(request.modelStep, "main");
+}
+function preferenceBudget(preference) {
+    if (preference.mode === "off")
+        return undefined;
+    if (preference.mode === "server-default")
+        return { mode: "server-default" };
+    return { mode: "tokens", tokens: preference.budgetTokens };
+}
+function isZeroReasoningBudget(budget) {
+    if (budget?.mode !== "tokens")
+        return false;
+    return budget.tokens === 0;
+}
+export function resolveInvocationReasoning(request, profile) {
+    const preference = resolveRequestedPreference(request);
+    const applies = canApplyReasoningPreference(request, profile, preference);
+    const configuredBudget = parseModelReasoningBudget(profile.generation.reasoningBudget);
+    const configuredModes = parseModelReasoningBudgetByMode(profile.generation.reasoningBudgetByMode);
+    if (configuredBudget || configuredModes)
+        assertReasoningBudgetSupport(profile);
+    const modeBudget = resolveReasoningModeBudget(request, configuredModes);
+    const override = normalizeReasoning(request.reasoningOverride);
+    const configuredThink = profile.generation.reasoningEffort ?? resolveThink(request.agentMode);
+    const preferredEffort = resolvePreferredEffort(applies ? preference : undefined, configuredThink);
+    const budget = applies
+        ? preferenceBudget(preference)
+        : (modeBudget ?? configuredBudget);
+    const zeroBudgetDisablesThinking = isZeroReasoningBudget(budget);
+    const budgetEffort = zeroBudgetDisablesThinking ? "none" : undefined;
+    const enabledBudget = zeroBudgetDisablesThinking ? undefined : budget;
+    const think = override ??
+        budgetEffort ??
+        preferredEffort ??
+        (modeBudget && configuredThink === "none" ? "medium" : configuredThink);
+    const reasoningControlSource = resolveReasoningControlSource(override, applies, profile);
+    if (!preference && !configuredBudget && !modeBudget)
+        return { think: profile.supportsThinking ? think : undefined };
+    if (!profile.supportsThinking)
+        return { think: undefined, reasoningControlSource };
+    if (think === "none")
+        return { think, reasoningControlSource };
+    return {
+        think,
+        ...(enabledBudget ? { reasoningBudget: enabledBudget } : {}),
+        reasoningControlSource,
+    };
+}
+function resolveReasoningControlSource(override, applies, profile) {
+    if (override)
+        return "invocation";
+    if (applies)
+        return "request";
+    if (profile.generation.reasoningEffort !== undefined)
+        return "configuration";
+    if (profile.generation.reasoningBudget !== undefined)
+        return "configuration";
+    if (profile.generation.reasoningBudgetByMode !== undefined)
+        return "configuration";
+    return "agent-mode";
+}
+function resolvePreferredEffort(preference, configuredThink) {
+    if (!preference)
+        return undefined;
+    if (preference.mode === "off")
+        return "none";
+    return configuredThink === "none" ? "medium" : configuredThink;
+}

package/dist/src/model-gateway/protocol/openai-embedding-response.d.ts

@@ -0,0 +1 @@
+export declare function readOpenAiCompatibleEmbeddingVectors(value: unknown, expectedCount: number): unknown[];

package/dist/src/model-gateway/protocol/openai-embedding-response.js

@@ -0,0 +1,28 @@
+export function readOpenAiCompatibleEmbeddingVectors(value, expectedCount) {
+    const body = value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+    if (!body || !Array.isArray(body.data)) {
+        return [];
+    }
+    const entries = body.data.filter(isRecord);
+    if (!hasContiguousIndices(entries, expectedCount)) {
+        return [];
+    }
+    return [...entries]
+        .sort((left, right) => Number(left.index) - Number(right.index))
+        .map((entry) => entry.embedding);
+}
+function hasContiguousIndices(entries, expectedCount) {
+    if (entries.length !== expectedCount) {
+        return false;
+    }
+    const indices = new Set(entries.map(({ index }) => index));
+    return (indices.size === expectedCount &&
+        [...indices].every((index) => Number.isSafeInteger(index) &&
+            Number(index) >= 0 &&
+            Number(index) < expectedCount));
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}

package/dist/src/model-gateway/protocol/sse-data.d.ts

@@ -0,0 +1,9 @@
+export declare class SseDataDecoder {
+    private readonly decoder;
+    private line;
+    private data;
+    private afterCr;
+    accept(bytes: Uint8Array): string[];
+    private acceptLine;
+}
+export declare function readSseDataFrames(body: ReadableStream<Uint8Array>): AsyncGenerator<string>;

package/dist/src/model-gateway/protocol/sse-data.js

@@ -0,0 +1,67 @@
+// Decode complete SSE data frames identically for response lifetime and output.
+// Event names are metadata; each provider owns its payload semantics.
+export class SseDataDecoder {
+    decoder = new TextDecoder();
+    line = "";
+    data = [];
+    afterCr = false;
+    accept(bytes) {
+        const text = this.decoder.decode(bytes, { stream: true });
+        const frames = [];
+        let start = 0;
+        for (let index = 0; index < text.length; index += 1) {
+            const char = text[index];
+            if (this.afterCr) {
+                this.afterCr = false;
+                if (char === "\n") {
+                    start = index + 1;
+                    continue;
+                }
+            }
+            if (char !== "\r" && char !== "\n")
+                continue;
+            this.line += text.slice(start, index);
+            this.acceptLine(frames);
+            this.line = "";
+            this.afterCr = char === "\r";
+            start = index + 1;
+        }
+        this.line += text.slice(start);
+        return frames;
+    }
+    acceptLine(frames) {
+        if (!this.line) {
+            if (this.data.length)
+                frames.push(this.data.join("\n"));
+            this.data = [];
+            return;
+        }
+        const colon = this.line.indexOf(":");
+        const field = colon < 0 ? this.line : this.line.slice(0, colon);
+        if (field !== "data")
+            return;
+        const value = colon < 0 ? "" : this.line.slice(colon + 1);
+        this.data.push(value.startsWith(" ") ? value.slice(1) : value);
+    }
+}
+export async function* readSseDataFrames(body) {
+    const reader = body.getReader();
+    const decoder = new SseDataDecoder();
+    let reachedEof = false;
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+                reachedEof = true;
+                return;
+            }
+            yield* decoder.accept(value);
+        }
+    }
+    finally {
+        // A tee branch cannot await cancellation before the other readers finish.
+        if (!reachedEof)
+            void reader.cancel().catch(() => { });
+        reader.releaseLock();
+    }
+}

package/dist/src/model-gateway/providers/envelope-budget.js

@@ -5,7 +5,7 @@ export function estimateProviderEnvelopeInputTokens(payload, tokenEstimation) {
 }
 export function createProviderEnvelopeFingerprint(payload) {
     return `sha256:${createHash("sha256")
-        .update(serializeTokenBearingEnvelope(payload))
+        .update(serializeFingerprintEnvelope(payload))
         .digest("hex")}`;
 }
 export function resolveProviderEnvelopeInputTokens(params) {
@@ -34,6 +34,15 @@ function estimatedEnvelopeAssessment(params) {
         measurementBinding: "missing",
     });
 }
+// Grammar and template controls bind the measurement but are not prompt prose.
+function serializeFingerprintEnvelope(payload) {
+    const selected = projectTokenBearingProviderEnvelope(payload);
+    for (const key of ["response_format", "chat_template_kwargs", "reasoning_effort"]) {
+        if (Object.hasOwn(payload, key))
+            selected[key] = payload[key];
+    }
+    return JSON.stringify(selected);
+}
 function serializeTokenBearingEnvelope(payload) {
     return JSON.stringify(projectTokenBearingProviderEnvelope(payload));
 }

package/dist/src/model-gateway/providers/llamacpp/adapter.d.ts

@@ -0,0 +1,2 @@
+import type { ModelProviderAdapter } from "../contracts.js";
+export declare function createLlamaCppProviderAdapter(): ModelProviderAdapter;

package/dist/src/model-gateway/providers/llamacpp/adapter.js

@@ -0,0 +1,79 @@
+import { fetchProviderWithTrace } from "../../model-io-trace.js";
+import { toolMediaSafeError, toolMediaSafeEvent, toolMediaSafeMessage } from "../../observability/tool-media-privacy.js";
+import { emitLlamaCppStreamTermination } from "./diagnostics.js";
+import { embedWithLlamaCpp } from "./embeddings.js";
+import { countLlamaCppInputTokens } from "./input-token-count.js";
+import { buildLlamaCppChatPayload } from "./payload.js";
+import { bindLlamaCppResponseLifetime } from "./response-lifetime.js";
+import { resolveLlamaCppProviderSettings } from "./settings.js";
+import { collectLlamaCppChatStream, forwardLlamaCppChatStream } from "./stream.js";
+export function createLlamaCppProviderAdapter() {
+    return Object.freeze({
+        type: "llamacpp",
+        supportsImageInput: false,
+        embed: embedWithLlamaCpp,
+        countInputTokens: countLlamaCppInputTokens,
+        async invoke(params) {
+            let settings;
+            try {
+                settings = resolveLlamaCppProviderSettings(params.invocation.profile.providerConfig);
+            }
+            catch (error) {
+                return { kind: "error", statusCode: 500, message: toolMediaSafeMessage(error instanceof Error ? error.message : "llamacpp_configuration_invalid", params.requestBody) };
+            }
+            const payload = buildLlamaCppChatPayload(params);
+            const { response, responseTrace } = await fetchProviderWithTrace({
+                endpoint: params.endpoint, requestBody: params.requestBody, invocation: params.invocation,
+                fetchImpl: async (input, init) => bindLlamaCppResponseLifetime(await params.fetchImpl(input, init)),
+                url: `${settings.apiUrl}/chat/completions`, headers: settings.headers, payload,
+                decodeResponse: collectLlamaCppChatStream,
+            });
+            if (!response.ok || !response.body) {
+                const message = await response.text();
+                await responseTrace;
+                return { kind: "error", statusCode: response.ok ? 502 : response.status,
+                    message: toolMediaSafeMessage(message || "llamacpp error", params.requestBody) };
+            }
+            const startedAt = Date.now();
+            const body = response.body;
+            if (params.endpoint === "chat") {
+                return {
+                    kind: "chat",
+                    async stream(writer) {
+                        let failure;
+                        try {
+                            await forwardLlamaCppChatStream(body, {
+                                emit: (event) => writer.emit(toolMediaSafeEvent(event, params.requestBody)),
+                            });
+                        }
+                        catch (error) {
+                            failure = toolMediaSafeError(error, params.requestBody);
+                            throw failure;
+                        }
+                        finally {
+                            emitLlamaCppStreamTermination(params, startedAt, failure);
+                            await responseTrace;
+                        }
+                    },
+                };
+            }
+            let failure;
+            try {
+                const result = await collectLlamaCppChatStream(body);
+                return { kind: "raw", body: {
+                        text: result.text, thinking: result.thinking,
+                        ...(result.usage ? { usage: result.usage } : {}),
+                        ...(result.doneReason ? { providerCompletionReason: result.doneReason } : {}),
+                    } };
+            }
+            catch (error) {
+                failure = toolMediaSafeError(error, params.requestBody);
+                throw failure;
+            }
+            finally {
+                emitLlamaCppStreamTermination(params, startedAt, failure);
+                await responseTrace;
+            }
+        },
+    });
+}

package/dist/src/model-gateway/providers/llamacpp/connection.d.ts

@@ -0,0 +1,9 @@
+/** Explicit read-only connection check; model capabilities remain user declarations. */
+export declare function inspectLlamaCppConnection(params: {
+    baseUrl: string;
+    apiKey?: string;
+    fetchImpl?: typeof fetch;
+    signal?: AbortSignal;
+}): Promise<{
+    models: readonly string[];
+}>;