@illuminis/comprism 0.1.3 → 0.1.4

package/out/providers/anthropic.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProviderHttpError = void 0;
+exports.callAnthropic = callAnthropic;
+const DEFAULT_BASE = 'https://api.anthropic.com';
+const API_VERSION = '2023-06-01';
+/**
+ * Honor the same base-URL override every client in this ecosystem supports.
+ *
+ * It is the mechanism our own proxy is installed with, so the Companion's SDK
+ * respecting it is not a test hook: it is what lets one instrumented tool sit
+ * behind another, and what lets a customer point us at a gateway they already
+ * run.
+ */
+function endpoint() {
+    const base = (process.env.ANTHROPIC_BASE_URL || DEFAULT_BASE).replace(/\/+$/, '');
+    return `${base}/v1/messages`;
+}
+async function callAnthropic(call) {
+    const started = Date.now();
+    const res = await fetch(endpoint(), {
+        method: 'POST',
+        headers: {
+            'content-type': 'application/json',
+            'x-api-key': call.apiKey,
+            'anthropic-version': API_VERSION,
+        },
+        body: JSON.stringify({
+            model: call.model,
+            max_tokens: call.maxTokens,
+            messages: call.messages.map((m) => ({ role: m.role, content: m.content })),
+        }),
+    });
+    const latencyMs = Date.now() - started;
+    if (!res.ok) {
+        // The status line, never the body: a provider error body can echo the
+        // request, and the request is the customer's content.
+        const err = new ProviderHttpError(res.status, `anthropic ${res.status} ${res.statusText}`);
+        err.latencyMs = latencyMs;
+        throw err;
+    }
+    const body = (await res.json());
+    const blocks = body.content || [];
+    const text = blocks
+        .filter((b) => b.type === 'text' && typeof b.text === 'string')
+        .map((b) => b.text)
+        .join('');
+    // A model that thinks by default and is given a tight token ceiling spends the
+    // ceiling on thinking and answers with nothing. That returns as an empty
+    // string, which is indistinguishable from a bad answer - and it cost a real
+    // bake-off run before it was caught. Name it instead of hiding it.
+    const thoughtButDidNotAnswer = text.length === 0 && blocks.some((b) => b.type === 'thinking' || b.type === 'redacted_thinking');
+    const usage = {
+        inputTokens: typeof body.usage?.input_tokens === 'number' ? body.usage.input_tokens : null,
+        outputTokens: typeof body.usage?.output_tokens === 'number' ? body.usage.output_tokens : null,
+    };
+    return {
+        text,
+        usage,
+        finishReason: thoughtButDidNotAnswer ? 'thinking_exhausted_budget' : body.stop_reason || 'end_turn',
+        latencyMs,
+        usageReported: usage.inputTokens !== null && usage.outputTokens !== null,
+        ...(thoughtButDidNotAnswer
+            ? {
+                errorMessage: 'the model used its whole token budget thinking and had none left to answer; raise maxTokens',
+            }
+            : {}),
+    };
+}
+/** Carries the status code so the shared retry policy can read it. */
+class ProviderHttpError extends Error {
+    status;
+    latencyMs = 0;
+    constructor(status, message) {
+        super(message);
+        this.name = 'ProviderHttpError';
+        this.status = status;
+    }
+}
+exports.ProviderHttpError = ProviderHttpError;

package/out/providers/index.d.ts

@@ -0,0 +1,8 @@
+import type { Keys } from '../lib/config';
+import type { Provider, ProviderCall, ProviderResult } from '../lib/types';
+export { ProviderHttpError } from './anthropic';
+export declare function providerOf(model: string): Provider | null;
+/**
+ * Dispatch one call. Returns a result in every case, including failure.
+ */
+export declare function callModel(call: ProviderCall, keys: Keys): Promise<ProviderResult>;

package/out/providers/index.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProviderHttpError = void 0;
+exports.providerOf = providerOf;
+exports.callModel = callModel;
+/**
+ * One normalized call interface across every provider.
+ *
+ * Two properties matter to everything downstream:
+ *
+ *   1. `callModel` never throws out of `send()`. A provider error becomes
+ *      `finishReason: 'error'` with an empty body, so the ledger still gets its
+ *      row and the client still records what happened. Rule 10, fail open: the
+ *      product being unable to reach a provider must look like a recorded
+ *      failure, not like a crash in someone's editor.
+ *   2. One retry on 429 and 5xx with jitter, then surface. A second retry buys
+ *      little and doubles the worst-case wait a person is sitting through.
+ */
+const catalog_1 = require("../internal/catalog");
+const anthropic_1 = require("./anthropic");
+const openai_1 = require("./openai");
+var anthropic_2 = require("./anthropic");
+Object.defineProperty(exports, "ProviderHttpError", { enumerable: true, get: function () { return anthropic_2.ProviderHttpError; } });
+const DEFAULT_MAX_TOKENS = 4096;
+const RETRY_BASE_MS = 400;
+function isRetryable(err) {
+    if (err instanceof anthropic_1.ProviderHttpError)
+        return err.status === 429 || err.status >= 500;
+    // A transport failure - DNS, reset connection, timeout - is worth one retry.
+    return err instanceof TypeError;
+}
+function jitteredDelay() {
+    return RETRY_BASE_MS + Math.floor(Math.random() * RETRY_BASE_MS);
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function providerOf(model) {
+    return (0, catalog_1.findModel)(model)?.provider ?? null;
+}
+/**
+ * Dispatch one call. Returns a result in every case, including failure.
+ */
+async function callModel(call, keys) {
+    const provider = providerOf(call.model);
+    if (!provider) {
+        return errorResult(`unknown model: ${call.model}`, 0);
+    }
+    const apiKey = keys[provider];
+    if (!apiKey) {
+        return errorResult(`no key resolved for ${provider}`, 0);
+    }
+    const maxTokens = call.maxTokens ?? DEFAULT_MAX_TOKENS;
+    const args = { model: call.model, messages: call.messages, maxTokens, apiKey };
+    for (let attempt = 0; attempt < 2; attempt++) {
+        try {
+            return provider === 'anthropic' ? await (0, anthropic_1.callAnthropic)(args) : await (0, openai_1.callOpenAi)(args);
+        }
+        catch (err) {
+            if (attempt === 0 && isRetryable(err)) {
+                await sleep(jitteredDelay());
+                continue;
+            }
+            const latency = err instanceof anthropic_1.ProviderHttpError ? err.latencyMs : 0;
+            return errorResult(err instanceof Error ? err.message : 'provider call failed', latency);
+        }
+    }
+    return errorResult('provider call failed', 0);
+}
+/**
+ * The failure shape. The message is a status line or a transport error - never
+ * a response body, which can contain the request that produced it.
+ */
+function errorResult(message, latencyMs) {
+    return {
+        text: '',
+        usage: { inputTokens: null, outputTokens: null },
+        finishReason: 'error',
+        latencyMs,
+        usageReported: false,
+        errorMessage: message,
+    };
+}

package/out/providers/openai.d.ts

@@ -0,0 +1,11 @@
+/**
+ * OpenAI adapter. Same shape as the Anthropic one, same dependency-free stance.
+ */
+import type { Message, ProviderResult } from '../lib/types';
+export interface OpenAiCall {
+    model: string;
+    messages: Message[];
+    maxTokens: number;
+    apiKey: string;
+}
+export declare function callOpenAi(call: OpenAiCall): Promise<ProviderResult>;

package/out/providers/openai.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callOpenAi = callOpenAi;
+const anthropic_1 = require("./anthropic");
+const DEFAULT_BASE = 'https://api.openai.com/v1';
+/** Same base-URL override every OpenAI-compatible client already supports. */
+function endpoint() {
+    const base = (process.env.OPENAI_BASE_URL || DEFAULT_BASE).replace(/\/+$/, '');
+    return `${base}/chat/completions`;
+}
+/**
+ * The reasoning-model families take `max_completion_tokens`; the older chat
+ * families take `max_tokens`. Sending the wrong one is a 400, so the choice is
+ * made from the model id rather than left to the caller.
+ */
+function tokenLimitField(model) {
+    return /^gpt-4/.test(model) ? 'max_tokens' : 'max_completion_tokens';
+}
+async function callOpenAi(call) {
+    const started = Date.now();
+    const body = {
+        model: call.model,
+        messages: call.messages.map((m) => ({ role: m.role, content: m.content })),
+    };
+    body[tokenLimitField(call.model)] = call.maxTokens;
+    const res = await fetch(endpoint(), {
+        method: 'POST',
+        headers: {
+            'content-type': 'application/json',
+            authorization: `Bearer ${call.apiKey}`,
+        },
+        body: JSON.stringify(body),
+    });
+    const latencyMs = Date.now() - started;
+    if (!res.ok) {
+        const err = new anthropic_1.ProviderHttpError(res.status, `openai ${res.status} ${res.statusText}`);
+        err.latencyMs = latencyMs;
+        throw err;
+    }
+    const parsed = (await res.json());
+    const choice = parsed.choices?.[0];
+    const text = choice?.message?.content || '';
+    const usage = {
+        inputTokens: typeof parsed.usage?.prompt_tokens === 'number' ? parsed.usage.prompt_tokens : null,
+        outputTokens: typeof parsed.usage?.completion_tokens === 'number' ? parsed.usage.completion_tokens : null,
+        reasoningTokens: typeof parsed.usage?.completion_tokens_details?.reasoning_tokens === 'number'
+            ? parsed.usage.completion_tokens_details.reasoning_tokens
+            : null,
+    };
+    return {
+        text,
+        usage,
+        finishReason: choice?.finish_reason || 'stop',
+        latencyMs,
+        usageReported: usage.inputTokens !== null && usage.outputTokens !== null,
+    };
+}