@genesislcap/foundation-ai 14.407.0-workspaces.4 → 14.408.0

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

@@ -0,0 +1,249 @@
+import { __awaiter } from "tslib";
+const GEMINI_DIRECT_URL = (model) => `https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent`;
+const DEFAULT_MODEL = 'gemini-2.0-flash';
+const DEFAULT_TIMEOUT = 180000; // 3 minutes
+/**
+ * Thrown when Gemini returns a `MALFORMED_FUNCTION_CALL` finish reason,
+ * typically because the model tried to batch multiple tool calls using
+ * Python-style syntax instead of the proper API format.
+ *
+ * @beta
+ */
+export class MalformedFunctionCallError extends Error {
+    constructor(finishMessage) {
+        super('Gemini returned MALFORMED_FUNCTION_CALL');
+        this.finishMessage = finishMessage;
+        this.name = 'MalformedFunctionCallError';
+    }
+}
+/**
+ * Transport for Gemini. Calls the Gemini REST API directly when `apiKey` is
+ * provided, otherwise falls back to a server-proxy endpoint (if `serverEndpoint`
+ * is configured).
+ *
+ * Implements `AITransport` (structured prompt) and `ChatTransport` (multi-turn chat).
+ *
+ * @beta
+ */
+export class GeminiTransport {
+    constructor(config = {}) {
+        var _a, _b;
+        this.model = (_a = config.model) !== null && _a !== void 0 ? _a : DEFAULT_MODEL;
+        this.timeout = (_b = config.timeout) !== null && _b !== void 0 ? _b : DEFAULT_TIMEOUT;
+        this.apiKey = config.apiKey;
+        this.serverEndpoint = config.serverEndpoint;
+    }
+    getConfig() {
+        return { provider: 'gemini', model: this.model };
+    }
+    // ── AITransport (structured prompt) ────────────────────────────────────
+    sendStructuredPrompt(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const { systemPrompt, userPrompt, responseSchema } = options;
+            const contents = [];
+            if (systemPrompt) {
+                contents.push({ role: 'user', parts: [{ text: systemPrompt }] });
+                contents.push({ role: 'model', parts: [{ text: 'Understood.' }] });
+            }
+            contents.push({ role: 'user', parts: [{ text: userPrompt }] });
+            const response = yield this.post({ model: this.model, contents, responseSchema });
+            return (_a = response === null || response === void 0 ? void 0 : response.content) !== null && _a !== void 0 ? _a : '';
+        });
+    }
+    // ── ChatTransport (multi-turn chat) ────────────────────────────────────
+    sendChatMessage(history, userMessage, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const contents = this.toGeminiContents(history, userMessage, options === null || options === void 0 ? void 0 : options.attachments);
+            const tools = ((_a = options === null || options === void 0 ? void 0 : options.tools) === null || _a === void 0 ? void 0 : _a.length)
+                ? [
+                    {
+                        functionDeclarations: options.tools.map((t) => ({
+                            name: t.name,
+                            description: t.description,
+                            parameters: t.parameters,
+                        })),
+                    },
+                ]
+                : undefined;
+            const systemInstruction = (options === null || options === void 0 ? void 0 : options.systemPrompt)
+                ? { role: 'system', parts: [{ text: options.systemPrompt }] }
+                : undefined;
+            const response = yield this.post({ model: this.model, contents, tools, systemInstruction }, options === null || options === void 0 ? void 0 : options.signal);
+            return this.fromGeminiResponse(response);
+        });
+    }
+    logTokenUsage(promptTokens, candidateTokens) {
+        const promptCost = (promptTokens / GeminiTransport.TOKENS_PER_MILLION) * GeminiTransport.PROMPT_COST_PER_MILLION;
+        const candidateCost = (candidateTokens / GeminiTransport.TOKENS_PER_MILLION) *
+            GeminiTransport.CANDIDATE_COST_PER_MILLION;
+        const totalCost = promptCost + candidateCost;
+        console.log('--- Gemini Token Usage ---');
+        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('--------------------------');
+    }
+    toGeminiContents(history, userMessage, attachments) {
+        var _a, _b;
+        const contents = [];
+        for (const msg of history) {
+            if (msg.role === 'system' || msg.thinking)
+                continue;
+            const role = msg.role === 'user' ? 'user' : 'model';
+            if (msg.toolResult) {
+                contents.push({
+                    role: 'user',
+                    parts: [
+                        {
+                            functionResponse: {
+                                name: msg.toolResult.toolCallId,
+                                response: { content: msg.toolResult.content },
+                            },
+                        },
+                    ],
+                });
+            }
+            else if ((_a = msg.toolCalls) === null || _a === void 0 ? void 0 : _a.length) {
+                contents.push({
+                    role: 'model',
+                    parts: msg.toolCalls.map((tc) => ({
+                        functionCall: { name: tc.name, args: tc.args },
+                    })),
+                });
+            }
+            else if (role === 'user' && ((_b = msg.attachments) === null || _b === void 0 ? void 0 : _b.length)) {
+                const msgAttachmentParts = msg.attachments.map((att) => ({
+                    text: `[File: ${att.name}]\n${att.content}`,
+                }));
+                contents.push({ role: 'user', parts: [{ text: msg.content }, ...msgAttachmentParts] });
+            }
+            else {
+                contents.push({ role, parts: [{ text: msg.content }] });
+            }
+        }
+        const attachmentParts = (attachments !== null && attachments !== void 0 ? attachments : []).map((att) => ({
+            text: `[File: ${att.name}]\n${att.content}`,
+        }));
+        if (userMessage || attachmentParts.length) {
+            contents.push({ role: 'user', parts: [{ text: userMessage }, ...attachmentParts] });
+        }
+        return contents;
+    }
+    fromGeminiResponse(response) {
+        var _a, _b, _c, _d, _e;
+        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);
+        }
+        const candidates = response === null || response === void 0 ? void 0 : response.candidates;
+        const firstCandidate = candidates === null || candidates === void 0 ? void 0 : candidates[0];
+        if ((firstCandidate === null || firstCandidate === void 0 ? void 0 : firstCandidate.finishReason) === 'MALFORMED_FUNCTION_CALL') {
+            throw new MalformedFunctionCallError(firstCandidate.finishMessage);
+        }
+        const parts = (_d = (_c = firstCandidate === null || firstCandidate === void 0 ? void 0 : firstCandidate.content) === null || _c === void 0 ? void 0 : _c.parts) !== null && _d !== void 0 ? _d : [];
+        const toolCalls = [];
+        const thoughtParts = [];
+        const textParts = [];
+        for (const part of parts) {
+            if (part.functionCall) {
+                toolCalls.push({
+                    id: part.functionCall.name,
+                    name: part.functionCall.name,
+                    args: (_e = part.functionCall.args) !== null && _e !== void 0 ? _e : {},
+                });
+            }
+            else if (part.thought && part.text) {
+                thoughtParts.push(part.text);
+            }
+            else if (part.text) {
+                textParts.push(part.text);
+            }
+        }
+        // For tool-call responses, surface thought parts as `content` so the UI can
+        // render them as a collapsible thinking block. Fall back to text narration
+        // (textParts) for models that don't emit native thought parts (e.g. gemini-2.0-flash)
+        // but do narrate alongside tool calls when prompted to do so.
+        // For final answers, surface only the response text.
+        return toolCalls.length > 0
+            ? { role: 'assistant', content: thoughtParts.join('') || textParts.join(''), toolCalls }
+            : { role: 'assistant', content: textParts.join('') };
+    }
+    buildEndpoint(body) {
+        if (this.apiKey) {
+            return {
+                url: `${GEMINI_DIRECT_URL(this.model)}?key=${this.apiKey}`,
+                payload: this.toDirectPayload(body),
+                credentials: 'omit',
+            };
+        }
+        if (this.serverEndpoint) {
+            return {
+                url: this.serverEndpoint,
+                payload: body,
+                credentials: 'include',
+            };
+        }
+        throw new Error('GeminiTransport: no API key or server endpoint configured. ' +
+            'Set GEMINI_API_KEY in your .env or pass apiKey/serverEndpoint in GeminiAIConfig.');
+    }
+    post(body, signal) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { url, payload, credentials } = this.buildEndpoint(body);
+            // Sequential retries are intentional — each attempt depends on the previous response.
+            /* eslint-disable no-await-in-loop */
+            for (let attempt = 0; attempt <= GeminiTransport.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: { 'Content-Type': 'application/json' },
+                        body: JSON.stringify(payload),
+                        signal: signal !== null && signal !== void 0 ? signal : controller.signal,
+                        credentials,
+                    });
+                }
+                catch (e) {
+                    clearTimeout(timeoutId);
+                    throw e;
+                }
+                clearTimeout(timeoutId);
+                if (response.status === GeminiTransport.RATE_LIMIT_STATUS &&
+                    attempt < GeminiTransport.MAX_RETRIES) {
+                    // Exponential backoff: 1s, 2s, 4s, 8s, 16s
+                    yield new Promise((resolve) => {
+                        setTimeout(resolve, GeminiTransport.BACKOFF_BASE_MS * (1 << attempt));
+                    });
+                    continue;
+                }
+                if (!response.ok) {
+                    const err = yield response.text();
+                    throw new Error(`Gemini request error ${response.status}: ${err}`);
+                }
+                return (yield response.json());
+            }
+            /* eslint-enable no-await-in-loop */
+            throw new Error('Gemini request failed: max retries exceeded');
+        });
+    }
+    toDirectPayload(body) {
+        const payload = Object.assign({}, body);
+        delete payload.model;
+        if (payload.responseSchema) {
+            payload.generationConfig = Object.assign(Object.assign({}, payload.generationConfig), { responseMimeType: 'application/json', responseSchema: payload.responseSchema });
+            delete payload.responseSchema;
+        }
+        return payload;
+    }
+}
+// ── Private helpers ────────────────────────────────────────────────────
+GeminiTransport.TOKENS_PER_MILLION = 1000000;
+GeminiTransport.PROMPT_COST_PER_MILLION = 0.1;
+GeminiTransport.CANDIDATE_COST_PER_MILLION = 0.4;
+GeminiTransport.COST_DECIMAL_PLACES = 6;
+GeminiTransport.MAX_RETRIES = 5;
+GeminiTransport.RATE_LIMIT_STATUS = 429;
+GeminiTransport.BACKOFF_BASE_MS = 1000;

package/dist/esm/types/chat-transport.types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/types/chat.types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/types/index.js

@@ -1,3 +1,5 @@
+export * from './chat-transport.types';
+export * from './chat.types';
 export * from './config.types';
 export * from './criteria-types';
 export * from './status.types';

package/dist/esm/utils/speech-to-text.js

@@ -4,10 +4,21 @@
  *
  * @beta
  */
+/**
+ * Returns true if the Web Speech API is available in the current environment.
+ *
+ * @beta
+ */
 export function isSpeechRecognitionAvailable() {
     return (typeof window !== 'undefined' &&
         ('SpeechRecognition' in window || 'webkitSpeechRecognition' in window));
 }
+/**
+ * Starts continuous speech recognition, calling `onResult` with each transcript update.
+ * Returns a stop function, or null if speech recognition is unavailable.
+ *
+ * @beta
+ */
 export function startSpeechRecognition(onResult, onError) {
     if (!isSpeechRecognitionAvailable()) {
         return null;