telecodex 0.1.5 → 0.1.6

package/dist/bot/handlers/operationalHandlers.js

@@ -94,7 +94,6 @@ export function registerOperationalHandlers(deps) {
                 textField("state", formatSessionRuntimeStatus(latestSession.runtimeStatus)),
                 textField("state detail", latestSession.runtimeStatusDetail ?? "none"),
                 textField("state updated", formatIsoTimestamp(latestSession.runtimeStatusUpdatedAt)),
-                codeField("active turn", latestSession.activeTurnId ?? "none"),
                 textField("active run", activeRun ? formatIsoTimestamp(activeRun.startedAt) : "none"),
                 codeField("active run thread", activeRun?.threadId ?? "none"),
                 textField("active run last event", activeRun?.lastEventType ?? "none"),
@@ -127,7 +126,6 @@ export function registerOperationalHandlers(deps) {
                 title: "Queue",
                 fields: [
                     textField("state", formatSessionRuntimeStatus(session.runtimeStatus)),
-                    codeField("active turn", session.activeTurnId ?? "none"),
                     textField("queue", queueDepth),
                 ],
                 sections: [

package/dist/bot/inputService.js

@@ -32,7 +32,7 @@ export async function handleUserInput(input) {
             chatId: numericChatId(session),
             messageThreadId: numericMessageThreadId(session),
         }, [
-            `The current Codex task is still ${describeBusyStatus(session.runtimeStatus)}. Your message was added to the queue.`,
+            `Codex is still ${describeBusyStatus(session.runtimeStatus)}. Your message was added to the queue.`,
             `queue position: ${queueDepth}`,
             `queued at: ${formatIsoTimestamp(queued.createdAt)}`,
             "It will be processed automatically after the current run finishes.",
@@ -48,7 +48,7 @@ export async function handleUserInput(input) {
         sessionKey: session.sessionKey,
         event: {
             type: "turn.preparing",
-            detail: "starting codex sdk run",
+            detail: "waiting for first Codex SDK event",
         },
         logger,
     });
@@ -78,17 +78,6 @@ export async function handleUserInput(input) {
         };
     }
     store.setOutputMessage(session.sessionKey, outputMessageId);
-    const turnId = createLocalTurnId();
-    await applySessionRuntimeEvent({
-        bot,
-        store,
-        sessionKey: session.sessionKey,
-        event: {
-            type: "turn.started",
-            turnId,
-        },
-        logger,
-    });
     void runSessionPrompt({
         sessionKey: session.sessionKey,
         prompt,
@@ -96,7 +85,6 @@ export async function handleUserInput(input) {
         codex,
         buffers,
         bot,
-        turnId,
         bufferKey,
         ...(logger ? { logger } : {}),
     });
@@ -118,7 +106,6 @@ export async function refreshSessionIfActiveTurnIsStale(session, store, codex, b
         sessionKey: latest.sessionKey,
         event: {
             type: "turn.failed",
-            turnId: latest.activeTurnId,
             message: "The previous run was lost. Send the message again.",
         },
         logger,
@@ -179,10 +166,13 @@ export async function processNextQueuedInputForSession(sessionKey, store, codex,
     }
 }
 async function runSessionPrompt(input) {
-    const { sessionKey, prompt, store, codex, buffers, bot, turnId, bufferKey, logger } = input;
+    const { sessionKey, prompt, store, codex, buffers, bot, bufferKey, logger } = input;
     const session = store.get(sessionKey);
     if (!session)
         return;
+    logger?.info("starting codex sdk run", {
+        ...sessionLogFields(session),
+    });
     try {
         const result = await codex.run({
             profile: {
@@ -203,8 +193,19 @@ async function runSessionPrompt(input) {
             callbacks: {
                 onThreadStarted: async (threadId) => {
                     store.bindThread(sessionKey, threadId);
+                    logger?.info("codex sdk thread started", {
+                        sessionKey,
+                        threadId,
+                    });
                 },
                 onEvent: async (event) => {
+                    await applyRuntimeStateForSdkEvent({
+                        event,
+                        sessionKey,
+                        store,
+                        bot,
+                        logger,
+                    });
                     await projectEventToTelegramBuffer(buffers, bufferKey, event);
                 },
             },
@@ -219,11 +220,14 @@ async function runSessionPrompt(input) {
                 sessionKey,
                 event: {
                     type: "turn.completed",
-                    turnId,
                 },
                 logger,
             });
         }
+        logger?.info("codex sdk run completed", {
+            sessionKey,
+            threadId: result.threadId,
+        });
         await buffers.complete(bufferKey, result.finalResponse || undefined);
     }
     catch (error) {
@@ -237,16 +241,18 @@ async function runSessionPrompt(input) {
                 event: isAbortError(error)
                     ? {
                         type: "turn.interrupted",
-                        turnId,
                     }
                     : {
                         type: "turn.failed",
-                        turnId,
                         message: error instanceof Error ? error.message : String(error),
                     },
                 logger,
             });
         }
+        logger?.warn("codex sdk run failed", {
+            sessionKey,
+            error,
+        });
         if (isAbortError(error)) {
             await buffers.fail(bufferKey, "Current run interrupted.");
         }
@@ -258,13 +264,33 @@ async function runSessionPrompt(input) {
         await processNextQueuedInputForSession(sessionKey, store, codex, buffers, bot, logger);
     }
 }
+async function applyRuntimeStateForSdkEvent(input) {
+    if (input.event.type !== "turn.started") {
+        return;
+    }
+    const session = input.store.get(input.sessionKey);
+    if (!session)
+        return;
+    if (session.runtimeStatus === "running") {
+        return;
+    }
+    await applySessionRuntimeEvent({
+        bot: input.bot,
+        store: input.store,
+        sessionKey: input.sessionKey,
+        event: {
+            type: "turn.started",
+        },
+        logger: input.logger,
+    });
+}
 async function projectEventToTelegramBuffer(buffers, key, event) {
     switch (event.type) {
         case "thread.started":
             buffers.note(key, `thread started: ${event.thread_id}`);
             return;
         case "turn.started":
-            buffers.note(key, "started processing");
+            buffers.markTurnStarted(key);
             return;
         case "turn.completed":
             buffers.note(key, `token usage: in ${event.usage.input_tokens}, out ${event.usage.output_tokens}, cached ${event.usage.cached_input_tokens}`);
@@ -357,9 +383,6 @@ function projectTodoList(buffers, key, item) {
         buffers.setPlan(key, lines.join("\n"));
     }
 }
-function createLocalTurnId() {
-    return `sdk-turn-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
-}
 function toSdkInput(input) {
     return input;
 }

package/dist/bot/sessionFlow.js

@@ -31,11 +31,10 @@ export function sessionLogFields(session) {
         runtimeStatus: session.runtimeStatus,
         runtimeStatusDetail: session.runtimeStatusDetail,
         codexThreadId: session.codexThreadId,
-        activeTurnId: session.activeTurnId,
     };
 }
 export function isSessionBusy(session) {
-    return session.runtimeStatus === "preparing" || session.runtimeStatus === "running" || session.activeTurnId != null;
+    return session.runtimeStatus === "preparing" || session.runtimeStatus === "running";
 }
 export function describeBusyStatus(status) {
     switch (status) {

package/dist/codex/sdkRuntime.js

@@ -86,7 +86,12 @@ export class CodexSdkRuntime {
         let finalResponse = "";
         let usage = null;
         let threadId = input.initialThreadId;
-        for await (const event of streamed.events) {
+        const iterator = streamed.events[Symbol.asyncIterator]();
+        while (true) {
+            const next = await iterator.next();
+            if (next.done)
+                break;
+            const event = next.value;
             const activeRun = this.activeRuns.get(input.sessionKey);
             if (activeRun) {
                 activeRun.lastEventAt = new Date().toISOString();

package/dist/runtime/sessionRuntime.js

@@ -13,14 +13,12 @@ export function reduceSessionRuntimeState(session, event, updatedAt = new Date()
                 status: "preparing",
                 detail: event.detail ?? null,
                 updatedAt,
-                activeTurnId: null,
             };
         case "turn.started":
             return {
                 status: "running",
                 detail: null,
                 updatedAt,
-                activeTurnId: event.turnId,
             };
         case "turn.completed":
         case "turn.interrupted":
@@ -28,14 +26,12 @@ export function reduceSessionRuntimeState(session, event, updatedAt = new Date()
                 status: "idle",
                 detail: null,
                 updatedAt,
-                activeTurnId: null,
             };
         case "turn.failed":
             return {
                 status: "failed",
                 detail: event.message?.trim() || null,
                 updatedAt,
-                activeTurnId: null,
             };
     }
 }

package/dist/store/sessions.js

@@ -320,7 +320,6 @@ function mapStoredSession(stored, runtimeState, outputMessageId) {
         status: "idle",
         detail: null,
         updatedAt: stored.updatedAt,
-        activeTurnId: null,
     };
     return {
         ...stored,
@@ -328,7 +327,6 @@ function mapStoredSession(stored, runtimeState, outputMessageId) {
         runtimeStatus: runtime.status,
         runtimeStatusDetail: runtime.detail,
         runtimeStatusUpdatedAt: runtime.updatedAt,
-        activeTurnId: runtime.activeTurnId,
         outputMessageId: outputMessageId ?? null,
     };
 }

package/dist/telegram/delivery.js

@@ -1,13 +1,25 @@
-import { GrammyError } from "grammy";
+import { GrammyError, HttpError } from "grammy";
 import { renderPlainChunksForTelegram } from "./renderer.js";
 import { splitTelegramHtml } from "./splitMessage.js";
 const telegramCooldownByClient = new WeakMap();
+const MAX_TELEGRAM_RETRY_ATTEMPTS = 5;
+const TELEGRAM_NETWORK_RETRY_BASE_MS = 100;
+const TELEGRAM_NETWORK_RETRY_MAX_MS = 1_000;
+const RETRYABLE_NETWORK_ERROR_CODES = new Set([
+    "ECONNRESET",
+    "ECONNREFUSED",
+    "EPIPE",
+    "ETIMEDOUT",
+    "ESOCKETTIMEDOUT",
+    "ENOTFOUND",
+    "EAI_AGAIN",
+]);
 export async function sendHtmlMessage(bot, input, logger) {
     return retryTelegramCall(bot.api, () => bot.api.sendMessage(input.chatId, input.text, {
         ...(input.messageThreadId == null ? {} : { message_thread_id: input.messageThreadId }),
         parse_mode: "HTML",
         link_preview_options: { is_disabled: true },
-    }), logger, "telegram send rate limited", {
+    }), logger, "telegram send retry scheduled", {
         chatId: input.chatId,
         messageThreadId: input.messageThreadId,
     });
@@ -29,9 +41,11 @@ export async function sendPlainChunks(bot, input, logger) {
 export async function sendTypingAction(bot, input, logger) {
     await retryTelegramCall(bot.api, () => bot.api.sendChatAction(input.chatId, "typing", {
         ...(input.messageThreadId == null ? {} : { message_thread_id: input.messageThreadId }),
-    }), logger, "telegram chat action rate limited", {
+    }), logger, "telegram chat action retry scheduled", {
         chatId: input.chatId,
         messageThreadId: input.messageThreadId,
+    }, {
+        allowNetworkRetry: true,
     });
 }
 export async function replaceOrSendHtmlChunks(bot, input, logger) {
@@ -84,9 +98,11 @@ export async function editHtmlMessage(bot, input, logger) {
     await retryTelegramCall(bot.api, () => bot.api.editMessageText(input.chatId, input.messageId, input.text, {
         parse_mode: "HTML",
         link_preview_options: { is_disabled: true },
-    }), logger, "telegram edit rate limited", {
+    }), logger, "telegram edit retry scheduled", {
         chatId: input.chatId,
         messageId: input.messageId,
+    }, {
+        allowNetworkRetry: true,
     });
 }
 export function isMessageNotModifiedError(error) {
@@ -113,29 +129,90 @@ function retryAfterMs(error) {
     }
     return null;
 }
+function retryPlan(error, attempt) {
+    const rateLimitDelayMs = retryAfterMs(error);
+    if (rateLimitDelayMs != null) {
+        return {
+            kind: "rate-limit",
+            delayMs: rateLimitDelayMs + 250,
+        };
+    }
+    if (isRetryableNetworkError(error)) {
+        return {
+            kind: "network",
+            delayMs: Math.min(TELEGRAM_NETWORK_RETRY_BASE_MS * 2 ** attempt, TELEGRAM_NETWORK_RETRY_MAX_MS),
+        };
+    }
+    return null;
+}
 function descriptionOf(error) {
     return typeof error.description === "string" ? error.description : null;
 }
-export async function retryTelegramCall(cooldownKey, operation, logger, message, context) {
+function isRetryableNetworkError(error) {
+    if (!(error instanceof HttpError))
+        return false;
+    return isRetryableNetworkCause(error.error);
+}
+function isRetryableNetworkCause(error) {
+    if (error instanceof Error && error.name === "AbortError") {
+        return false;
+    }
+    const code = readErrorCode(error);
+    if (code && RETRYABLE_NETWORK_ERROR_CODES.has(code)) {
+        return true;
+    }
+    const message = readErrorMessage(error);
+    if (!message)
+        return false;
+    return (message.includes("socket hang up") ||
+        message.includes("connection reset") ||
+        message.includes("network request failed") ||
+        message.includes("fetch failed") ||
+        message.includes("timed out") ||
+        message.includes("timeout"));
+}
+function readErrorCode(error) {
+    if (typeof error !== "object" || error == null || !("code" in error))
+        return null;
+    const code = error.code;
+    return typeof code === "string" && code ? code : null;
+}
+function readErrorMessage(error) {
+    if (error instanceof Error) {
+        return error.message.toLowerCase();
+    }
+    if (typeof error === "string") {
+        return error.toLowerCase();
+    }
+    return null;
+}
+export async function retryTelegramCall(cooldownKey, operation, logger, message, context, options) {
     for (let attempt = 0;; attempt += 1) {
         await waitForTelegramCooldown(cooldownKey);
         try {
             return await operation();
         }
         catch (error) {
-            const waitMs = retryAfterMs(error);
-            if (waitMs == null || attempt >= 5) {
+            const rateLimitDelayMs = retryAfterMs(error);
+            const retry = options?.allowNetworkRetry === true
+                ? retryPlan(error, attempt)
+                : rateLimitDelayMs == null
+                    ? null
+                    : {
+                        kind: "rate-limit",
+                        delayMs: rateLimitDelayMs + 250,
+                    };
+            if (retry == null || attempt >= MAX_TELEGRAM_RETRY_ATTEMPTS) {
                 throw error;
             }
-            const cooldownMs = waitMs + 250;
             logger?.warn(message, {
                 ...context,
                 attempt: attempt + 1,
-                retryAfterMs: waitMs,
-                sharedCooldownMs: cooldownMs,
+                retryKind: retry.kind,
+                retryDelayMs: retry.delayMs,
                 error,
             });
-            await applyTelegramCooldown(cooldownKey, cooldownMs);
+            await applyTelegramCooldown(cooldownKey, retry.delayMs);
         }
     }
 }

package/dist/telegram/messageBuffer.js

@@ -1,15 +1,20 @@
 import { editHtmlMessage, isMessageNotModifiedError, replaceOrSendHtmlChunks, sendHtmlMessage, sendTypingAction, shouldFallbackToNewMessage, } from "./delivery.js";
 import { renderMarkdownForTelegram, renderPlainChunksForTelegram, renderPlainForTelegram } from "./renderer.js";
-const ACTIVITY_PULSE_INTERVAL_MS = 4_000;
+const DEFAULT_ACTIVITY_PULSE_INTERVAL_MS = 4_000;
+const DEFAULT_ACTIVITY_IDLE_MS = 60_000;
 export class MessageBuffer {
     bot;
     updateIntervalMs;
     logger;
     states = new Map();
-    constructor(bot, updateIntervalMs, logger) {
+    activityPulseIntervalMs;
+    activityIdleMs;
+    constructor(bot, updateIntervalMs, logger, input) {
         this.bot = bot;
         this.updateIntervalMs = updateIntervalMs;
         this.logger = logger;
+        this.activityPulseIntervalMs = input?.activityPulseIntervalMs ?? DEFAULT_ACTIVITY_PULSE_INTERVAL_MS;
+        this.activityIdleMs = input?.activityIdleMs ?? DEFAULT_ACTIVITY_IDLE_MS;
     }
     async create(key, input) {
         const previous = this.states.get(key);
@@ -22,12 +27,13 @@ export class MessageBuffer {
         const message = await sendHtmlMessage(this.bot, {
             chatId: input.chatId,
             messageThreadId: input.messageThreadId,
-            text: "Codex is working...",
+            text: "Starting Codex...",
         }, this.logger);
         const state = {
             chatId: input.chatId,
             messageThreadId: input.messageThreadId,
             messageId: message.message_id,
+            phase: "starting",
             text: "",
             progressLines: [],
             planText: "",
@@ -36,6 +42,7 @@ export class MessageBuffer {
             timer: null,
             activityTimer: null,
             activityInFlight: false,
+            lastActivityAt: Date.now(),
             lastSentText: "",
             queue: Promise.resolve(),
         };
@@ -51,6 +58,7 @@ export class MessageBuffer {
         if (!state)
             return;
         state.text = text;
+        this.touchActivity(state);
         this.scheduleFlush(key, state);
     }
     note(key, line) {
@@ -68,6 +76,17 @@ export class MessageBuffer {
         if (state.progressLines.length > 8) {
             state.progressLines.splice(0, state.progressLines.length - 8);
         }
+        this.touchActivity(state);
+        this.scheduleFlush(key, state);
+    }
+    markTurnStarted(key) {
+        const state = this.states.get(key);
+        if (!state)
+            return;
+        if (state.phase === "running")
+            return;
+        state.phase = "running";
+        this.touchActivity(state);
         this.scheduleFlush(key, state);
     }
     setPlan(key, text) {
@@ -75,6 +94,7 @@ export class MessageBuffer {
         if (!state)
             return;
         state.planText = text.trim();
+        this.touchActivity(state);
         this.scheduleFlush(key, state);
     }
     setReasoningSummary(key, text) {
@@ -82,6 +102,7 @@ export class MessageBuffer {
         if (!state)
             return;
         state.reasoningSummaryText = text.trim();
+        this.touchActivity(state);
         this.scheduleFlush(key, state);
     }
     setToolOutput(key, text) {
@@ -89,6 +110,7 @@ export class MessageBuffer {
         if (!state)
             return;
         state.toolOutputText = truncateTail(text.replace(/\r/g, "").trim(), 2000);
+        this.touchActivity(state);
         this.scheduleFlush(key, state);
     }
     rename(from, to) {
@@ -144,7 +166,7 @@ export class MessageBuffer {
             const latest = this.states.get(key);
             if (!latest)
                 return;
-            const text = renderPlainForTelegram(truncateForEdit(composePendingText(latest)));
+            const text = renderPlainForTelegram(truncateForEdit(composePendingText(latest), latest.phase));
             if (text === latest.lastSentText)
                 return;
             await this.safeEdit(latest, text);
@@ -193,10 +215,12 @@ export class MessageBuffer {
         }
     }
     startActivityPulse(state) {
+        if (state.activityTimer)
+            return;
         void this.sendActivityPulse(state);
         const timer = setInterval(() => {
             void this.sendActivityPulse(state);
-        }, ACTIVITY_PULSE_INTERVAL_MS);
+        }, this.activityPulseIntervalMs);
         timer.unref?.();
         state.activityTimer = timer;
     }
@@ -207,6 +231,10 @@ export class MessageBuffer {
         state.activityTimer = null;
     }
     async sendActivityPulse(state) {
+        if (Date.now() - state.lastActivityAt >= this.activityIdleMs) {
+            this.stopActivityPulse(state);
+            return;
+        }
         if (state.activityInFlight)
             return;
         state.activityInFlight = true;
@@ -227,6 +255,12 @@ export class MessageBuffer {
             state.activityInFlight = false;
         }
     }
+    touchActivity(state) {
+        state.lastActivityAt = Date.now();
+        if (!state.activityTimer) {
+            this.startActivityPulse(state);
+        }
+    }
     async replaceWithChunks(state, chunks) {
         const messageId = await replaceOrSendHtmlChunks(this.bot, {
             chatId: state.chatId,
@@ -248,13 +282,13 @@ export class MessageBuffer {
         await run;
     }
 }
-function truncateForEdit(text) {
+function truncateForEdit(text, phase) {
     if (text.length <= 3800)
-        return text || "Codex is working...";
+        return text || pendingBanner(phase);
     return `${text.slice(0, 3800)}\n\n...`;
 }
 function composePendingText(state) {
-    const sections = ["Codex is working..."];
+    const sections = [pendingBanner(state.phase)];
     if (state.planText) {
         sections.push(`[Plan]\n${state.planText}`);
     }
@@ -275,6 +309,9 @@ function composePendingText(state) {
     }
     return sections.join("\n\n");
 }
+function pendingBanner(phase) {
+    return phase === "running" ? "Codex is working..." : "Starting Codex...";
+}
 function truncateTail(text, maxLength) {
     if (text.length <= maxLength)
         return text;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "telecodex",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "Telegram bridge for local Codex.",
   "license": "MIT",
   "type": "module",
@@ -52,7 +52,7 @@
     "@grammyjs/parse-mode": "^2.3.0",
     "@grammyjs/runner": "^2.0.3",
     "@napi-rs/keyring": "^1.2.0",
-    "@openai/codex-sdk": "^0.120.0",
+    "@openai/codex-sdk": "^0.121.0",
     "clipboardy": "^4.0.0",
     "grammy": "^1.42.0",
     "markdown-it": "^14.1.0",