@oscharko-dev/keiko 0.1.5 → 0.1.7

package/dist/gateway/http.d.ts

@@ -1,8 +1,2 @@
-export declare const MAX_RESPONSE_BYTES = 10000000;
-export interface GatewayFetchOptions extends RequestInit {
-    readonly fetchImpl?: typeof fetch | undefined;
-    readonly useCaFallback?: boolean | undefined;
-}
-export declare function isMissingIssuerError(error: unknown): boolean;
-export declare function gatewayFetch(url: string, options?: GatewayFetchOptions): Promise<Response>;
-export declare function readJsonCapped(response: Response, maxBytes?: number): Promise<unknown>;
+export { gatewayFetch, gatewayTrustedCaCertificates, isMissingIssuerError, isRecoverableTlsTrustError, MAX_RESPONSE_BYTES, readJsonCapped, } from "@oscharko-dev/keiko-model-gateway/internal/http";
+export type { GatewayFetchOptions } from "@oscharko-dev/keiko-model-gateway/internal/http";

package/dist/gateway/http.js

@@ -1,142 +1,3 @@
-import { readFileSync } from "node:fs";
-import { request as httpsRequest } from "node:https";
-import { rootCertificates } from "node:tls";
-// Caps a single gateway response at 10 MB; real chat completions are far smaller.
-export const MAX_RESPONSE_BYTES = 10_000_000;
-function headersFromNode(headers) {
-    const out = new Headers();
-    for (const [name, value] of Object.entries(headers)) {
-        if (Array.isArray(value)) {
-            for (const item of value)
-                out.append(name, item);
-        }
-        else if (value !== undefined) {
-            out.set(name, value);
-        }
-    }
-    return out;
-}
-function headersToRecord(headers) {
-    const out = {};
-    const normalized = new Headers(headers);
-    normalized.forEach((value, key) => {
-        out[key] = value;
-    });
-    return out;
-}
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-export function isMissingIssuerError(error) {
-    const cause = isRecord(error) ? error.cause : undefined;
-    const candidates = [error, cause];
-    return candidates.some((item) => {
-        if (!isRecord(item))
-            return false;
-        return item.code === "UNABLE_TO_GET_ISSUER_CERT_LOCALLY";
-    });
-}
-function usesHttps(url) {
-    try {
-        return new URL(url).protocol === "https:";
-    }
-    catch {
-        return false;
-    }
-}
-function extraCaCertificates() {
-    const path = process.env.NODE_EXTRA_CA_CERTS;
-    if (path === undefined || path.trim().length === 0) {
-        return [];
-    }
-    try {
-        return [readFileSync(path, "utf8")];
-    }
-    catch {
-        return [];
-    }
-}
-function caBundle() {
-    return [...rootCertificates, ...extraCaCertificates()];
-}
-function bodyToString(body) {
-    if (body === undefined || body === null) {
-        return undefined;
-    }
-    if (typeof body === "string") {
-        return body;
-    }
-    if (body instanceof URLSearchParams) {
-        return body.toString();
-    }
-    throw new TypeError("gateway HTTP fallback supports string request bodies only");
-}
-function fetchWithCaBundle(url, init) {
-    const body = bodyToString(init.body);
-    const headers = headersToRecord(init.headers);
-    return new Promise((resolve, reject) => {
-        const req = httpsRequest(url, {
-            method: init.method ?? "GET",
-            headers,
-            ca: [...caBundle()],
-            signal: init.signal ?? undefined,
-        }, (res) => {
-            const chunks = [];
-            let total = 0;
-            res.on("data", (chunk) => {
-                total += chunk.length;
-                if (total > MAX_RESPONSE_BYTES) {
-                    req.destroy();
-                    reject(new Error("gateway response exceeded the size limit"));
-                    return;
-                }
-                chunks.push(chunk);
-            });
-            res.on("end", () => {
-                resolve(new Response(Buffer.concat(chunks), {
-                    status: res.statusCode ?? 500,
-                    statusText: res.statusMessage ?? "",
-                    headers: headersFromNode(res.headers),
-                }));
-            });
-            res.on("error", reject);
-        });
-        req.on("error", reject);
-        req.end(body);
-    });
-}
-export async function gatewayFetch(url, options = {}) {
-    const { fetchImpl, useCaFallback = fetchImpl === undefined, ...init } = options;
-    const doFetch = fetchImpl ?? globalThis.fetch;
-    try {
-        return await doFetch(url, init);
-    }
-    catch (error) {
-        if (useCaFallback && usesHttps(url) && isMissingIssuerError(error)) {
-            return fetchWithCaBundle(url, init);
-        }
-        throw error;
-    }
-}
-export async function readJsonCapped(response, maxBytes = MAX_RESPONSE_BYTES) {
-    if (response.body === null) {
-        return response.json();
-    }
-    const reader = response.body.getReader();
-    const decoder = new TextDecoder();
-    const parts = [];
-    let total = 0;
-    for (;;) {
-        const { done, value } = await reader.read();
-        if (done)
-            break;
-        total += value.byteLength;
-        if (total > maxBytes) {
-            await reader.cancel();
-            throw new Error("response body exceeded the size limit");
-        }
-        parts.push(decoder.decode(value, { stream: true }));
-    }
-    parts.push(decoder.decode());
-    return JSON.parse(parts.join(""));
-}
+// Re-export shim: http now lives in @oscharko-dev/keiko-model-gateway (issue #160, ADR-0019).
+// All existing import sites (`from "../gateway/http.js"`) keep resolving unchanged via this barrel.
+export { gatewayFetch, gatewayTrustedCaCertificates, isMissingIssuerError, isRecoverableTlsTrustError, MAX_RESPONSE_BYTES, readJsonCapped, } from "@oscharko-dev/keiko-model-gateway/internal/http";

package/dist/gateway/index.d.ts

@@ -1,10 +1,12 @@
-export type { CircuitBreakerConfig, CircuitBreakerStatus, CircuitState, ChatMessage, Clock, CostClass, FinishReason, GatewayConfig, GatewayRequest, LatencyClass, ModelCapability, ModelKind, ModelProviderConfig, NormalizedResponse, NormalizedToolCall, ProviderAdapter, ResponseFormat, StreamDelta, StreamEvent, ToolDefinition, UsageMetadata, } from "./types.js";
-export { CAPABILITY_REGISTRY, createDefaultChatCapability, findCapability, listCapabilities, selectCheapest, type CapabilityQuery, } from "./capabilities.js";
-export { apiKeyHeaderValue, DEFAULT_API_KEY_HEADER_NAME, loadConfigFromFile, normalizeApiKeyHeaderName, parseGatewayConfig, toSafeObject, validateBaseUrl, type EnvSource, type SafeGatewayConfig, type SafeProviderConfig, } from "./config.js";
-export { Gateway, type GatewayDeps } from "./gateway.js";
-export { OpenAiAdapter, type AdapterDeps } from "./openai-adapter.js";
-export { assertConfiguredModel, findConfiguredCapability, listConfiguredCapabilities, selectConfiguredModel, type ModelSelectionQuery, } from "./model-selection.js";
-export { CircuitBreaker, executeWithRetry, systemClock, type RetryConfig } from "./resilience.js";
-export { normalizeChatResponse, type UsageSeed } from "./normalize.js";
-export { redact } from "./redaction.js";
-export { AuthenticationError, CancelledError, CircuitOpenError, ConfigInvalidError, ContextOverflowError, ERROR_CODES, GatewayError, MalformedToolCallError, ModelRefusalError, ProviderError, RateLimitError, TimeoutError, TransportError, UnknownModelError, type ErrorCode, } from "./errors.js";
+export type { CircuitBreakerConfig, CircuitBreakerStatus, CircuitState, ChatMessage, Clock, CostClass, FinishReason, GatewayConfig, GatewayRequest, LatencyClass, ModelCapability, ModelKind, ModelProviderConfig, NormalizedResponse, NormalizedToolCall, ProviderAdapter, ResponseFormat, StreamDelta, StreamEvent, ToolDefinition, UsageMetadata, } from "@oscharko-dev/keiko-model-gateway";
+export { CAPABILITY_REGISTRY, createDefaultChatCapability, findCapability, listCapabilities, resolveCostClass, selectCheapest, } from "@oscharko-dev/keiko-model-gateway";
+export type { CapabilityQuery } from "@oscharko-dev/keiko-model-gateway";
+export { apiKeyHeaderValue, DEFAULT_API_KEY_HEADER_NAME, loadConfigFromFile, normalizeApiKeyHeaderName, parseGatewayConfig, toSafeObject, validateBaseUrl, } from "@oscharko-dev/keiko-model-gateway";
+export type { EnvSource, SafeGatewayConfig, SafeProviderConfig, } from "@oscharko-dev/keiko-model-gateway";
+export { Gateway } from "@oscharko-dev/keiko-model-gateway";
+export type { GatewayDeps } from "@oscharko-dev/keiko-model-gateway";
+export { assertConfiguredModel, findConfiguredCapability, listConfiguredCapabilities, selectConfiguredModel, } from "@oscharko-dev/keiko-model-gateway";
+export type { ModelSelectionQuery } from "@oscharko-dev/keiko-model-gateway";
+export { redact } from "@oscharko-dev/keiko-model-gateway";
+export { AuthenticationError, CancelledError, CircuitOpenError, ConfigInvalidError, ContextOverflowError, ERROR_CODES, GatewayError, MalformedToolCallError, ModelRefusalError, ProviderError, RateLimitError, TimeoutError, TransportError, UnknownModelError, } from "@oscharko-dev/keiko-model-gateway";
+export type { ErrorCode } from "@oscharko-dev/keiko-model-gateway";

package/dist/gateway/index.js

@@ -1,11 +1,9 @@
-// Public barrel for the model gateway: all types, the Gateway orchestrator, the
-// capability registry helpers, config loaders, and the typed error taxonomy.
-export { CAPABILITY_REGISTRY, createDefaultChatCapability, findCapability, listCapabilities, selectCheapest, } from "./capabilities.js";
-export { apiKeyHeaderValue, DEFAULT_API_KEY_HEADER_NAME, loadConfigFromFile, normalizeApiKeyHeaderName, parseGatewayConfig, toSafeObject, validateBaseUrl, } from "./config.js";
-export { Gateway } from "./gateway.js";
-export { OpenAiAdapter } from "./openai-adapter.js";
-export { assertConfiguredModel, findConfiguredCapability, listConfiguredCapabilities, selectConfiguredModel, } from "./model-selection.js";
-export { CircuitBreaker, executeWithRetry, systemClock } from "./resilience.js";
-export { normalizeChatResponse } from "./normalize.js";
-export { redact } from "./redaction.js";
-export { AuthenticationError, CancelledError, CircuitOpenError, ConfigInvalidError, ContextOverflowError, ERROR_CODES, GatewayError, MalformedToolCallError, ModelRefusalError, ProviderError, RateLimitError, TimeoutError, TransportError, UnknownModelError, } from "./errors.js";
+// Re-export shim: the gateway barrel now lives in @oscharko-dev/keiko-model-gateway (issue #160,
+// ADR-0019). All existing import sites (`from "../gateway/index.js"`) keep resolving unchanged via
+// this barrel. The full public surface of the original src/gateway/index.ts is preserved.
+export { CAPABILITY_REGISTRY, createDefaultChatCapability, findCapability, listCapabilities, resolveCostClass, selectCheapest, } from "@oscharko-dev/keiko-model-gateway";
+export { apiKeyHeaderValue, DEFAULT_API_KEY_HEADER_NAME, loadConfigFromFile, normalizeApiKeyHeaderName, parseGatewayConfig, toSafeObject, validateBaseUrl, } from "@oscharko-dev/keiko-model-gateway";
+export { Gateway } from "@oscharko-dev/keiko-model-gateway";
+export { assertConfiguredModel, findConfiguredCapability, listConfiguredCapabilities, selectConfiguredModel, } from "@oscharko-dev/keiko-model-gateway";
+export { redact } from "@oscharko-dev/keiko-model-gateway";
+export { AuthenticationError, CancelledError, CircuitOpenError, ConfigInvalidError, ContextOverflowError, ERROR_CODES, GatewayError, MalformedToolCallError, ModelRefusalError, ProviderError, RateLimitError, TimeoutError, TransportError, UnknownModelError, } from "@oscharko-dev/keiko-model-gateway";

package/dist/gateway/model-selection.d.ts

@@ -1,11 +1,2 @@
-import type { GatewayConfig, ModelCapability, ModelKind } from "./types.js";
-export interface ModelSelectionQuery {
-    readonly kind: ModelKind;
-    readonly toolCalling?: boolean | undefined;
-    readonly structuredOutput?: boolean | undefined;
-    readonly minContextWindow?: number | undefined;
-}
-export declare function assertConfiguredModel(config: GatewayConfig, modelId: string): void;
-export declare function findConfiguredCapability(config: GatewayConfig, modelId: string): ModelCapability | undefined;
-export declare function listConfiguredCapabilities(config: GatewayConfig): readonly ModelCapability[];
-export declare function selectConfiguredModel(config: GatewayConfig, query: ModelSelectionQuery): string | undefined;
+export { assertConfiguredModel, findConfiguredCapability, listConfiguredCapabilities, selectConfiguredModel, } from "@oscharko-dev/keiko-model-gateway";
+export type { ModelSelectionQuery } from "@oscharko-dev/keiko-model-gateway";

package/dist/gateway/model-selection.js

@@ -1,47 +1,3 @@
-import { createDefaultChatCapability, listCapabilities } from "./capabilities.js";
-import { ConfigInvalidError } from "./errors.js";
-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;
-}
+// Re-export shim: model-selection now lives in @oscharko-dev/keiko-model-gateway (issue #160, ADR-0019).
+// All existing import sites (`from "../gateway/model-selection.js"`) keep resolving unchanged via this barrel.
+export { assertConfiguredModel, findConfiguredCapability, listConfiguredCapabilities, selectConfiguredModel, } from "@oscharko-dev/keiko-model-gateway";

package/dist/gateway/normalize.d.ts

@@ -1,7 +1,2 @@
-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;
+export { normalizeChatResponse } from "@oscharko-dev/keiko-model-gateway/internal/normalize";
+export type { UsageSeed } from "@oscharko-dev/keiko-model-gateway/internal/normalize";

package/dist/gateway/normalize.js

@@ -1,93 +1,3 @@
-// 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 "./errors.js";
-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 };
-}
+// Re-export shim: normalize now lives in @oscharko-dev/keiko-model-gateway (issue #160, ADR-0019).
+// All existing import sites (`from "../gateway/normalize.js"`) keep resolving unchanged via this barrel.
+export { normalizeChatResponse } from "@oscharko-dev/keiko-model-gateway/internal/normalize";

package/dist/gateway/openai-adapter.d.ts

@@ -1,17 +1,2 @@
-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;
-}
+export { OpenAiAdapter } from "@oscharko-dev/keiko-model-gateway/internal/openai-adapter";
+export type { AdapterDeps } from "@oscharko-dev/keiko-model-gateway/internal/openai-adapter";

package/dist/gateway/openai-adapter.js

@@ -1,200 +1,3 @@
-// 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 "./errors.js";
-import { apiKeyHeaderValue, DEFAULT_API_KEY_HEADER_NAME } from "./config.js";
-import { gatewayFetch, readJsonCapped } from "./http.js";
-import { normalizeChatResponse } from "./normalize.js";
-import { redact } from "./redaction.js";
-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;
-        }
-    }
-}
+// Re-export shim: openai-adapter now lives in @oscharko-dev/keiko-model-gateway (issue #160, ADR-0019).
+// All existing import sites (`from "../gateway/openai-adapter.js"`) keep resolving unchanged via this barrel.
+export { OpenAiAdapter } from "@oscharko-dev/keiko-model-gateway/internal/openai-adapter";

package/dist/gateway/redaction.d.ts

@@ -1 +1 @@
-export declare function redact(input: string, additionalSecrets?: readonly string[]): string;
+export { redact } from "@oscharko-dev/keiko-security";