@messenger-agent/codex-agent 0.24.0-alpha.2 → 0.24.0-alpha.4

package/dist/codex.js

@@ -1,461 +1,3 @@
-import { mkdirSync, existsSync } from "node:fs";
-import { appServerClient } from "./app-server-client.js";
-import { dynamicToolSpecs } from "./dynamic-tools.js";
-import { loadAllSessions, persistSession } from "./db.js";
-import { appConfig } from "./config.js";
-import { logger } from "@messenger-agent/shared/logger";
-import { resolveAgentWorkdir } from "@messenger-agent/shared/agent-workspaces";
-import { codexPlatformInstructions } from "./platform-instructions.js";
-export class WorkdirNotFoundError extends Error {
-    path;
-    constructor(path) {
-        super(`Workdir not found: ${path}`);
-        this.path = path;
-    }
-}
-export class CodexThread {
-    id;
-    model;
-    workingDirectory;
-    constructor(id, model, workingDirectory) {
-        this.id = id;
-        this.model = model;
-        this.workingDirectory = workingDirectory;
-    }
-    async run(prompt, options) {
-        const streamed = await this.runStreamed(prompt, options);
-        const items = new Map();
-        const completedItems = new Set();
-        let usage = null;
-        for await (const event of streamed.events) {
-            if (event.type === "item.started") {
-                if (!completedItems.has(event.item.id)) {
-                    items.set(event.item.id, event.item);
-                }
-            }
-            else if (event.type === "item.completed") {
-                completedItems.add(event.item.id);
-                items.set(event.item.id, event.item);
-            }
-            else if (event.type === "thread.tokenUsage.updated") {
-                usage = event.usage;
-            }
-            else if (event.type === "turn.failed") {
-                throw new Error(event.error.message);
-            }
-        }
-        const itemList = Array.from(items.values());
-        const finalResponse = itemList
-            .filter((item) => item.type === "agentMessage")
-            .map((item) => item.text)
-            .join("\n");
-        return { items: itemList, finalResponse: finalResponse || undefined, usage };
-    }
-    async runStreamed(_prompt, options) {
-        const response = await appServerClient.request("turn/start", this.turnStartParams(_prompt, options));
-        const turnId = response.turn.id;
-        return { turnId, events: this.eventsForTurn(turnId, response.turn, options?.signal) };
-    }
-    async steerStreamed(prompt, expectedTurnId, options) {
-        const params = {
-            threadId: this.id,
-            input: [{ type: "text", text: prompt }],
-            expectedTurnId,
-        };
-        const response = await appServerClient.request("turn/steer", params);
-        return {
-            turnId: response.turnId,
-            events: this.eventsForTurn(response.turnId, undefined, options?.signal, undefined, true),
-        };
-    }
-    async continueWithUserInput(itemId, response, options) {
-        const turnId = appServerClient.pendingUserInputTurnId(this.id, itemId);
-        if (!turnId) {
-            await this.interruptStaleTurn(options?.sourceTurnId);
-            return this.runStreamed(userInputResponsePrompt(itemId, response), options);
-        }
-        return {
-            turnId,
-            events: this.eventsForTurn(turnId, undefined, options?.signal, async () => {
-                const accepted = await appServerClient.respondToUserInput(this.id, itemId, response);
-                if (!accepted) {
-                    throw new Error(`No pending user input request found for item: ${itemId}`);
-                }
-            }),
-        };
-    }
-    async submitPendingUserInput(itemId, response) {
-        const turnId = appServerClient.pendingUserInputTurnId(this.id, itemId);
-        if (!turnId)
-            return undefined;
-        const accepted = await appServerClient.respondToUserInput(this.id, itemId, response);
-        if (!accepted)
-            return undefined;
-        return turnId;
-    }
-    async interrupt(turnId) {
-        await appServerClient.request("turn/interrupt", { threadId: this.id, turnId });
-    }
-    async interruptPendingUserInput(turnId, itemId) {
-        await this.interrupt(turnId);
-        appServerClient.discardPendingUserInput(this.id, itemId);
-    }
-    async interruptStaleTurn(turnId) {
-        if (!turnId)
-            return;
-        const response = await appServerClient.request("thread/read", {
-            threadId: this.id,
-            includeTurns: true,
-        });
-        const turn = response.thread.turns?.find((candidate) => candidate.id === turnId);
-        if (turn?.status === "inProgress") {
-            await this.interrupt(turnId);
-        }
-    }
-    turnStartParams(prompt, options) {
-        return {
-            threadId: this.id,
-            input: [{ type: "text", text: prompt, text_elements: [] }],
-            cwd: this.workingDirectory,
-            approvalPolicy: "never",
-            model: this.model,
-            ...(options?.collaborationMode ? { collaborationMode: options.collaborationMode } : null),
-        };
-    }
-    async *eventsForTurn(turnId, initialTurn, signal, beforeWait, emitStarted = false) {
-        const queue = [
-            ...(initialTurn || emitStarted
-                ? [
-                    { type: "thread.started", thread_id: this.id },
-                    { type: "turn.started", turn_id: turnId },
-                ]
-                : []),
-            ...(initialTurn ? eventsFromInitialTurn(initialTurn) : []),
-        ];
-        let done = initialTurn?.status === "completed" || initialTurn?.status === "failed" || initialTurn?.status === "interrupted";
-        let failure;
-        let stopped = false;
-        let wake = () => { };
-        const onNotification = ({ method, params }) => {
-            if (stopped)
-                return;
-            const event = notificationToEvent(method, params, this.id, turnId);
-            if (!event)
-                return;
-            queue.push(event);
-            if (event.type === "turn.completed" || event.type === "turn.failed") {
-                done = true;
-            }
-            wake();
-        };
-        const onExit = (err) => {
-            failure = err;
-            done = true;
-            wake();
-        };
-        const onAbort = () => {
-            stopped = true;
-            queue.length = 0;
-            done = true;
-            wake();
-        };
-        appServerClient.on("notification", onNotification);
-        appServerClient.on("exit", onExit);
-        signal?.addEventListener("abort", onAbort, { once: true });
-        if (signal?.aborted)
-            onAbort();
-        try {
-            await beforeWait?.();
-            while (!done || queue.length > 0) {
-                while (queue.length > 0) {
-                    yield queue.shift();
-                }
-                if (done)
-                    break;
-                await new Promise((resolve) => {
-                    const timer = setTimeout(() => {
-                        wake = () => { };
-                        resolve();
-                    }, 50);
-                    wake = () => {
-                        clearTimeout(timer);
-                        wake = () => { };
-                        resolve();
-                    };
-                });
-            }
-            if (failure) {
-                yield { type: "error", message: failure.message };
-            }
-        }
-        finally {
-            appServerClient.off("notification", onNotification);
-            appServerClient.off("exit", onExit);
-            signal?.removeEventListener("abort", onAbort);
-        }
-    }
-}
-function userInputResponsePrompt(itemId, response) {
-    return [
-        `The user answered a previous request_user_input prompt (${itemId}), but the original pending tool request is no longer active.`,
-        "Continue the task using this answer:",
-        JSON.stringify(response, null, 2),
-    ].join("\n");
-}
-class SessionManager {
-    sessions = new Map();
-    constructor() {
-        for (const row of loadAllSessions()) {
-            this.sessions.set(row.sessionId, {
-                workdir: row.workdir,
-                botName: row.botName ?? "main",
-                llmProxyBinding: row.llmProxyBinding,
-            });
-        }
-        logger.info(`SessionManager: loaded ${this.sessions.size} persisted sessions`);
-    }
-    async getOrCreate(sessionId, botName, requestedWorkdir, requestedWorkspaceId, model, sandboxMode, llmProxyBinding) {
-        const targetWorkdir = this.resolveWorkdir(requestedWorkdir, requestedWorkspaceId);
-        if (sessionId) {
-            const stored = this.sessions.get(sessionId);
-            if (stored && stored.workdir === targetWorkdir) {
-                const effectiveLlmProxyBinding = stored.llmProxyBinding ?? llmProxyBinding;
-                const response = await appServerClient.request("thread/resume", this.threadResumeParams(sessionId, model, targetWorkdir, sandboxMode, effectiveLlmProxyBinding));
-                if (!stored.llmProxyBinding && effectiveLlmProxyBinding) {
-                    const updated = { ...stored, llmProxyBinding: effectiveLlmProxyBinding };
-                    this.sessions.set(sessionId, updated);
-                    persistSession({
-                        sessionId,
-                        botName: updated.botName,
-                        workdir: updated.workdir,
-                        createdAt: Date.now(),
-                        llmProxyBinding: effectiveLlmProxyBinding,
-                    });
-                }
-                return { thread: new CodexThread(response.thread.id, model, targetWorkdir), sessionId, isNewSession: false };
-            }
-        }
-        if (requestedWorkdir && !existsSync(targetWorkdir)) {
-            throw new WorkdirNotFoundError(targetWorkdir);
-        }
-        mkdirSync(targetWorkdir, { recursive: true });
-        const response = await appServerClient.request("thread/start", this.threadStartParams(model, targetWorkdir, sandboxMode, llmProxyBinding));
-        return {
-            thread: new CodexThread(response.thread.id, model, targetWorkdir),
-            sessionId: undefined,
-            isNewSession: true,
-        };
-    }
-    async fork(source, botName, requestedWorkdir, requestedWorkspaceId, model, sandboxMode, llmProxyBinding) {
-        const targetWorkdir = this.resolveWorkdir(requestedWorkdir, requestedWorkspaceId);
-        if (requestedWorkdir && !existsSync(targetWorkdir)) {
-            throw new WorkdirNotFoundError(targetWorkdir);
-        }
-        mkdirSync(targetWorkdir, { recursive: true });
-        const forkResponse = await appServerClient.request("thread/fork", this.threadForkParams(source.threadId, source.turnId, model, targetWorkdir, sandboxMode, llmProxyBinding));
-        const threadId = forkResponse.thread.id;
-        this.persist(threadId, botName, requestedWorkdir, requestedWorkspaceId, llmProxyBinding);
-        return {
-            thread: new CodexThread(threadId, model, targetWorkdir),
-            sessionId: threadId,
-            isNewSession: false,
-        };
-    }
-    persist(sessionId, botName, workdir, workspaceId, llmProxyBinding) {
-        const resolvedBotName = botName ?? "main";
-        const resolvedWorkdir = this.resolveWorkdir(workdir, workspaceId);
-        this.sessions.set(sessionId, { botName: resolvedBotName, workdir: resolvedWorkdir, llmProxyBinding });
-        persistSession({
-            sessionId,
-            botName: resolvedBotName,
-            workdir: resolvedWorkdir,
-            createdAt: Date.now(),
-            llmProxyBinding,
-        });
-    }
-    bindingFor(sessionId) {
-        return sessionId ? this.sessions.get(sessionId)?.llmProxyBinding : undefined;
-    }
-    workdirFor(sessionId) {
-        return sessionId ? this.sessions.get(sessionId)?.workdir : undefined;
-    }
-    hasSession(sessionId) {
-        return !!sessionId && this.sessions.has(sessionId);
-    }
-    resolveWorkdir(subpath, workspaceId) {
-        return resolveAgentWorkdir(appConfig, workspaceId, subpath);
-    }
-    threadStartParams(model, cwd, sandbox, llmProxyBinding) {
-        return {
-            model,
-            modelProvider: appConfig.codex.baseUrl ? "custom" : null,
-            cwd,
-            approvalPolicy: "never",
-            sandbox,
-            config: this.codexConfig(llmProxyBinding),
-            developerInstructions: codexPlatformInstructions,
-            dynamicTools: dynamicToolSpecs(),
-            experimentalRawEvents: false,
-            persistExtendedHistory: false,
-        };
-    }
-    threadResumeParams(threadId, model, cwd, sandbox, llmProxyBinding) {
-        return {
-            threadId,
-            model,
-            modelProvider: appConfig.codex.baseUrl ? "custom" : null,
-            cwd,
-            approvalPolicy: "never",
-            sandbox,
-            config: this.codexConfig(llmProxyBinding),
-            developerInstructions: codexPlatformInstructions,
-            excludeTurns: true,
-            persistExtendedHistory: false,
-        };
-    }
-    threadForkParams(threadId, lastTurnId, model, cwd, sandbox, llmProxyBinding) {
-        return {
-            threadId,
-            lastTurnId,
-            model,
-            modelProvider: appConfig.codex.baseUrl ? "custom" : null,
-            cwd,
-            approvalPolicy: "never",
-            sandbox,
-            config: this.codexConfig(llmProxyBinding),
-            developerInstructions: codexPlatformInstructions,
-            ephemeral: false,
-            excludeTurns: true,
-        };
-    }
-    codexConfig(llmProxyBinding) {
-        return {
-            approval_policy: "never",
-            ...(appConfig.codex.baseUrl
-                ? {
-                    model_provider: "custom",
-                    model_reasoning_effort: "medium",
-                    disable_response_storage: true,
-                    model_providers: {
-                        custom: {
-                            name: "custom",
-                            base_url: appConfig.codex.baseUrl,
-                            wire_api: "responses",
-                            ...(appConfig.codex.apiKey ? { env_key: "OPENAI_API_KEY" } : null),
-                            ...(llmProxyBinding ? { http_headers: { "X-Elevo-LLM-Binding": llmProxyBinding } } : null),
-                        },
-                    },
-                    "features.default_mode_request_user_input": true,
-                }
-                : null),
-        };
-    }
-}
-if (appConfig.codex.apiKey && !process.env.OPENAI_API_KEY) {
-    process.env.OPENAI_API_KEY = appConfig.codex.apiKey;
-}
-function eventsFromInitialTurn(turn) {
-    const events = [];
-    for (const item of turn.items ?? []) {
-        events.push({ type: "item.completed", item });
-    }
-    if (turn.status === "completed") {
-        events.push({ type: "turn.completed" });
-    }
-    else if (turn.status === "failed") {
-        events.push({ type: "turn.failed", error: { message: turn.error?.message ?? "Codex turn failed" } });
-    }
-    return events;
-}
-function notificationToEvent(method, params, expectedThreadId, expectedTurnId) {
-    const record = params;
-    if (!record)
-        return undefined;
-    const threadId = record.threadId;
-    const turnId = record.turnId;
-    if (typeof threadId === "string" && threadId !== expectedThreadId)
-        return undefined;
-    if (typeof turnId === "string" && turnId !== expectedTurnId)
-        return undefined;
-    if (method === "item/started" && isThreadItem(record.item)) {
-        return { type: "item.started", item: record.item };
-    }
-    if (method === "item/completed" && isThreadItem(record.item)) {
-        return { type: "item.completed", item: record.item };
-    }
-    if (method === "item/agentMessage/delta") {
-        return deltaEvent(record, "agentMessage");
-    }
-    if (method === "item/reasoning/summaryTextDelta" || method === "item/reasoning/textDelta") {
-        return deltaEvent(record, "reasoning");
-    }
-    if (method === "item/plan/delta") {
-        return deltaEvent(record, "plan");
-    }
-    if (method === "item/tool/requestUserInput") {
-        return { type: "item.tool.requestUserInput", params: record };
-    }
-    if (method === "turn/diff/updated" && typeof record.diff === "string") {
-        return { type: "turn.diff.updated", diff: record.diff };
-    }
-    if (method === "thread/tokenUsage/updated") {
-        return { type: "thread.tokenUsage.updated", usage: usageFromTokenUsageUpdate(record) };
-    }
-    if (method === "turn/completed") {
-        const turn = record.turn;
-        if (turn?.status === "failed") {
-            return { type: "turn.failed", error: { message: turn.error?.message ?? "Codex turn failed" } };
-        }
-        return { type: "turn.completed" };
-    }
-    if (method === "error") {
-        console.error("Received error notification from app-server:", record);
-        return { type: "error", message: errorMessageFromRecord(record) };
-    }
-    return undefined;
-}
-function errorMessageFromRecord(record) {
-    const nestedError = record.error;
-    const message = nestedError && typeof nestedError === "object" && "message" in nestedError
-        ? nestedError.message
-        : undefined;
-    const details = record.additionalDetails;
-    const messageText = typeof message === "string" && message.trim() ? message : "Codex app-server error";
-    if (typeof details === "string" && details.trim()) {
-        return `${messageText}: ${details}`;
-    }
-    return messageText;
-}
-function deltaEvent(record, itemType) {
-    if (typeof record.itemId !== "string" || typeof record.delta !== "string")
-        return undefined;
-    return { type: "item.delta", item_id: record.itemId, item_type: itemType, delta: record.delta };
-}
-function usageFromTokenUsageUpdate(record) {
-    const tokenUsage = record.tokenUsage;
-    if (!tokenUsage || typeof tokenUsage !== "object")
-        return null;
-    const usage = tokenUsage;
-    const total = usage.total;
-    const last = usage.last;
-    if (!total || typeof total !== "object" || !last || typeof last !== "object")
-        return null;
-    const breakdown = (value) => {
-        const fields = value;
-        return {
-            input_tokens: typeof fields.inputTokens === "number" ? fields.inputTokens : undefined,
-            output_tokens: typeof fields.outputTokens === "number" ? fields.outputTokens : undefined,
-            total_tokens: typeof fields.totalTokens === "number" ? fields.totalTokens : undefined,
-        };
-    };
-    const modelContextWindow = usage.modelContextWindow;
-    return {
-        total: breakdown(total),
-        last: breakdown(last),
-        model_context_window: typeof modelContextWindow === "number" ? modelContextWindow : undefined,
-    };
-}
-function isThreadItem(item) {
-    return Boolean(item && typeof item === "object" && "type" in item && "id" in item);
-}
-export const sessionManager = new SessionManager();
+import{mkdirSync as b,existsSync as _}from"node:fs";import{appServerClient as l}from"./app-server-client.js";import{dynamicToolSpecs as S}from"./dynamic-tools.js";import{loadAllSessions as U,persistSession as I}from"./db.js";import{appConfig as f}from"./config.js";import{logger as E}from"@messenger-agent/shared/logger";import{resolveAgentWorkdir as N}from"@messenger-agent/shared/agent-workspaces";import{codexPlatformInstructions as v}from"./platform-instructions.js";class P extends Error{path;constructor(e){super(`Workdir not found: ${e}`),this.path=e}}class k{id;model;workingDirectory;constructor(e,r,n){this.id=e,this.model=r,this.workingDirectory=n}async run(e,r){const n=await this.runStreamed(e,r),t=new Map,i=new Set;let a=null;for await(const u of n.events)if(u.type==="item.started")i.has(u.item.id)||t.set(u.item.id,u.item);else if(u.type==="item.completed")i.add(u.item.id),t.set(u.item.id,u.item);else if(u.type==="thread.tokenUsage.updated")a=u.usage;else if(u.type==="turn.failed")throw new Error(u.error.message);const d=Array.from(t.values()),o=d.filter(u=>u.type==="agentMessage").map(u=>u.text).join(`
+`);return{items:d,finalResponse:o||void 0,usage:a}}async runStreamed(e,r){const n=await l.request("turn/start",this.turnStartParams(e,r)),t=n.turn.id;return{turnId:t,events:this.eventsForTurn(t,n.turn,r?.signal)}}async steerStreamed(e,r,n){const t={threadId:this.id,input:[{type:"text",text:e}],expectedTurnId:r},i=await l.request("turn/steer",t);return{turnId:i.turnId,events:this.eventsForTurn(i.turnId,void 0,n?.signal,void 0,!0)}}async continueWithUserInput(e,r,n){const t=l.pendingUserInputTurnId(this.id,e);return t?{turnId:t,events:this.eventsForTurn(t,void 0,n?.signal,async()=>{if(!await l.respondToUserInput(this.id,e,r))throw new Error(`No pending user input request found for item: ${e}`)})}:(await this.interruptStaleTurn(n?.sourceTurnId),this.runStreamed(C(e,r),n))}async submitPendingUserInput(e,r){const n=l.pendingUserInputTurnId(this.id,e);if(!(!n||!await l.respondToUserInput(this.id,e,r)))return n}async interrupt(e){await l.request("turn/interrupt",{threadId:this.id,turnId:e})}async interruptPendingUserInput(e,r){await this.interrupt(e),l.discardPendingUserInput(this.id,r)}async interruptStaleTurn(e){if(!e)return;(await l.request("thread/read",{threadId:this.id,includeTurns:!0})).thread.turns?.find(t=>t.id===e)?.status==="inProgress"&&await this.interrupt(e)}turnStartParams(e,r){return{threadId:this.id,input:[{type:"text",text:e,text_elements:[]}],cwd:this.workingDirectory,approvalPolicy:"never",model:this.model,...r?.collaborationMode?{collaborationMode:r.collaborationMode}:null}}async*eventsForTurn(e,r,n,t,i=!1){const a=[...r||i?[{type:"thread.started",thread_id:this.id},{type:"turn.started",turn_id:e}]:[],...r?F(r):[]];let d=r?.status==="completed"||r?.status==="failed"||r?.status==="interrupted",o,u=!1,p=()=>{};const c=({method:h,params:w})=>{if(u)return;const y=M(h,w,this.id,e);y&&(a.push(y),(y.type==="turn.completed"||y.type==="turn.failed")&&(d=!0),p())},g=h=>{o=h,d=!0,p()},m=()=>{u=!0,a.length=0,d=!0,p()};l.on("notification",c),l.on("exit",g),n?.addEventListener("abort",m,{once:!0}),n?.aborted&&m();try{for(await t?.();!d||a.length>0;){for(;a.length>0;)yield a.shift();if(d)break;await new Promise(h=>{const w=setTimeout(()=>{p=()=>{},h()},50);p=()=>{clearTimeout(w),p=()=>{},h()}})}o&&(yield{type:"error",message:o.message})}finally{l.off("notification",c),l.off("exit",g),n?.removeEventListener("abort",m)}}}function C(s,e){return[`The user answered a previous request_user_input prompt (${s}), but the original pending tool request is no longer active.`,"Continue the task using this answer:",JSON.stringify(e,null,2)].join(`
+`)}class A{sessions=new Map;constructor(){for(const e of U())this.sessions.set(e.sessionId,{workdir:e.workdir,botName:e.botName??"main",llmProxyBinding:e.llmProxyBinding});E.info(`SessionManager: loaded ${this.sessions.size} persisted sessions`)}async getOrCreate(e,r,n,t,i,a,d){const o=this.resolveWorkdir(n,t);if(e){const p=this.sessions.get(e);if(p&&p.workdir===o){const c=p.llmProxyBinding??d,g=await l.request("thread/resume",this.threadResumeParams(e,i,o,a,c));if(!p.llmProxyBinding&&c){const m={...p,llmProxyBinding:c};this.sessions.set(e,m),I({sessionId:e,botName:m.botName,workdir:m.workdir,createdAt:Date.now(),llmProxyBinding:c})}return{thread:new k(g.thread.id,i,o),sessionId:e,isNewSession:!1}}}if(n&&!_(o))throw new P(o);b(o,{recursive:!0});const u=await l.request("thread/start",this.threadStartParams(i,o,a,d));return{thread:new k(u.thread.id,i,o),sessionId:void 0,isNewSession:!0}}async fork(e,r,n,t,i,a,d){const o=this.resolveWorkdir(n,t);if(n&&!_(o))throw new P(o);b(o,{recursive:!0});const p=(await l.request("thread/fork",this.threadForkParams(e.threadId,e.turnId,i,o,a,d))).thread.id;return this.persist(p,r,n,t,d),{thread:new k(p,i,o),sessionId:p,isNewSession:!1}}persist(e,r,n,t,i){const a=r??"main",d=this.resolveWorkdir(n,t);this.sessions.set(e,{botName:a,workdir:d,llmProxyBinding:i}),I({sessionId:e,botName:a,workdir:d,createdAt:Date.now(),llmProxyBinding:i})}bindingFor(e){return e?this.sessions.get(e)?.llmProxyBinding:void 0}workdirFor(e){return e?this.sessions.get(e)?.workdir:void 0}hasSession(e){return!!e&&this.sessions.has(e)}resolveWorkdir(e,r){return N(f,r,e)}threadStartParams(e,r,n,t){return{model:e,modelProvider:f.codex.baseUrl?"custom":null,cwd:r,approvalPolicy:"never",sandbox:n,config:this.codexConfig(t),developerInstructions:v,dynamicTools:S(),experimentalRawEvents:!1,persistExtendedHistory:!1}}threadResumeParams(e,r,n,t,i){return{threadId:e,model:r,modelProvider:f.codex.baseUrl?"custom":null,cwd:n,approvalPolicy:"never",sandbox:t,config:this.codexConfig(i),developerInstructions:v,excludeTurns:!0,persistExtendedHistory:!1}}threadForkParams(e,r,n,t,i,a){return{threadId:e,lastTurnId:r,model:n,modelProvider:f.codex.baseUrl?"custom":null,cwd:t,approvalPolicy:"never",sandbox:i,config:this.codexConfig(a),developerInstructions:v,ephemeral:!1,excludeTurns:!0}}codexConfig(e){return{approval_policy:"never",...f.codex.baseUrl?{model_provider:"custom",model_reasoning_effort:"medium",disable_response_storage:!0,model_providers:{custom:{name:"custom",base_url:f.codex.baseUrl,wire_api:"responses",...f.codex.apiKey?{env_key:"OPENAI_API_KEY"}:null,...e?{http_headers:{"X-Elevo-LLM-Binding":e}}:null}},"features.default_mode_request_user_input":!0}:null}}}f.codex.apiKey&&!process.env.OPENAI_API_KEY&&(process.env.OPENAI_API_KEY=f.codex.apiKey);function F(s){const e=[];for(const r of s.items??[])e.push({type:"item.completed",item:r});return s.status==="completed"?e.push({type:"turn.completed"}):s.status==="failed"&&e.push({type:"turn.failed",error:{message:s.error?.message??"Codex turn failed"}}),e}function M(s,e,r,n){const t=e;if(!t)return;const i=t.threadId,a=t.turnId;if(!(typeof i=="string"&&i!==r)&&!(typeof a=="string"&&a!==n)){if(s==="item/started"&&T(t.item))return{type:"item.started",item:t.item};if(s==="item/completed"&&T(t.item))return{type:"item.completed",item:t.item};if(s==="item/agentMessage/delta")return x(t,"agentMessage");if(s==="item/reasoning/summaryTextDelta"||s==="item/reasoning/textDelta")return x(t,"reasoning");if(s==="item/plan/delta")return x(t,"plan");if(s==="item/tool/requestUserInput")return{type:"item.tool.requestUserInput",params:t};if(s==="turn/diff/updated"&&typeof t.diff=="string")return{type:"turn.diff.updated",diff:t.diff};if(s==="thread/tokenUsage/updated")return{type:"thread.tokenUsage.updated",usage:R(t)};if(s==="turn/completed"){const d=t.turn;return d?.status==="failed"?{type:"turn.failed",error:{message:d.error?.message??"Codex turn failed"}}:{type:"turn.completed"}}if(s==="error")return console.error("Received error notification from app-server:",t),{type:"error",message:q(t)}}}function q(s){const e=s.error,r=e&&typeof e=="object"&&"message"in e?e.message:void 0,n=s.additionalDetails,t=typeof r=="string"&&r.trim()?r:"Codex app-server error";return typeof n=="string"&&n.trim()?`${t}: ${n}`:t}function x(s,e){if(!(typeof s.itemId!="string"||typeof s.delta!="string"))return{type:"item.delta",item_id:s.itemId,item_type:e,delta:s.delta}}function R(s){const e=s.tokenUsage;if(!e||typeof e!="object")return null;const r=e,n=r.total,t=r.last;if(!n||typeof n!="object"||!t||typeof t!="object")return null;const i=d=>{const o=d;return{input_tokens:typeof o.inputTokens=="number"?o.inputTokens:void 0,output_tokens:typeof o.outputTokens=="number"?o.outputTokens:void 0,total_tokens:typeof o.totalTokens=="number"?o.totalTokens:void 0}},a=r.modelContextWindow;return{total:i(n),last:i(t),model_context_window:typeof a=="number"?a:void 0}}function T(s){return!!(s&&typeof s=="object"&&"type"in s&&"id"in s)}const Y=new A;export{k as CodexThread,P as WorkdirNotFoundError,Y as sessionManager};

package/dist/config.js

@@ -1,154 +1 @@
-import { existsSync, readFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { parse } from "yaml";
-import { z } from "zod";
-import { normalizeOptional, parseAgentAuthConfig, parseAgentWorkspacesConfig, parseGitInitConfig, } from "@messenger-agent/shared/agent-config";
-import { logger, normalizeLogLevel, setLogFile, setLogLevel } from "@messenger-agent/shared/logger";
-const defaultTunnelServerUrl = "wss://m.elevo.vip/agent-bridge/tunnel";
-const defaultCodexBaseUrl = "https://m.elevo.vip/agent-bridge/llm/v1";
-const RawConfigSchema = z
-    .object({
-    log_level: z.string().optional(),
-    port: z.coerce.number().int().positive().optional(),
-    auth_tokens: z.record(z.string(), z.string()).optional(),
-    workspaces: z
-        .array(z.object({
-        id: z.string().optional(),
-        name: z.string().optional(),
-        path: z.string().optional(),
-    }))
-        .optional(),
-    file_uploads: z
-        .object({
-        temp_dir: z.string().optional(),
-    })
-        .optional(),
-    data_dir: z.string().optional(),
-    codex: z
-        .object({
-        port: z.coerce.number().int().positive().optional(),
-        data_dir: z.string().optional(),
-        file_uploads: z.object({ temp_dir: z.string().optional() }).optional(),
-        api_key: z.string().optional(),
-        base_url: z.string().optional(),
-    })
-        .optional(),
-    openai: z
-        .object({
-        api_key: z.string().optional(),
-        base_url: z.string().optional(),
-        image_model: z.string().optional(),
-    })
-        .optional(),
-    gitlab: z
-        .object({
-        ca_cert_path: z.string().optional(),
-        host: z.string().optional(),
-    })
-        .optional(),
-    git: z
-        .object({
-        co_authors: z.array(z.string()).optional(),
-    })
-        .optional(),
-    tunnel: z
-        .object({
-        enabled: z.boolean().optional(),
-        server_url: z.string().optional(),
-        tunnel_id: z.string().optional(),
-        token: z.string().optional(),
-        reconnect_initial_ms: z.number().int().positive().optional(),
-        reconnect_max_ms: z.number().int().positive().optional(),
-        heartbeat_interval_ms: z.number().int().positive().optional(),
-    })
-        .optional(),
-})
-    .loose();
-function loadConfig() {
-    const configPath = process.env.AGENT_CONFIG_PATH ?? "./agent-config.yaml";
-    if (!existsSync(configPath)) {
-        const dataDir = "./data";
-        const logFile = join(dataDir, "logs", "codex-agent.log");
-        setLogLevel("info");
-        setLogFile(logFile);
-        logger.warn(`Config file not found at ${configPath}`);
-        return {
-            configPath,
-            logLevel: "info",
-            logFile,
-            port: 3000,
-            fileUploads: { tempDir: join(tmpdir(), "codex-agent-uploads") },
-            dataDir,
-            sessionsDbPath: join(dataDir, "sessions.db"),
-            codex: {},
-            openai: { imageModel: "gpt-image-2" },
-            tunnel: {
-                enabled: false,
-                reconnectInitialMs: 1000,
-                reconnectMaxMs: 30000,
-                heartbeatIntervalMs: 30000,
-            },
-            ...parseAgentAuthConfig({}),
-            ...parseAgentWorkspacesConfig({}),
-            ...parseGitInitConfig({}),
-        };
-    }
-    let parsedYaml;
-    try {
-        parsedYaml = parse(readFileSync(configPath, "utf-8"));
-    }
-    catch (err) {
-        logger.error(`Failed to parse config file at ${configPath}:`, err);
-        parsedYaml = {};
-    }
-    const raw = RawConfigSchema.safeParse(parsedYaml ?? {});
-    if (!raw.success) {
-        logger.error(`Invalid config format at ${configPath}:`, raw.error.issues);
-    }
-    const data = raw.success ? raw.data : {};
-    const logLevel = normalizeLogLevel(data.log_level);
-    const dataDir = normalizeOptional(data.codex?.data_dir) ?? normalizeOptional(data.data_dir) ?? "./data";
-    const logFile = join(dataDir, "logs", "codex-agent.log");
-    const tunnelEnabled = data.tunnel?.enabled ?? false;
-    const tunnelToken = normalizeOptional(data.tunnel?.token);
-    setLogLevel(logLevel);
-    setLogFile(logFile);
-    const config = {
-        configPath,
-        logLevel,
-        logFile,
-        port: data.codex?.port ?? data.port ?? 3000,
-        fileUploads: {
-            tempDir: normalizeOptional(data.codex?.file_uploads?.temp_dir) ??
-                normalizeOptional(data.file_uploads?.temp_dir) ??
-                join(tmpdir(), "codex-agent-uploads"),
-        },
-        dataDir,
-        sessionsDbPath: join(dataDir, "sessions.db"),
-        codex: {
-            apiKey: normalizeOptional(data.codex?.api_key) ?? (tunnelEnabled ? tunnelToken : undefined),
-            baseUrl: normalizeOptional(data.codex?.base_url) ?? (tunnelEnabled ? defaultCodexBaseUrl : undefined),
-        },
-        openai: {
-            apiKey: normalizeOptional(data.openai?.api_key) ?? (tunnelEnabled ? tunnelToken : undefined),
-            baseUrl: normalizeOptional(data.openai?.base_url) ?? (tunnelEnabled ? defaultCodexBaseUrl : undefined),
-            imageModel: normalizeOptional(data.openai?.image_model) ?? "gpt-image-2",
-        },
-        tunnel: {
-            enabled: tunnelEnabled,
-            serverUrl: normalizeOptional(data.tunnel?.server_url) ?? (tunnelEnabled ? defaultTunnelServerUrl : undefined),
-            tunnelId: normalizeOptional(data.tunnel?.tunnel_id),
-            token: tunnelToken,
-            reconnectInitialMs: data.tunnel?.reconnect_initial_ms ?? 1000,
-            reconnectMaxMs: data.tunnel?.reconnect_max_ms ?? 30000,
-            heartbeatIntervalMs: data.tunnel?.heartbeat_interval_ms ?? 30000,
-        },
-        ...parseAgentAuthConfig(data),
-        ...parseAgentWorkspacesConfig(data),
-        ...parseGitInitConfig(data),
-    };
-    logger.info(`Loaded agent config from ${configPath}`);
-    return config;
-}
-export const appConfig = loadConfig();
+import{existsSync as j,readFileSync as M}from"node:fs";import{tmpdir as f}from"node:os";import{join as a}from"node:path";import{parse as C}from"yaml";import{z as e}from"zod";import{normalizeOptional as n,parseAgentAuthConfig as _,parseAgentWorkspacesConfig as b,parseGitInitConfig as v}from"@messenger-agent/shared/agent-config";import{logger as s,normalizeLogLevel as I,setLogFile as x,setLogLevel as h}from"@messenger-agent/shared/logger";const L="wss://m.elevo.vip/agent-bridge/tunnel",y="https://m.elevo.vip/agent-bridge/llm/v1",U=e.object({log_level:e.string().optional(),port:e.coerce.number().int().positive().optional(),auth_tokens:e.record(e.string(),e.string()).optional(),workspaces:e.array(e.object({id:e.string().optional(),name:e.string().optional(),path:e.string().optional()})).optional(),file_uploads:e.object({temp_dir:e.string().optional()}).optional(),data_dir:e.string().optional(),codex:e.object({port:e.coerce.number().int().positive().optional(),data_dir:e.string().optional(),file_uploads:e.object({temp_dir:e.string().optional()}).optional(),api_key:e.string().optional(),base_url:e.string().optional()}).optional(),openai:e.object({api_key:e.string().optional(),base_url:e.string().optional(),image_model:e.string().optional()}).optional(),gitlab:e.object({ca_cert_path:e.string().optional(),host:e.string().optional()}).optional(),git:e.object({co_authors:e.array(e.string()).optional()}).optional(),tunnel:e.object({enabled:e.boolean().optional(),server_url:e.string().optional(),tunnel_id:e.string().optional(),token:e.string().optional(),reconnect_initial_ms:e.number().int().positive().optional(),reconnect_max_ms:e.number().int().positive().optional(),heartbeat_interval_ms:e.number().int().positive().optional()}).optional()}).loose();function D(){const t=process.env.AGENT_CONFIG_PATH??"./agent-config.yaml";if(!j(t)){const r="./data",u=a(r,"logs","codex-agent.log");return h("info"),x(u),s.warn(`Config file not found at ${t}`),{configPath:t,logLevel:"info",logFile:u,port:3e3,fileUploads:{tempDir:a(f(),"codex-agent-uploads")},dataDir:r,sessionsDbPath:a(r,"sessions.db"),codex:{},openai:{imageModel:"gpt-image-2"},tunnel:{enabled:!1,reconnectInitialMs:1e3,reconnectMaxMs:3e4,heartbeatIntervalMs:3e4},..._({}),...b({}),...v({})}}let p;try{p=C(M(t,"utf-8"))}catch(r){s.error(`Failed to parse config file at ${t}:`,r),p={}}const l=U.safeParse(p??{});l.success||s.error(`Invalid config format at ${t}:`,l.error.issues);const o=l.success?l.data:{},g=I(o.log_level),c=n(o.codex?.data_dir)??n(o.data_dir)??"./data",m=a(c,"logs","codex-agent.log"),i=o.tunnel?.enabled??!1,d=n(o.tunnel?.token);h(g),x(m);const k={configPath:t,logLevel:g,logFile:m,port:o.codex?.port??o.port??3e3,fileUploads:{tempDir:n(o.codex?.file_uploads?.temp_dir)??n(o.file_uploads?.temp_dir)??a(f(),"codex-agent-uploads")},dataDir:c,sessionsDbPath:a(c,"sessions.db"),codex:{apiKey:n(o.codex?.api_key)??(i?d:void 0),baseUrl:n(o.codex?.base_url)??(i?y:void 0)},openai:{apiKey:n(o.openai?.api_key)??(i?d:void 0),baseUrl:n(o.openai?.base_url)??(i?y:void 0),imageModel:n(o.openai?.image_model)??"gpt-image-2"},tunnel:{enabled:i,serverUrl:n(o.tunnel?.server_url)??(i?L:void 0),tunnelId:n(o.tunnel?.tunnel_id),token:d,reconnectInitialMs:o.tunnel?.reconnect_initial_ms??1e3,reconnectMaxMs:o.tunnel?.reconnect_max_ms??3e4,heartbeatIntervalMs:o.tunnel?.heartbeat_interval_ms??3e4},..._(o),...b(o),...v(o)};return s.info(`Loaded agent config from ${t}`),k}const z=D();export{z as appConfig};

package/dist/db.js

@@ -1,11 +1,4 @@
-import { DatabaseSync } from "node:sqlite";
-import { mkdirSync } from "node:fs";
-import { dirname } from "node:path";
-import { appConfig } from "./config.js";
-const DB_PATH = appConfig.sessionsDbPath;
-mkdirSync(dirname(DB_PATH), { recursive: true });
-const db = new DatabaseSync(DB_PATH);
-db.exec(`
+import{DatabaseSync as o}from"node:sqlite";import{mkdirSync as i}from"node:fs";import{dirname as t}from"node:path";import{appConfig as r}from"./config.js";const n=r.sessionsDbPath;i(t(n),{recursive:!0});const e=new o(n);e.exec(`
   CREATE TABLE IF NOT EXISTS sessions (
     sessionId  TEXT PRIMARY KEY,
     workdir    TEXT NOT NULL,
@@ -13,20 +6,4 @@ db.exec(`
     botName    TEXT NOT NULL DEFAULT 'main',
     llmProxyBinding TEXT
   )
-`);
-const sessionColumns = db.prepare("PRAGMA table_info(sessions)").all();
-if (!sessionColumns.some((column) => column.name === "llmProxyBinding")) {
-    db.exec("ALTER TABLE sessions ADD COLUMN llmProxyBinding TEXT");
-}
-const stmtInsert = db.prepare(`INSERT OR REPLACE INTO sessions (sessionId, workdir, createdAt, botName, llmProxyBinding) VALUES (?, ?, ?, ?, ?)`);
-const stmtGetAll = db.prepare(`SELECT * FROM sessions`);
-const stmtGet = db.prepare(`SELECT * FROM sessions WHERE sessionId = ?`);
-export function persistSession(row) {
-    stmtInsert.run(row.sessionId, row.workdir, row.createdAt, row.botName, row.llmProxyBinding ?? null);
-}
-export function loadAllSessions() {
-    return stmtGetAll.all();
-}
-export function getSession(sessionId) {
-    return stmtGet.get(sessionId);
-}
+`);const T=e.prepare("PRAGMA table_info(sessions)").all();T.some(s=>s.name==="llmProxyBinding")||e.exec("ALTER TABLE sessions ADD COLUMN llmProxyBinding TEXT");const m=e.prepare("INSERT OR REPLACE INTO sessions (sessionId, workdir, createdAt, botName, llmProxyBinding) VALUES (?, ?, ?, ?, ?)"),E=e.prepare("SELECT * FROM sessions"),l=e.prepare("SELECT * FROM sessions WHERE sessionId = ?");function A(s){m.run(s.sessionId,s.workdir,s.createdAt,s.botName,s.llmProxyBinding??null)}function L(){return E.all()}function N(s){return l.get(s)}export{N as getSession,L as loadAllSessions,A as persistSession};