dominds 0.1.0

package/dist/llm/gen/codex.js

@@ -0,0 +1,375 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodexGen = void 0;
+const log_1 = require("../../log");
+const text_1 = require("../../shared/i18n/text");
+const runtime_language_1 = require("../../shared/runtime-language");
+const log = (0, log_1.createLogger)('llm/codex');
+const codexFallbackInstructions = 'You are Codex CLI.';
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function tryExtractApiReturnedModel(value) {
+    // NOTE: This payload is derived from an external API / transport layer.
+    // Some upstream variants include `model`, but the exported TS types may not.
+    // A runtime check is unavoidable here.
+    if (!isRecord(value))
+        return undefined;
+    if (!('model' in value))
+        return undefined;
+    const model = value.model;
+    if (typeof model !== 'string')
+        return undefined;
+    const trimmed = model.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+async function resolveCodexInstructions(model, systemPrompt, loadPrompt) {
+    const basePrompt = await loadPrompt(model);
+    const trimmedSystemPrompt = systemPrompt.trim();
+    if (!basePrompt) {
+        return {
+            instructions: trimmedSystemPrompt.length > 0 ? systemPrompt : codexFallbackInstructions,
+            assistantPrelude: null,
+        };
+    }
+    return {
+        instructions: basePrompt,
+        assistantPrelude: trimmedSystemPrompt.length > 0 ? trimmedSystemPrompt : null,
+    };
+}
+function funcToolToCodex(funcTool) {
+    // MCP schemas are passed through to providers. Codex tool schema types are narrower; runtime
+    // validation is handled by provider rejection + the driver stop policy.
+    const parameters = funcTool.parameters;
+    const description = (0, text_1.getTextForLanguage)({ i18n: funcTool.descriptionI18n, fallback: funcTool.description }, (0, runtime_language_1.getWorkLanguage)());
+    return {
+        type: 'function',
+        name: funcTool.name,
+        description,
+        strict: false,
+        parameters,
+    };
+}
+function messageItem(role, text) {
+    const contentType = role === 'assistant' ? 'output_text' : 'input_text';
+    return {
+        type: 'message',
+        role,
+        content: [
+            {
+                type: contentType,
+                text,
+            },
+        ],
+    };
+}
+function chatMessageToCodexItems(msg) {
+    switch (msg.type) {
+        case 'environment_msg':
+        case 'prompting_msg':
+            return [messageItem('user', msg.content)];
+        case 'transient_guide_msg':
+        case 'saying_msg':
+        case 'thinking_msg':
+            return [messageItem('assistant', msg.content)];
+        case 'call_result_msg':
+            return [messageItem('user', msg.content)];
+        case 'func_call_msg':
+            return [
+                {
+                    type: 'function_call',
+                    name: msg.name,
+                    arguments: msg.arguments,
+                    call_id: msg.id,
+                },
+            ];
+        case 'func_result_msg':
+            return [
+                {
+                    type: 'function_call_output',
+                    call_id: msg.id,
+                    output: msg.content,
+                },
+            ];
+        default: {
+            const _exhaustive = msg;
+            throw new Error(`Unsupported chat message: ${_exhaustive}`);
+        }
+    }
+}
+function buildCodexRequest(agent, instructions, assistantPrelude, funcTools, context) {
+    if (!agent.model) {
+        throw new Error(`Internal error: Model is undefined for agent '${agent.id}'`);
+    }
+    const input = [];
+    if (assistantPrelude) {
+        // Codex backend rejects system messages; pass extra instructions as prior assistant context.
+        input.push(messageItem('assistant', assistantPrelude));
+    }
+    for (const msg of context) {
+        const items = chatMessageToCodexItems(msg);
+        for (const item of items) {
+            input.push(item);
+        }
+    }
+    const codexParams = agent.model_params?.codex ?? agent.model_params?.openai;
+    let reasoning = null;
+    let text;
+    const parallelToolCalls = codexParams?.parallel_tool_calls ?? true;
+    if (codexParams && codexParams.reasoning_effort) {
+        reasoning = {
+            effort: codexParams.reasoning_effort,
+        };
+    }
+    if (codexParams && codexParams.verbosity) {
+        text = {
+            verbosity: codexParams.verbosity,
+        };
+    }
+    return {
+        model: agent.model,
+        instructions,
+        input,
+        tools: funcTools.map(funcToolToCodex),
+        tool_choice: 'auto',
+        parallel_tool_calls: parallelToolCalls,
+        reasoning,
+        store: false,
+        stream: true,
+        include: [],
+        text,
+    };
+}
+class CodexGen {
+    get apiType() {
+        return 'codex';
+    }
+    async genToReceiver(providerConfig, agent, systemPrompt, funcTools, context, receiver, _genseq, abortSignal) {
+        const codexHomeValue = process.env[providerConfig.apiKeyEnvVar] || '~/.codex';
+        const codexHome = codexHomeValue.startsWith('~')
+            ? process.env['HOME'] + codexHomeValue.substring(1)
+            : codexHomeValue;
+        // NOTE: `@longrun-ai/codex-auth` is an ESM package (`"type": "module"`). The Dominds backend is
+        // compiled as CommonJS, so Node.js requires a dynamic `import()` for runtime access here.
+        const codexAuth = await Promise.resolve().then(() => __importStar(require('@longrun-ai/codex-auth')));
+        const manager = new codexAuth.AuthManager({ codexHome });
+        const client = await codexAuth.createChatGptClientFromManager(manager, {
+            baseUrl: providerConfig.baseUrl,
+        });
+        if (!agent.model) {
+            throw new Error(`Internal error: Model is undefined for agent '${agent.id}'`);
+        }
+        const resolvedInstructions = await resolveCodexInstructions(agent.model, systemPrompt, codexAuth.loadCodexPrompt);
+        const payload = buildCodexRequest(agent, resolvedInstructions.instructions, resolvedInstructions.assistantPrelude, funcTools, context);
+        let sayingStarted = false;
+        let thinkingStarted = false;
+        let sawOutputText = false;
+        let usage = { kind: 'unavailable' };
+        let returnedModel;
+        const eventReceiver = {
+            onEvent: async (event) => {
+                switch (event.type) {
+                    case 'response.created':
+                    case 'response.in_progress':
+                        if (returnedModel === undefined) {
+                            returnedModel = tryExtractApiReturnedModel(event.response);
+                        }
+                        return;
+                    case 'response.failed': {
+                        const error = event.response.error;
+                        const message = error && typeof error.message === 'string' && error.message.length > 0
+                            ? error.message
+                            : 'Codex response failed.';
+                        throw new Error(message);
+                    }
+                    case 'response.output_text.delta': {
+                        const delta = event.delta;
+                        if (delta.length > 0) {
+                            if (!sayingStarted) {
+                                sayingStarted = true;
+                                await receiver.sayingStart();
+                            }
+                            await receiver.sayingChunk(delta);
+                            sawOutputText = true;
+                        }
+                        return;
+                    }
+                    case 'response.output_text.done': {
+                        if (!sawOutputText && event.text.length > 0) {
+                            if (!sayingStarted) {
+                                sayingStarted = true;
+                                await receiver.sayingStart();
+                            }
+                            await receiver.sayingChunk(event.text);
+                            sawOutputText = true;
+                        }
+                        if (sayingStarted) {
+                            await receiver.sayingFinish();
+                            sayingStarted = false;
+                        }
+                        return;
+                    }
+                    case 'response.content_part.added':
+                    case 'response.content_part.done':
+                        return;
+                    case 'response.reasoning_summary_text.delta':
+                    case 'response.reasoning_text.delta': {
+                        const delta = event.delta;
+                        if (delta.length > 0) {
+                            if (!thinkingStarted) {
+                                thinkingStarted = true;
+                                await receiver.thinkingStart();
+                            }
+                            await receiver.thinkingChunk(delta);
+                        }
+                        return;
+                    }
+                    case 'response.reasoning_summary_part.added': {
+                        if (!thinkingStarted) {
+                            thinkingStarted = true;
+                            await receiver.thinkingStart();
+                        }
+                        return;
+                    }
+                    case 'response.output_item.added':
+                        return;
+                    case 'response.output_item.done': {
+                        switch (event.item.type) {
+                            case 'function_call':
+                                await receiver.funcCall(event.item.call_id, event.item.name, event.item.arguments);
+                                return;
+                            case 'message': {
+                                if (!sawOutputText) {
+                                    let text = '';
+                                    for (const part of event.item.content) {
+                                        switch (part.type) {
+                                            case 'output_text':
+                                                text += part.text;
+                                                break;
+                                            case 'input_text':
+                                            case 'input_image':
+                                                break;
+                                            default: {
+                                                const _exhaustive = part;
+                                                return _exhaustive;
+                                            }
+                                        }
+                                    }
+                                    if (text.length > 0) {
+                                        if (!sayingStarted) {
+                                            sayingStarted = true;
+                                            await receiver.sayingStart();
+                                        }
+                                        await receiver.sayingChunk(text);
+                                        await receiver.sayingFinish();
+                                        sayingStarted = false;
+                                        sawOutputText = true;
+                                    }
+                                }
+                                return;
+                            }
+                            case 'reasoning':
+                            case 'local_shell_call':
+                            case 'function_call_output':
+                            case 'custom_tool_call':
+                            case 'custom_tool_call_output':
+                            case 'web_search_call':
+                            case 'ghost_snapshot':
+                            case 'compaction':
+                            case 'compaction_summary':
+                                return;
+                            default: {
+                                const _exhaustive = event.item;
+                                return _exhaustive;
+                            }
+                        }
+                    }
+                    case 'response.completed': {
+                        if (sayingStarted) {
+                            await receiver.sayingFinish();
+                            sayingStarted = false;
+                        }
+                        if (thinkingStarted) {
+                            await receiver.thinkingFinish();
+                            thinkingStarted = false;
+                        }
+                        if (returnedModel === undefined) {
+                            returnedModel = tryExtractApiReturnedModel(event.response);
+                        }
+                        const responseUsage = event.response.usage;
+                        if (responseUsage &&
+                            typeof responseUsage.input_tokens === 'number' &&
+                            typeof responseUsage.output_tokens === 'number') {
+                            usage = {
+                                kind: 'available',
+                                promptTokens: responseUsage.input_tokens,
+                                completionTokens: responseUsage.output_tokens,
+                                totalTokens: typeof responseUsage.total_tokens === 'number'
+                                    ? responseUsage.total_tokens
+                                    : responseUsage.input_tokens + responseUsage.output_tokens,
+                            };
+                        }
+                        return;
+                    }
+                    default: {
+                        const _exhaustive = event;
+                        return _exhaustive;
+                    }
+                }
+            },
+        };
+        try {
+            await client.trigger(payload, eventReceiver, abortSignal ? { signal: abortSignal } : {});
+        }
+        catch (error) {
+            log.warn('CODEX streaming error', error);
+            throw error;
+        }
+        finally {
+            if (sayingStarted) {
+                await receiver.sayingFinish();
+            }
+            if (thinkingStarted) {
+                await receiver.thinkingFinish();
+            }
+        }
+        return { usage, llmGenModel: returnedModel };
+    }
+    async genMoreMessages(_providerConfig, _agent, _systemPrompt, _funcTools, _context, _genseq) {
+        throw new Error('Codex generator only supports streaming mode.');
+    }
+}
+exports.CodexGen = CodexGen;