@genesislcap/foundation-ai 14.438.0 → 14.439.0

package/dist/esm/transports/anthropic-transport.js

@@ -0,0 +1,367 @@
+import { __awaiter } from "tslib";
+import { SUPPORTED_ANTHROPIC_MODEL_IDS, } from '../types';
+import { logger } from '../utils/logger';
+const ANTHROPIC_DIRECT_URL = 'https://api.anthropic.com/v1/messages';
+const ANTHROPIC_API_VERSION = '2023-06-01';
+const DEFAULT_MODEL = 'claude-haiku-4-5-20251001';
+const DEFAULT_TIMEOUT = 180000; // 3 minutes
+const DEFAULT_MAX_TOKENS = 4096;
+/**
+ * Maximum input context window (tokens) per supported Claude model.
+ * Source: https://docs.claude.com/en/docs/about-claude/models/overview
+ */
+const ANTHROPIC_CONTEXT_LIMITS = {
+    'claude-opus-4-7': 1000000,
+    'claude-sonnet-4-6': 1000000,
+    'claude-haiku-4-5-20251001': 200000,
+};
+/**
+ * Tool name used to coerce JSON-schema output from the model when the caller
+ * provided a `responseSchema`. The transport forces `tool_choice` to this tool
+ * and surfaces the `input` field as the structured response.
+ */
+const STRUCTURED_OUTPUT_TOOL_NAME = 'emit_structured_response';
+function assertSupportedAnthropicModel(model) {
+    if (!SUPPORTED_ANTHROPIC_MODEL_IDS.includes(model)) {
+        throw new Error(`AnthropicTransport: unsupported model "${model}". Use one of: ${SUPPORTED_ANTHROPIC_MODEL_IDS.join(', ')}.`);
+    }
+}
+/**
+ * Standard tier pricing per million tokens — https://docs.claude.com/en/docs/about-claude/pricing
+ */
+function estimatedAnthropicRatesUsdPerMillion(model) {
+    if (model === 'claude-haiku-4-5-20251001') {
+        return { promptPerMillion: 1, candidatePerMillion: 5 };
+    }
+    if (model === 'claude-sonnet-4-6') {
+        return { promptPerMillion: 3, candidatePerMillion: 15 };
+    }
+    // Opus 4.7
+    return { promptPerMillion: 5, candidatePerMillion: 25 };
+}
+/**
+ * Transport for Anthropic Claude. Calls the Messages API directly when `apiKey`
+ * is provided, otherwise falls back to a server-proxy endpoint (if `serverEndpoint`
+ * is configured).
+ *
+ * Implements `AITransport` (structured prompt via tool-forcing) and `ChatTransport`
+ * (multi-turn chat).
+ *
+ * @beta
+ */
+export class AnthropicTransport {
+    constructor(config = {}) {
+        var _a, _b, _c;
+        /**
+         * Estimated USD cost accumulated across every successful request on this
+         * transport instance. Convenience accessor for non-chat consumers
+         * (telemetry, debug overlays). The main chat UI sums per-message `cost`
+         * fields instead so its session total stays attributed to chat turns only.
+         */
+        this.lifetimeCostUsd = 0;
+        const model = (_a = config.model) !== null && _a !== void 0 ? _a : DEFAULT_MODEL;
+        assertSupportedAnthropicModel(model);
+        this.model = model;
+        if (model === 'claude-sonnet-4-6') {
+            logger.warn('AnthropicTransport: using claude-sonnet-4-6 — higher cost than Haiku; use for stronger reasoning or agent tasks.');
+        }
+        else if (model === 'claude-opus-4-7') {
+            logger.warn('AnthropicTransport: using claude-opus-4-7 — significantly higher cost; reserve for tasks where Sonnet reliability is insufficient.');
+        }
+        this.timeout = (_b = config.timeout) !== null && _b !== void 0 ? _b : DEFAULT_TIMEOUT;
+        this.apiKey = config.apiKey;
+        this.serverEndpoint = config.serverEndpoint;
+        this.maxTokens = (_c = config.maxTokens) !== null && _c !== void 0 ? _c : DEFAULT_MAX_TOKENS;
+    }
+    getConfig() {
+        return {
+            provider: 'anthropic',
+            model: this.model,
+            contextLimit: ANTHROPIC_CONTEXT_LIMITS[this.model],
+        };
+    }
+    /** Estimated USD cost accumulated across every successful request on this transport instance. */
+    getLifetimeCost() {
+        return this.lifetimeCostUsd;
+    }
+    /** Reset the lifetime cost counter. Intended for chat-clear / new-session flows. */
+    resetLifetimeCost() {
+        this.lifetimeCostUsd = 0;
+    }
+    // ── AITransport (structured prompt) ────────────────────────────────────
+    sendStructuredPrompt(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            const { systemPrompt, userPrompt, responseSchema } = options;
+            const messages = [{ role: 'user', content: userPrompt }];
+            // Anthropic has no native JSON-schema response format. The supported pattern
+            // is to define a tool whose input_schema is the desired schema, then force
+            // the model to call it via tool_choice. The tool's `input` is the structured
+            // payload we surface back to the caller as a JSON string.
+            const tools = responseSchema
+                ? [
+                    {
+                        name: STRUCTURED_OUTPUT_TOOL_NAME,
+                        description: 'Emit the structured response that matches the required schema.',
+                        input_schema: responseSchema,
+                    },
+                ]
+                : undefined;
+            const body = {
+                model: this.model,
+                max_tokens: this.maxTokens,
+                messages,
+            };
+            if (systemPrompt)
+                body.system = systemPrompt;
+            if (tools) {
+                body.tools = tools;
+                body.tool_choice = { type: 'tool', name: STRUCTURED_OUTPUT_TOOL_NAME };
+            }
+            const response = yield this.post(body);
+            if (responseSchema) {
+                const toolUse = ((_a = response.content) !== null && _a !== void 0 ? _a : []).find((b) => b.type === 'tool_use' && b.name === STRUCTURED_OUTPUT_TOOL_NAME);
+                return toolUse ? JSON.stringify((_b = toolUse.input) !== null && _b !== void 0 ? _b : {}) : '';
+            }
+            return ((_c = response.content) !== null && _c !== void 0 ? _c : [])
+                .filter((b) => b.type === 'text')
+                .map((b) => b.text)
+                .join('');
+        });
+    }
+    // ── ChatTransport (multi-turn chat) ────────────────────────────────────
+    sendChatMessage(history, userMessage, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const messages = this.toAnthropicMessages(history, userMessage, options === null || options === void 0 ? void 0 : options.attachments);
+            const body = {
+                model: this.model,
+                max_tokens: this.maxTokens,
+                messages,
+            };
+            if (options === null || options === void 0 ? void 0 : options.systemPrompt)
+                body.system = options.systemPrompt;
+            if ((_a = options === null || options === void 0 ? void 0 : options.tools) === null || _a === void 0 ? void 0 : _a.length) {
+                body.tools = options.tools.map((t) => ({
+                    name: t.name,
+                    description: t.description,
+                    input_schema: t.parameters,
+                }));
+            }
+            const response = yield this.post(body, options === null || options === void 0 ? void 0 : options.signal);
+            return this.fromAnthropicResponse(response);
+        });
+    }
+    /**
+     * Logs the per-call cost breakdown, accumulates the lifetime running total,
+     * and returns the per-call total so the caller can attach it to the response
+     * message.
+     */
+    logTokenUsage(promptTokens, candidateTokens) {
+        const { promptPerMillion, candidatePerMillion } = estimatedAnthropicRatesUsdPerMillion(this.model);
+        const promptCost = (promptTokens / AnthropicTransport.TOKENS_PER_MILLION) * promptPerMillion;
+        const candidateCost = (candidateTokens / AnthropicTransport.TOKENS_PER_MILLION) * candidatePerMillion;
+        const totalCost = promptCost + candidateCost;
+        this.lifetimeCostUsd += totalCost;
+        console.log(`--- Anthropic Token Usage (${this.model}) ---`);
+        console.log(`Prompt Tokens:    ${promptTokens} ($${promptCost.toFixed(AnthropicTransport.COST_DECIMAL_PLACES)})`);
+        console.log(`Candidate Tokens: ${candidateTokens} ($${candidateCost.toFixed(AnthropicTransport.COST_DECIMAL_PLACES)})`);
+        console.log(`Total Cost:       $${totalCost.toFixed(AnthropicTransport.COST_DECIMAL_PLACES)}`);
+        console.log(`Lifetime Cost:    $${this.lifetimeCostUsd.toFixed(AnthropicTransport.COST_DECIMAL_PLACES)}`);
+        console.log('--------------------------');
+        return totalCost;
+    }
+    /**
+     * Convert the internal `ChatMessage[]` history into Anthropic's message format.
+     *
+     * Anthropic alternates strictly `user` / `assistant`. Tool calls are emitted by
+     * the assistant as `tool_use` blocks; the corresponding `tool_result` blocks
+     * must appear in the *next* user message and reference the tool by `tool_use_id`.
+     * Consecutive same-role turns are merged by the API but we merge here to keep
+     * the payload tidy.
+     */
+    toAnthropicMessages(history, userMessage, attachments) {
+        var _a, _b, _c;
+        const messages = [];
+        const pushBlock = (role, block) => {
+            const last = messages[messages.length - 1];
+            if (last && last.role === role && Array.isArray(last.content)) {
+                last.content.push(block);
+                return;
+            }
+            messages.push({ role, content: [block] });
+        };
+        for (const msg of history) {
+            if (msg.role === 'system' || msg.role === 'system-event' || msg.thinking)
+                continue;
+            if (msg.toolResult) {
+                pushBlock('user', {
+                    type: 'tool_result',
+                    tool_use_id: msg.toolResult.toolCallId,
+                    content: msg.toolResult.content,
+                });
+                continue;
+            }
+            if ((_a = msg.toolCalls) === null || _a === void 0 ? void 0 : _a.length) {
+                if (msg.content) {
+                    pushBlock('assistant', { type: 'text', text: msg.content });
+                }
+                for (const tc of msg.toolCalls) {
+                    pushBlock('assistant', {
+                        type: 'tool_use',
+                        id: tc.id,
+                        name: tc.name,
+                        input: (_b = tc.args) !== null && _b !== void 0 ? _b : {},
+                    });
+                }
+                continue;
+            }
+            const role = msg.role === 'user' ? 'user' : 'assistant';
+            if (role === 'user' && ((_c = msg.attachments) === null || _c === void 0 ? void 0 : _c.length)) {
+                pushBlock(role, { type: 'text', text: msg.content });
+                for (const att of msg.attachments) {
+                    pushBlock(role, { type: 'text', text: `[File: ${att.name}]\n${att.content}` });
+                }
+            }
+            else if (msg.content) {
+                pushBlock(role, { type: 'text', text: msg.content });
+            }
+        }
+        if (userMessage || (attachments === null || attachments === void 0 ? void 0 : attachments.length)) {
+            if (userMessage) {
+                pushBlock('user', { type: 'text', text: userMessage });
+            }
+            for (const att of attachments !== null && attachments !== void 0 ? attachments : []) {
+                pushBlock('user', { type: 'text', text: `[File: ${att.name}]\n${att.content}` });
+            }
+        }
+        return messages;
+    }
+    fromAnthropicResponse(response) {
+        var _a, _b, _c, _d;
+        let inputTokens;
+        let outputTokens;
+        let cost;
+        if (response.usage) {
+            cost = this.logTokenUsage((_a = response.usage.input_tokens) !== null && _a !== void 0 ? _a : 0, (_b = response.usage.output_tokens) !== null && _b !== void 0 ? _b : 0);
+            if (response.usage.input_tokens != null) {
+                inputTokens = response.usage.input_tokens;
+            }
+            if (response.usage.output_tokens != null) {
+                outputTokens = response.usage.output_tokens;
+            }
+        }
+        const blocks = (_c = response.content) !== null && _c !== void 0 ? _c : [];
+        const toolCalls = [];
+        const thoughtParts = [];
+        const textParts = [];
+        for (const block of blocks) {
+            if (block.type === 'tool_use') {
+                toolCalls.push({
+                    id: block.id,
+                    name: block.name,
+                    args: (_d = block.input) !== null && _d !== void 0 ? _d : {},
+                });
+            }
+            else if (block.type === 'thinking') {
+                thoughtParts.push(block.thinking);
+            }
+            else if (block.type === 'text') {
+                textParts.push(block.text);
+            }
+        }
+        const base = toolCalls.length > 0
+            ? {
+                role: 'assistant',
+                content: thoughtParts.join('') || textParts.join(''),
+                toolCalls,
+            }
+            : { role: 'assistant', content: textParts.join('') };
+        if (inputTokens != null)
+            base.inputTokens = inputTokens;
+        if (outputTokens != null)
+            base.outputTokens = outputTokens;
+        if (cost != null)
+            base.cost = cost;
+        return base;
+    }
+    buildEndpoint() {
+        if (this.apiKey) {
+            return {
+                url: ANTHROPIC_DIRECT_URL,
+                headers: {
+                    'Content-Type': 'application/json',
+                    'x-api-key': this.apiKey,
+                    'anthropic-version': ANTHROPIC_API_VERSION,
+                    // Anthropic blocks browser-origin requests by default. This header is the
+                    // documented opt-in (equivalent to the SDK's `dangerouslyAllowBrowser`).
+                    'anthropic-dangerous-direct-browser-access': 'true',
+                },
+                credentials: 'omit',
+            };
+        }
+        if (this.serverEndpoint) {
+            return {
+                url: this.serverEndpoint,
+                headers: { 'Content-Type': 'application/json' },
+                credentials: 'include',
+            };
+        }
+        throw new Error('AnthropicTransport: no API key or server endpoint configured. ' +
+            'Set ANTHROPIC_API_KEY in your .env or pass apiKey/serverEndpoint in AnthropicAIConfig.');
+    }
+    post(body, signal) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { url, headers, credentials } = this.buildEndpoint();
+            // Sequential retries are intentional — each attempt depends on the previous response.
+            /* eslint-disable no-await-in-loop */
+            for (let attempt = 0; attempt <= AnthropicTransport.MAX_RETRIES; attempt += 1) {
+                const controller = new AbortController();
+                const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+                let response;
+                try {
+                    response = yield fetch(url, {
+                        method: 'POST',
+                        headers,
+                        body: JSON.stringify(body),
+                        signal: signal !== null && signal !== void 0 ? signal : controller.signal,
+                        credentials,
+                    });
+                }
+                catch (e) {
+                    clearTimeout(timeoutId);
+                    throw e;
+                }
+                clearTimeout(timeoutId);
+                if (AnthropicTransport.RETRYABLE_STATUSES.includes(response.status) &&
+                    attempt < AnthropicTransport.MAX_RETRIES) {
+                    // Exponential backoff: 1s, 2s, 4s, 8s, 16s
+                    yield new Promise((resolve) => {
+                        setTimeout(resolve, AnthropicTransport.BACKOFF_BASE_MS * (1 << attempt));
+                    });
+                    continue;
+                }
+                if (!response.ok) {
+                    const err = yield response.text();
+                    throw new Error(`Anthropic request error ${response.status}: ${err}`);
+                }
+                return (yield response.json());
+            }
+            /* eslint-enable no-await-in-loop */
+            throw new Error('Anthropic request failed: max retries exceeded');
+        });
+    }
+}
+// ── Private helpers ────────────────────────────────────────────────────
+AnthropicTransport.TOKENS_PER_MILLION = 1000000;
+AnthropicTransport.COST_DECIMAL_PLACES = 6;
+AnthropicTransport.MAX_RETRIES = 5;
+AnthropicTransport.RATE_LIMIT_STATUS = 429;
+AnthropicTransport.SERVICE_UNAVAILABLE_STATUS = 503;
+AnthropicTransport.OVERLOADED_STATUS = 529;
+AnthropicTransport.RETRYABLE_STATUSES = [
+    AnthropicTransport.RATE_LIMIT_STATUS,
+    AnthropicTransport.SERVICE_UNAVAILABLE_STATUS,
+    AnthropicTransport.OVERLOADED_STATUS,
+];
+AnthropicTransport.BACKOFF_BASE_MS = 1000;

package/dist/esm/transports/gemini-transport.js

@@ -4,6 +4,15 @@ import { logger } from '../utils/logger';
 const GEMINI_DIRECT_URL = (model) => `https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent`;
 const DEFAULT_MODEL = 'gemini-2.5-flash-lite';
 const DEFAULT_TIMEOUT = 180000; // 3 minutes
+/**
+ * Maximum input context window (tokens) per supported Gemini model.
+ * Source: https://ai.google.dev/gemini-api/docs/models
+ */
+const GEMINI_CONTEXT_LIMITS = {
+    'gemini-2.5-pro': 1048576,
+    'gemini-2.5-flash': 1048576,
+    'gemini-2.5-flash-lite': 1048576,
+};
 function assertSupportedGeminiModel(model) {
     if (!SUPPORTED_GEMINI_MODEL_IDS.includes(model)) {
         throw new Error(`GeminiTransport: unsupported model "${model}". Use one of: ${SUPPORTED_GEMINI_MODEL_IDS.join(', ')}.`);
@@ -47,6 +56,13 @@ export class MalformedFunctionCallError extends Error {
 export class GeminiTransport {
     constructor(config = {}) {
         var _a, _b;
+        /**
+         * Estimated USD cost accumulated across every successful request on this
+         * transport instance. Convenience accessor for non-chat consumers
+         * (telemetry, debug overlays). The main chat UI sums per-message `cost`
+         * fields instead so its session total stays attributed to chat turns only.
+         */
+        this.lifetimeCostUsd = 0;
         const model = (_a = config.model) !== null && _a !== void 0 ? _a : DEFAULT_MODEL;
         assertSupportedGeminiModel(model);
         this.model = model;
@@ -61,7 +77,19 @@ export class GeminiTransport {
         this.serverEndpoint = config.serverEndpoint;
     }
     getConfig() {
-        return { provider: 'gemini', model: this.model };
+        return {
+            provider: 'gemini',
+            model: this.model,
+            contextLimit: GEMINI_CONTEXT_LIMITS[this.model],
+        };
+    }
+    /** Estimated USD cost accumulated across every successful request on this transport instance. */
+    getLifetimeCost() {
+        return this.lifetimeCostUsd;
+    }
+    /** Reset the lifetime cost counter. Intended for chat-clear / new-session flows. */
+    resetLifetimeCost() {
+        this.lifetimeCostUsd = 0;
     }
     // ── AITransport (structured prompt) ────────────────────────────────────
     sendStructuredPrompt(options) {
@@ -101,16 +129,24 @@ export class GeminiTransport {
             return this.fromGeminiResponse(response);
         });
     }
+    /**
+     * Logs the per-call cost breakdown, accumulates the lifetime running total,
+     * and returns the per-call total so the caller can attach it to the response
+     * message.
+     */
     logTokenUsage(promptTokens, candidateTokens) {
         const { promptPerMillion, candidatePerMillion } = estimatedGeminiPaidRatesUsdPerMillion(this.model);
         const promptCost = (promptTokens / GeminiTransport.TOKENS_PER_MILLION) * promptPerMillion;
         const candidateCost = (candidateTokens / GeminiTransport.TOKENS_PER_MILLION) * candidatePerMillion;
         const totalCost = promptCost + candidateCost;
+        this.lifetimeCostUsd += totalCost;
         console.log(`--- Gemini Token Usage (${this.model}) ---`);
         console.log(`Prompt Tokens:    ${promptTokens} ($${promptCost.toFixed(GeminiTransport.COST_DECIMAL_PLACES)})`);
         console.log(`Candidate Tokens: ${candidateTokens} ($${candidateCost.toFixed(GeminiTransport.COST_DECIMAL_PLACES)})`);
         console.log(`Total Cost:       $${totalCost.toFixed(GeminiTransport.COST_DECIMAL_PLACES)}`);
+        console.log(`Lifetime Cost:    $${this.lifetimeCostUsd.toFixed(GeminiTransport.COST_DECIMAL_PLACES)}`);
         console.log('--------------------------');
+        return totalCost;
     }
     toGeminiContents(history, userMessage, attachments) {
         var _a, _b, _c;
@@ -168,12 +204,17 @@ export class GeminiTransport {
     fromGeminiResponse(response) {
         var _a, _b, _c, _d, _e;
         let inputTokens;
+        let outputTokens;
+        let cost;
         if (response.usageMetadata) {
             const usage = response.usageMetadata;
-            this.logTokenUsage((_a = usage.promptTokenCount) !== null && _a !== void 0 ? _a : 0, (_b = usage.candidatesTokenCount) !== null && _b !== void 0 ? _b : 0);
+            cost = this.logTokenUsage((_a = usage.promptTokenCount) !== null && _a !== void 0 ? _a : 0, (_b = usage.candidatesTokenCount) !== null && _b !== void 0 ? _b : 0);
             if (usage.promptTokenCount != null) {
                 inputTokens = usage.promptTokenCount;
             }
+            if (usage.candidatesTokenCount != null) {
+                outputTokens = usage.candidatesTokenCount;
+            }
         }
         const candidates = response === null || response === void 0 ? void 0 : response.candidates;
         const firstCandidate = candidates === null || candidates === void 0 ? void 0 : candidates[0];
@@ -211,7 +252,13 @@ export class GeminiTransport {
                 toolCalls,
             }
             : { role: 'assistant', content: textParts.join('') };
-        return inputTokens != null ? Object.assign(Object.assign({}, base), { inputTokens }) : base;
+        if (inputTokens != null)
+            base.inputTokens = inputTokens;
+        if (outputTokens != null)
+            base.outputTokens = outputTokens;
+        if (cost != null)
+            base.cost = cost;
+        return base;
     }
     buildEndpoint(body) {
         if (this.apiKey) {

package/dist/esm/transports/server-openai-transport.js

@@ -2,6 +2,17 @@ import { __awaiter } from "tslib";
 const AI_SERVER_PATH = '/gwf/ai-service/chat-completions';
 const DEFAULT_MODEL = 'gpt-4o-mini';
 const DEFAULT_TIMEOUT = 30000;
+/**
+ * Maximum input context window (tokens) per known OpenAI model.
+ * OpenAI's model identifier is a free-form string, so this is a best-effort
+ * lookup — unknown models return undefined and the context indicator hides.
+ * Source: https://platform.openai.com/docs/models
+ */
+const OPENAI_CONTEXT_LIMITS = {
+    'gpt-4o': 128000,
+    'gpt-4o-mini': 128000,
+    'gpt-4-turbo': 128000,
+};
 /**
  * Server-proxy transport for OpenAI. Calls the standard server endpoint.
  * API key stays on the server; client never sees it.
@@ -15,7 +26,11 @@ export class ServerOpenAITransport {
         this.timeout = (_b = config.timeout) !== null && _b !== void 0 ? _b : DEFAULT_TIMEOUT;
     }
     getConfig() {
-        return { provider: 'openai', model: this.model };
+        return {
+            provider: 'openai',
+            model: this.model,
+            contextLimit: OPENAI_CONTEXT_LIMITS[this.model],
+        };
     }
     sendStructuredPrompt(options) {
         return __awaiter(this, void 0, void 0, function* () {

package/dist/esm/types/config.types.js

@@ -4,3 +4,9 @@ export const SUPPORTED_GEMINI_MODEL_IDS = [
     'gemini-2.5-flash',
     'gemini-2.5-flash-lite',
 ];
+/** @beta */
+export const SUPPORTED_ANTHROPIC_MODEL_IDS = [
+    'claude-opus-4-7',
+    'claude-sonnet-4-6',
+    'claude-haiku-4-5-20251001',
+];