@oscharko-dev/keiko 0.1.6 → 0.1.7

package/node_modules/@oscharko-dev/keiko-model-gateway/dist/model-selection.js

@@ -0,0 +1,47 @@
+import { createDefaultChatCapability, listCapabilities } from "./capabilities.js";
+import { ConfigInvalidError } from "@oscharko-dev/keiko-security/errors/gateway";
+const COST_RANK = { low: 0, medium: 1, high: 2 };
+function matches(capability, query) {
+    if (capability.kind !== query.kind) {
+        return false;
+    }
+    if (query.toolCalling === true && !capability.toolCalling) {
+        return false;
+    }
+    if (query.structuredOutput === true && !capability.structuredOutput) {
+        return false;
+    }
+    if (query.minContextWindow !== undefined && capability.contextWindow < query.minContextWindow) {
+        return false;
+    }
+    return true;
+}
+export function assertConfiguredModel(config, modelId) {
+    if (!config.providers.some((provider) => provider.modelId === modelId)) {
+        throw new ConfigInvalidError(`model '${modelId}' is not configured as a provider`);
+    }
+}
+export function findConfiguredCapability(config, modelId) {
+    return (config.capabilities?.find((capability) => capability.id === modelId) ??
+        listCapabilities().find((capability) => capability.id === modelId) ??
+        (config.providers.some((provider) => provider.modelId === modelId)
+            ? createDefaultChatCapability(modelId)
+            : undefined));
+}
+export function listConfiguredCapabilities(config) {
+    return config.providers
+        .map((provider) => findConfiguredCapability(config, provider.modelId))
+        .filter((capability) => capability !== undefined);
+}
+export function selectConfiguredModel(config, query) {
+    let best;
+    for (const capability of listConfiguredCapabilities(config)) {
+        if (!matches(capability, query)) {
+            continue;
+        }
+        if (best === undefined || COST_RANK[capability.costClass] < COST_RANK[best.costClass]) {
+            best = capability;
+        }
+    }
+    return best?.id;
+}

package/node_modules/@oscharko-dev/keiko-model-gateway/dist/normalize.d.ts

@@ -0,0 +1,8 @@
+import type { CostClass, NormalizedResponse } from "./types.js";
+export interface UsageSeed {
+    readonly requestId: string;
+    readonly latencyMs: number;
+    readonly costClass: CostClass;
+}
+export declare function normalizeChatResponse(rawPayload: unknown, modelId: string, seed: UsageSeed, expectStructured?: boolean): NormalizedResponse;
+//# sourceMappingURL=normalize.d.ts.map

package/node_modules/@oscharko-dev/keiko-model-gateway/dist/normalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize.d.ts","sourceRoot":"","sources":["../src/normalize.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EACV,SAAS,EAET,kBAAkB,EAGnB,MAAM,YAAY,CAAC;AAEpB,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC;CAC/B;AAwFD,wBAAgB,qBAAqB,CACnC,UAAU,EAAE,OAAO,EACnB,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,SAAS,EACf,gBAAgB,UAAQ,GACvB,kBAAkB,CAYpB"}

package/node_modules/@oscharko-dev/keiko-model-gateway/dist/normalize.js

@@ -0,0 +1,93 @@
+// Provider payload → NormalizedResponse. The internal contract is strict and small
+// so workflows fail closed when a provider response is unsafe or malformed.
+import { MalformedToolCallError, ModelRefusalError, } from "@oscharko-dev/keiko-security/errors/gateway";
+const FINISH_REASONS = new Set([
+    "stop",
+    "tool_calls",
+    "length",
+    "content_filter",
+    "error",
+    "cancelled",
+]);
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function asCount(value) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : 0;
+}
+function mapFinishReason(value) {
+    return typeof value === "string" && FINISH_REASONS.has(value)
+        ? value
+        : "stop";
+}
+function buildUsage(payload, seed) {
+    const usage = isRecord(payload.usage) ? payload.usage : {};
+    return {
+        requestId: seed.requestId,
+        promptTokens: asCount(usage.prompt_tokens),
+        completionTokens: asCount(usage.completion_tokens),
+        latencyMs: seed.latencyMs,
+        costClass: seed.costClass,
+    };
+}
+function parseToolCall(raw) {
+    if (!isRecord(raw) || !isRecord(raw.function)) {
+        throw new MalformedToolCallError("tool call is missing a function descriptor");
+    }
+    const fn = raw.function;
+    const name = typeof fn.name === "string" ? fn.name : "";
+    const id = typeof raw.id === "string" ? raw.id : "";
+    const argsText = typeof fn.arguments === "string" ? fn.arguments : "{}";
+    let parsed;
+    try {
+        parsed = JSON.parse(argsText);
+    }
+    catch {
+        throw new MalformedToolCallError(`tool call '${name}' has non-JSON arguments`);
+    }
+    if (!isRecord(parsed)) {
+        throw new MalformedToolCallError(`tool call '${name}' arguments are not an object`);
+    }
+    return { id, name, arguments: parsed };
+}
+function parseToolCalls(message) {
+    const raw = message.tool_calls;
+    return Array.isArray(raw) ? raw.map(parseToolCall) : [];
+}
+function parseStructuredOutput(content) {
+    try {
+        const parsed = JSON.parse(content);
+        return isRecord(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function assertNotRefusal(message, finishReason) {
+    if (finishReason === "content_filter") {
+        throw new ModelRefusalError("provider filtered the model response");
+    }
+    const refusal = message.refusal;
+    if (typeof refusal === "string" && refusal.length > 0) {
+        throw new ModelRefusalError("provider refused the model request");
+    }
+}
+function firstChoice(payload) {
+    const choices = payload.choices;
+    if (!Array.isArray(choices) || choices.length === 0) {
+        return undefined;
+    }
+    return isRecord(choices[0]) ? choices[0] : undefined;
+}
+export function normalizeChatResponse(rawPayload, modelId, seed, expectStructured = false) {
+    const payload = isRecord(rawPayload) ? rawPayload : {};
+    const usage = buildUsage(payload, seed);
+    const choice = firstChoice(payload);
+    const message = choice !== undefined && isRecord(choice.message) ? choice.message : {};
+    const finishReason = mapFinishReason(choice?.finish_reason);
+    assertNotRefusal(message, finishReason);
+    const toolCalls = parseToolCalls(message);
+    const content = typeof message.content === "string" ? message.content : "";
+    const structuredOutput = expectStructured && content.length > 0 ? parseStructuredOutput(content) : null;
+    return { modelId, content, finishReason, toolCalls, structuredOutput, usage };
+}

package/node_modules/@oscharko-dev/keiko-model-gateway/dist/openai-adapter.d.ts

@@ -0,0 +1,18 @@
+import type { CostClass, GatewayRequest, ModelProviderConfig, NormalizedResponse, ProviderAdapter } from "./types.js";
+export interface AdapterDeps {
+    readonly fetchImpl?: typeof fetch | undefined;
+    readonly requestId: string;
+    readonly costClass: CostClass;
+    readonly now?: (() => number) | undefined;
+}
+export declare class OpenAiAdapter implements ProviderAdapter {
+    private readonly deps;
+    private readonly now;
+    constructor(deps: AdapterDeps);
+    call: (request: GatewayRequest, config: ModelProviderConfig) => Promise<NormalizedResponse>;
+    private dispatch;
+    private mapDispatchError;
+    private readBody;
+    private readErrorBody;
+}
+//# sourceMappingURL=openai-adapter.d.ts.map

package/node_modules/@oscharko-dev/keiko-model-gateway/dist/openai-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai-adapter.d.ts","sourceRoot":"","sources":["../src/openai-adapter.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EACV,SAAS,EACT,cAAc,EACd,mBAAmB,EACnB,kBAAkB,EAElB,eAAe,EAChB,MAAM,YAAY,CAAC;AAEpB,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,KAAK,GAAG,SAAS,CAAC;IAC9C,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC;IAC9B,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC,MAAM,MAAM,CAAC,GAAG,SAAS,CAAC;CAC3C;AA2KD,qBAAa,aAAc,YAAW,eAAe;IAGvC,OAAO,CAAC,QAAQ,CAAC,IAAI;IAFjC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAe;gBAEN,IAAI,EAAE,WAAW;IAI9C,IAAI,GACF,SAAS,cAAc,EACvB,QAAQ,mBAAmB,KAC1B,OAAO,CAAC,kBAAkB,CAAC,CA4B5B;YAEY,QAAQ;IA2BtB,OAAO,CAAC,gBAAgB;YAmBV,QAAQ;YAYR,aAAa;CAO5B"}

package/node_modules/@oscharko-dev/keiko-model-gateway/dist/openai-adapter.js

@@ -0,0 +1,200 @@
+// Zero-dependency OpenAI-compatible HTTP adapter built on globalThis.fetch and
+// AbortSignal. fetch, clock, request-id, and cost class are injected so tests run
+// with no network I/O and no real time. The raw provider body is never echoed into
+// an error; only a redacted, status-level summary is surfaced.
+import { AuthenticationError, CancelledError, ContextOverflowError, ModelRefusalError, ProviderError, RateLimitError, TimeoutError, TransportError, } from "@oscharko-dev/keiko-security/errors/gateway";
+import { apiKeyHeaderValue, DEFAULT_API_KEY_HEADER_NAME } from "./config.js";
+import { gatewayFetch, readJsonCapped } from "./http.js";
+import { normalizeChatResponse } from "./normalize.js";
+import { redact } from "@oscharko-dev/keiko-security";
+function buildMessage(message) {
+    const toolCalls = message.toolCalls?.map((call) => ({
+        id: call.id,
+        type: "function",
+        function: { name: call.name, arguments: JSON.stringify(call.arguments) },
+    }));
+    return {
+        role: message.role,
+        content: message.role === "assistant" && toolCalls !== undefined && toolCalls.length > 0
+            ? null
+            : message.content,
+        ...(message.role === "tool" && message.toolCallId !== undefined
+            ? { tool_call_id: message.toolCallId }
+            : {}),
+        ...(toolCalls !== undefined && toolCalls.length > 0 ? { tool_calls: toolCalls } : {}),
+    };
+}
+function buildBody(request) {
+    const messages = request.messages.map(buildMessage);
+    const base = { model: request.modelId, messages };
+    const tools = request.tools === undefined
+        ? undefined
+        : request.tools.map((t) => ({
+            type: "function",
+            function: { name: t.name, description: t.description, parameters: t.parameters },
+        }));
+    const responseFormat = request.responseFormat?.type === "json_schema"
+        ? { type: "json_schema", json_schema: { schema: request.responseFormat.schema } }
+        : undefined;
+    return {
+        ...base,
+        ...(tools ? { tools } : {}),
+        ...(responseFormat ? { response_format: responseFormat } : {}),
+    };
+}
+function retryAfterMs(response) {
+    const header = response.headers.get("retry-after");
+    if (header === null) {
+        return null;
+    }
+    const seconds = Number(header);
+    return Number.isFinite(seconds) && seconds >= 0 ? seconds * 1000 : null;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function redactUnknown(value, secrets) {
+    if (typeof value === "string") {
+        return redact(value, secrets);
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => redactUnknown(item, secrets));
+    }
+    if (isRecord(value)) {
+        return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, redactUnknown(item, secrets)]));
+    }
+    return value;
+}
+function redactRecord(value, secrets) {
+    return value === null ? null : redactUnknown(value, secrets);
+}
+function redactToolCall(call, secrets) {
+    return {
+        ...call,
+        name: redact(call.name, secrets),
+        arguments: redactUnknown(call.arguments, secrets),
+    };
+}
+function redactResponse(response, secrets) {
+    return {
+        ...response,
+        content: redact(response.content, secrets),
+        toolCalls: response.toolCalls.map((call) => redactToolCall(call, secrets)),
+        structuredOutput: redactRecord(response.structuredOutput, secrets),
+    };
+}
+function errorSignal(payload) {
+    const error = isRecord(payload) && isRecord(payload.error) ? payload.error : payload;
+    if (!isRecord(error)) {
+        return "";
+    }
+    return [error.code, error.type, error.message]
+        .filter((value) => typeof value === "string")
+        .join(" ")
+        .toLowerCase();
+}
+function isContextOverflow(response, payload) {
+    if (response.status !== 400 && response.status !== 413 && response.status !== 422) {
+        return false;
+    }
+    return /context[_ -]?length[_ -]?exceeded|context window|context.*exceed|maximum context|too many tokens|prompt too long|context overflow/.test(errorSignal(payload));
+}
+function isModelRefusal(payload) {
+    return /content[_ -]?filter|refus|safety|policy/.test(errorSignal(payload));
+}
+function mapHttpError(response, modelId, secrets, payload) {
+    if (isContextOverflow(response, payload)) {
+        throw new ContextOverflowError(`provider reported context overflow for '${modelId}'`, secrets);
+    }
+    if (isModelRefusal(payload)) {
+        throw new ModelRefusalError(`provider refused the request for '${modelId}'`, secrets);
+    }
+    if (response.status === 401 || response.status === 403) {
+        throw new AuthenticationError(`provider rejected credentials for '${modelId}'`, secrets);
+    }
+    if (response.status === 429) {
+        throw new RateLimitError(`provider rate limited '${modelId}'`, retryAfterMs(response), secrets);
+    }
+    throw new ProviderError(`provider returned HTTP ${String(response.status)} for '${modelId}'`, response.status, secrets);
+}
+function apiKeyHeaders(config) {
+    const headerName = config.apiKeyHeaderName ?? DEFAULT_API_KEY_HEADER_NAME;
+    return { [headerName]: apiKeyHeaderValue(headerName, config.apiKey) };
+}
+export class OpenAiAdapter {
+    deps;
+    now;
+    constructor(deps) {
+        this.deps = deps;
+        this.now = deps.now ?? Date.now;
+    }
+    call = async (request, config) => {
+        const secrets = [config.apiKey, config.baseUrl];
+        if (request.cancellationSignal?.aborted === true) {
+            throw new CancelledError(`request for '${config.modelId}' cancelled before dispatch`, secrets);
+        }
+        const start = this.now();
+        const response = await this.dispatch(request, config, secrets);
+        if (!response.ok) {
+            const errorPayload = await this.readErrorBody(response);
+            mapHttpError(response, config.modelId, secrets, errorPayload);
+        }
+        const payload = await this.readBody(response, config, secrets);
+        return redactResponse(normalizeChatResponse(payload, config.modelId, {
+            requestId: this.deps.requestId,
+            latencyMs: this.now() - start,
+            costClass: this.deps.costClass,
+        }, request.responseFormat?.type === "json_schema"), secrets);
+    };
+    async dispatch(request, config, secrets) {
+        const timeoutSignal = AbortSignal.timeout(config.timeoutMs);
+        const cancel = request.cancellationSignal;
+        const signal = cancel ? AbortSignal.any([timeoutSignal, cancel]) : timeoutSignal;
+        const url = `${config.baseUrl}/chat/completions`;
+        const body = JSON.stringify(buildBody(request));
+        const headers = {
+            "content-type": "application/json",
+            ...apiKeyHeaders(config),
+        };
+        try {
+            return await gatewayFetch(url, {
+                method: "POST",
+                headers,
+                body,
+                signal,
+                fetchImpl: this.deps.fetchImpl,
+            });
+        }
+        catch (error) {
+            throw this.mapDispatchError(error, config, cancel, timeoutSignal, secrets);
+        }
+    }
+    mapDispatchError(error, config, cancel, timeout, secrets) {
+        if (cancel?.aborted === true) {
+            return new CancelledError(`request for '${config.modelId}' cancelled`, secrets);
+        }
+        if (timeout.aborted) {
+            return new TimeoutError(`request for '${config.modelId}' timed out`, secrets);
+        }
+        if (error instanceof DOMException && error.name === "TimeoutError") {
+            return new TimeoutError(`request for '${config.modelId}' timed out`, secrets);
+        }
+        return new TransportError(`transport failure contacting '${config.modelId}'`, secrets);
+    }
+    async readBody(response, config, secrets) {
+        try {
+            return await readJsonCapped(response);
+        }
+        catch {
+            throw new TransportError(`provider sent an unreadable body for '${config.modelId}'`, secrets);
+        }
+    }
+    async readErrorBody(response) {
+        try {
+            return await readJsonCapped(response);
+        }
+        catch {
+            return null;
+        }
+    }
+}

package/node_modules/@oscharko-dev/keiko-model-gateway/dist/resilience.d.ts

@@ -0,0 +1,25 @@
+import type { CircuitBreakerConfig, CircuitBreakerStatus, Clock } from "./types.js";
+export declare const systemClock: Clock;
+export interface RetryConfig {
+    readonly maxRetries: number;
+    readonly retryBaseDelayMs: number;
+    readonly timeoutMs?: number | undefined;
+}
+export declare function executeWithRetry<T>(operation: (attemptTimeoutMs?: number) => Promise<T>, config: RetryConfig, clock: Clock, signal?: AbortSignal): Promise<T>;
+export declare class CircuitBreaker {
+    private readonly modelId;
+    private readonly config;
+    private readonly clock;
+    private state;
+    private consecutiveFailures;
+    private openedAt;
+    private probesRemaining;
+    constructor(modelId: string, config: CircuitBreakerConfig, clock: Clock);
+    assertAllowed(): void;
+    recordSuccess(): void;
+    recordFailure(): void;
+    status(modelId: string): CircuitBreakerStatus;
+    private open;
+    private close;
+}
+//# sourceMappingURL=resilience.d.ts.map

package/node_modules/@oscharko-dev/keiko-model-gateway/dist/resilience.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resilience.d.ts","sourceRoot":"","sources":["../src/resilience.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,oBAAoB,EAAE,oBAAoB,EAAgB,KAAK,EAAE,MAAM,YAAY,CAAC;AAIlG,eAAO,MAAM,WAAW,EAAE,KAkBzB,CAAC;AAEF,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACzC;AAuDD,wBAAsB,gBAAgB,CAAC,CAAC,EACtC,SAAS,EAAE,CAAC,gBAAgB,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,EACpD,MAAM,EAAE,WAAW,EACnB,KAAK,EAAE,KAAK,EACZ,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,CAAC,CAAC,CAiCZ;AAED,qBAAa,cAAc;IAOvB,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,KAAK;IARxB,OAAO,CAAC,KAAK,CAA0B;IACvC,OAAO,CAAC,mBAAmB,CAAK;IAChC,OAAO,CAAC,QAAQ,CAAuB;IACvC,OAAO,CAAC,eAAe,CAAK;gBAGT,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,oBAAoB,EAC5B,KAAK,EAAE,KAAK;IAM/B,aAAa,IAAI,IAAI;IAWrB,aAAa,IAAI,IAAI;IAWrB,aAAa,IAAI,IAAI;IAWrB,MAAM,CAAC,OAAO,EAAE,MAAM,GAAG,oBAAoB;IAS7C,OAAO,CAAC,IAAI;IAMZ,OAAO,CAAC,KAAK;CAMd"}

package/node_modules/@oscharko-dev/keiko-model-gateway/dist/resilience.js

@@ -0,0 +1,166 @@
+// Resilience primitives: a real-time Clock, a bounded exponential-backoff retry
+// loop, and a per-(model,endpoint) circuit breaker. All time-dependent behaviour
+// flows through the injectable Clock so tests are deterministic and instant.
+import { CancelledError, CircuitOpenError, GatewayError, RateLimitError, } from "@oscharko-dev/keiko-security/errors/gateway";
+const MAX_BACKOFF_MS = 30_000;
+export const systemClock = {
+    now: () => Date.now(),
+    sleep: (ms, signal) => {
+        if (signal?.aborted === true) {
+            return Promise.reject(new DOMException("cancelled", "AbortError"));
+        }
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                signal?.removeEventListener("abort", onAbort);
+                resolve();
+            }, ms);
+            function onAbort() {
+                clearTimeout(timeout);
+                reject(new DOMException("cancelled", "AbortError"));
+            }
+            signal?.addEventListener("abort", onAbort, { once: true });
+        });
+    },
+};
+function backoffDelayMs(attempt, base) {
+    return Math.min(base * 2 ** (attempt - 1), MAX_BACKOFF_MS);
+}
+// A RateLimitError with an explicit retryAfterMs is honoured; otherwise the error's
+// own `retryable` flag decides. Non-GatewayErrors are never retried.
+function retryDelayMs(error, attempt, base) {
+    if (!(error instanceof GatewayError) || !error.retryable) {
+        return null;
+    }
+    if (error instanceof RateLimitError && error.retryAfterMs !== null && error.retryAfterMs > 0) {
+        return Math.min(error.retryAfterMs, MAX_BACKOFF_MS);
+    }
+    return backoffDelayMs(attempt, base);
+}
+function assertNotAborted(signal) {
+    if (signal?.aborted === true) {
+        throw new CancelledError("request cancelled during retry");
+    }
+}
+function remainingBudgetMs(start, timeoutMs, clock) {
+    if (timeoutMs === undefined) {
+        return Number.POSITIVE_INFINITY;
+    }
+    return Math.max(0, timeoutMs - (clock.now() - start));
+}
+function asError(error) {
+    if (error instanceof Error) {
+        return error;
+    }
+    return new Error(String(error));
+}
+async function sleepWithCancellation(clock, delayMs, signal) {
+    assertNotAborted(signal);
+    try {
+        await clock.sleep(delayMs, signal);
+    }
+    catch (error) {
+        if (signal?.aborted === true) {
+            throw new CancelledError("request cancelled during retry backoff");
+        }
+        throw error;
+    }
+    assertNotAborted(signal);
+}
+export async function executeWithRetry(operation, config, clock, signal) {
+    let lastError;
+    const start = clock.now();
+    for (let attempt = 1; attempt <= config.maxRetries + 1; attempt += 1) {
+        assertNotAborted(signal);
+        const attemptBudget = remainingBudgetMs(start, config.timeoutMs, clock);
+        if (attemptBudget <= 0) {
+            if (lastError) {
+                throw lastError;
+            }
+            throw new CancelledError("request timeout budget exhausted before provider call");
+        }
+        try {
+            return await operation(Number.isFinite(attemptBudget) ? Math.max(1, Math.floor(attemptBudget)) : undefined);
+        }
+        catch (error) {
+            lastError = asError(error);
+            const delay = attempt <= config.maxRetries
+                ? retryDelayMs(lastError, attempt, config.retryBaseDelayMs)
+                : null;
+            if (delay === null) {
+                throw lastError;
+            }
+            const remaining = remainingBudgetMs(start, config.timeoutMs, clock);
+            if (remaining <= 0) {
+                throw lastError;
+            }
+            await sleepWithCancellation(clock, Math.min(delay, remaining), signal);
+        }
+    }
+    throw lastError ?? new CancelledError("request timeout budget exhausted after retries");
+}
+export class CircuitBreaker {
+    modelId;
+    config;
+    clock;
+    state = "closed";
+    consecutiveFailures = 0;
+    openedAt = null;
+    probesRemaining = 0;
+    constructor(modelId, config, clock) {
+        this.modelId = modelId;
+        this.config = config;
+        this.clock = clock;
+    }
+    // Called before forwarding a request. Throws CircuitOpenError when the breaker is
+    // open and the cooldown has not elapsed; otherwise lets the call through (entering
+    // half-open as a side effect when cooldown has passed).
+    assertAllowed() {
+        if (this.state === "open") {
+            if (this.openedAt !== null && this.clock.now() - this.openedAt >= this.config.cooldownMs) {
+                this.state = "half-open";
+                this.probesRemaining = this.config.halfOpenProbes;
+                return;
+            }
+            throw new CircuitOpenError(`circuit open for model '${this.modelId}'`);
+        }
+    }
+    recordSuccess() {
+        if (this.state === "half-open") {
+            this.probesRemaining -= 1;
+            if (this.probesRemaining <= 0) {
+                this.close();
+            }
+            return;
+        }
+        this.consecutiveFailures = 0;
+    }
+    recordFailure() {
+        if (this.state === "half-open") {
+            this.open();
+            return;
+        }
+        this.consecutiveFailures += 1;
+        if (this.consecutiveFailures >= this.config.failureThreshold) {
+            this.open();
+        }
+    }
+    status(modelId) {
+        return {
+            modelId,
+            state: this.state,
+            consecutiveFailures: this.consecutiveFailures,
+            openedAt: this.openedAt,
+        };
+    }
+    open() {
+        this.state = "open";
+        this.openedAt = this.clock.now();
+        this.probesRemaining = 0;
+    }
+    close() {
+        this.state = "closed";
+        this.consecutiveFailures = 0;
+        this.openedAt = null;
+        this.probesRemaining = 0;
+    }
+}

package/node_modules/@oscharko-dev/keiko-model-gateway/dist/types.d.ts

@@ -0,0 +1,36 @@
+import type { ModelCapability, NormalizedResponse, GatewayRequest } from "@oscharko-dev/keiko-contracts";
+export type { ModelKind, CostClass, LatencyClass, ModelCapability, ChatMessage, ToolDefinition, ResponseFormat, GatewayRequest, NormalizedToolCall, UsageMetadata, NormalizedResponse, FinishReason, StreamDelta, StreamEvent, } from "@oscharko-dev/keiko-contracts";
+export interface ModelProviderConfig {
+    readonly modelId: string;
+    readonly baseUrl: string;
+    readonly apiKey: string;
+    readonly apiKeyHeaderName?: string | undefined;
+    readonly timeoutMs: number;
+    readonly maxRetries: number;
+    readonly retryBaseDelayMs: number;
+}
+export interface CircuitBreakerConfig {
+    readonly failureThreshold: number;
+    readonly cooldownMs: number;
+    readonly halfOpenProbes: number;
+}
+export interface GatewayConfig {
+    readonly providers: readonly ModelProviderConfig[];
+    readonly circuitBreaker: CircuitBreakerConfig;
+    readonly capabilities?: readonly ModelCapability[] | undefined;
+}
+export interface ProviderAdapter {
+    readonly call: (request: GatewayRequest, config: ModelProviderConfig) => Promise<NormalizedResponse>;
+}
+export interface Clock {
+    readonly now: () => number;
+    readonly sleep: (ms: number, signal?: AbortSignal) => Promise<void>;
+}
+export type CircuitState = "closed" | "open" | "half-open";
+export interface CircuitBreakerStatus {
+    readonly modelId: string;
+    readonly state: CircuitState;
+    readonly consecutiveFailures: number;
+    readonly openedAt: number | null;
+}
+//# sourceMappingURL=types.d.ts.map

package/node_modules/@oscharko-dev/keiko-model-gateway/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EACV,eAAe,EACf,kBAAkB,EAClB,cAAc,EACf,MAAM,+BAA+B,CAAC;AAEvC,YAAY,EACV,SAAS,EACT,SAAS,EACT,YAAY,EACZ,eAAe,EACf,WAAW,EACX,cAAc,EACd,cAAc,EACd,cAAc,EACd,kBAAkB,EAClB,aAAa,EACb,kBAAkB,EAClB,YAAY,EACZ,WAAW,EACX,WAAW,GACZ,MAAM,+BAA+B,CAAC;AAIvC,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/C,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;CACnC;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;CACjC;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,SAAS,EAAE,SAAS,mBAAmB,EAAE,CAAC;IACnD,QAAQ,CAAC,cAAc,EAAE,oBAAoB,CAAC;IAC9C,QAAQ,CAAC,YAAY,CAAC,EAAE,SAAS,eAAe,EAAE,GAAG,SAAS,CAAC;CAChE;AAID,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,IAAI,EAAE,CACb,OAAO,EAAE,cAAc,EACvB,MAAM,EAAE,mBAAmB,KACxB,OAAO,CAAC,kBAAkB,CAAC,CAAC;CAClC;AAID,MAAM,WAAW,KAAK;IACpB,QAAQ,CAAC,GAAG,EAAE,MAAM,MAAM,CAAC;IAC3B,QAAQ,CAAC,KAAK,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACrE;AAID,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG,MAAM,GAAG,WAAW,CAAC;AAE3D,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;IAC7B,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAC;IACrC,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;CAClC"}

package/node_modules/@oscharko-dev/keiko-model-gateway/dist/types.js

@@ -0,0 +1,6 @@
+// Re-export shim: wire-safe gateway contract types live in @oscharko-dev/keiko-contracts
+// (issue #158). Credential-bearing / port shapes (ModelProviderConfig, GatewayConfig,
+// CircuitBreakerConfig, ProviderAdapter, Clock, CircuitState, CircuitBreakerStatus) STAY here
+// so contracts never carries an apiKey-shaped surface (ADR-0019 direction 1 contracts-leaf).
+// `verbatimModuleSyntax` is on, so type-only names use `export type`.
+export {};

package/node_modules/@oscharko-dev/keiko-model-gateway/dist/version.d.ts

@@ -0,0 +1,2 @@
+export declare const KEIKO_MODEL_GATEWAY_VERSION: "0.1.0";
+//# sourceMappingURL=version.d.ts.map

package/node_modules/@oscharko-dev/keiko-model-gateway/dist/version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../src/version.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,2BAA2B,EAAG,OAAgB,CAAC"}

package/node_modules/@oscharko-dev/keiko-model-gateway/dist/version.js

@@ -0,0 +1,3 @@
+// Package version constant. Pinned at the workspace package's package.json version. Promoted to
+// a `const` string-literal type so downstream tests/assertions stay byte-exact.
+export const KEIKO_MODEL_GATEWAY_VERSION = "0.1.0";