poe-code 3.0.427 → 3.0.428

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "poe-code",
-  "version": "3.0.427",
+  "version": "3.0.428",
   "description": "CLI tool to configure Poe API for developer workflows.",
   "license": "MIT",
   "type": "module",
@@ -196,6 +196,7 @@
     "ignore": "^5.3.2",
     "jose": "^6.1.3",
     "jsonc-parser": "^3.3.1",
+    "lru-cache": "^10.4.3",
     "mustache": "^4.2.0",
     "openai": "^6.34.0",
     "parse-duration": "^2.1.5",

package/packages/agent-trace-viewer/dist/breakdown.d.ts

@@ -1,3 +1,7 @@
 import type { NormalizedTrace } from "../../agent-traces/dist/index.js";
 import type { ContextBreakdown } from "./types.js";
-export declare function computeContextBreakdown(trace: NormalizedTrace): ContextBreakdown;
+export interface ComputeContextBreakdownOptions {
+    signal?: AbortSignal;
+    mode?: "exact" | "estimated";
+}
+export declare function computeContextBreakdown(trace: NormalizedTrace, options?: ComputeContextBreakdownOptions): Promise<ContextBreakdown>;

package/packages/agent-trace-viewer/dist/breakdown.js

@@ -1,4 +1,4 @@
-import { estimateTokens } from "tokenfill";
+import { countTokens } from "tokenfill";
 const MATCHERS = [
     {
         id: "system-prompt",
@@ -44,15 +44,28 @@ const MATCHERS = [
         matches: () => true
     }
 ];
-export function computeContextBreakdown(trace) {
+const TURNS_PER_YIELD = 256;
+const ESTIMATOR_SAMPLE_TARGET_CHARS = 16_384;
+const ESTIMATOR_SAMPLE_CHARS_PER_TURN = 1_024;
+const ESTIMATOR_DEFAULT_CHARS_PER_TOKEN = 4;
+export async function computeContextBreakdown(trace, options = {}) {
+    const mode = options.mode ?? "exact";
+    const estimate = mode === "exact" ? undefined : createTraceTokenEstimator(trace.turns);
     const categories = MATCHERS.map((matcher) => ({
         id: matcher.id,
         label: matcher.label,
         tokens: 0,
         items: new Map()
     }));
-    for (const turn of trace.turns) {
-        const tokens = estimateTokens(turn.text);
+    for (let index = 0; index < trace.turns.length; index += 1) {
+        if (mode === "exact" && index > 0 && index % TURNS_PER_YIELD === 0) {
+            await yieldToEventLoop();
+            if (options.signal?.aborted) {
+                break;
+            }
+        }
+        const turn = trace.turns[index];
+        const tokens = estimate === undefined ? await countTokensYielding(turn.text) : estimate(turn.text);
         const matcherIndex = MATCHERS.findIndex((matcher) => matcher.matches(turn));
         const matcher = MATCHERS[matcherIndex];
         const category = categories[matcherIndex];
@@ -85,6 +98,42 @@ export function computeContextBreakdown(trace) {
     }));
     return {
         measuredTokens,
-        categories: outputCategories
+        categories: outputCategories,
+        source: mode
     };
 }
+function createTraceTokenEstimator(turns) {
+    const sampleParts = [];
+    let sampleLength = 0;
+    for (const turn of turns) {
+        if (sampleLength >= ESTIMATOR_SAMPLE_TARGET_CHARS) {
+            break;
+        }
+        const part = turn.text.slice(0, Math.min(ESTIMATOR_SAMPLE_CHARS_PER_TURN, ESTIMATOR_SAMPLE_TARGET_CHARS - sampleLength));
+        sampleParts.push(part);
+        sampleLength += part.length;
+    }
+    const sample = sampleParts.join("");
+    const sampleTokens = sample.length === 0 ? 0 : countTokens(sample);
+    const charsPerToken = sampleTokens === 0 ? ESTIMATOR_DEFAULT_CHARS_PER_TOKEN : sample.length / sampleTokens;
+    return (text) => Math.round(text.length / charsPerToken);
+}
+const COUNT_CHUNK_CHARS = 512 * 1024;
+async function countTokensYielding(text) {
+    if (text.length <= COUNT_CHUNK_CHARS) {
+        return countTokens(text);
+    }
+    let total = 0;
+    for (let index = 0; index < text.length; index += COUNT_CHUNK_CHARS) {
+        if (index > 0) {
+            await yieldToEventLoop();
+        }
+        total += countTokens(text.slice(index, index + COUNT_CHUNK_CHARS));
+    }
+    return total;
+}
+function yieldToEventLoop() {
+    return new Promise((resolve) => {
+        setImmediate(resolve);
+    });
+}

package/packages/agent-trace-viewer/dist/context.d.ts

@@ -5,4 +5,4 @@ export declare const CONTEXT_WINDOWS: {
     match: string;
     window: number;
 }[];
-export declare function computeContextUsage(trace: NormalizedTrace): ContextUsage;
+export declare function computeContextUsage(trace: NormalizedTrace, measuredTokens: number): ContextUsage;

package/packages/agent-trace-viewer/dist/context.js

@@ -1,11 +1,8 @@
-import { estimateTokens } from "tokenfill";
 export const DEFAULT_CONTEXT_WINDOW = 200000;
 export const CONTEXT_WINDOWS = [{ match: "claude", window: 200000 }];
-export function computeContextUsage(trace) {
+export function computeContextUsage(trace, measuredTokens) {
     const window = resolveContextWindow(trace);
-    const tokens = trace.usage !== undefined
-        ? trace.usage.contextTokens
-        : trace.turns.reduce((sum, turn) => sum + estimateTokens(turn.text), 0);
+    const tokens = trace.usage !== undefined ? trace.usage.contextTokens : measuredTokens;
     return {
         tokens,
         window,

package/packages/agent-trace-viewer/dist/loader.js

@@ -1,6 +1,7 @@
 import { traceReaders } from "@poe-code/agent-traces";
 import { computeContextBreakdown } from "./breakdown.js";
 import { computeContextUsage } from "./context.js";
+import { defaultTraceTokenCacheDir, readCachedBreakdown, traceFileIdentity, writeCachedBreakdown } from "./token-cache.js";
 export async function listTraces(options) {
     const readers = options.sources === undefined
         ? traceReaders
@@ -29,13 +30,55 @@ export async function loadTrace(reference, options) {
     if (reader === undefined) {
         throw new Error(`No trace reader registered for source: ${reference.source}`);
     }
+    const filePath = reference.path;
+    const identity = filePath === undefined ? undefined : await traceFileIdentity(options.fs, filePath);
     const trace = await reader.read(reference, { fs: options.fs });
+    const breakdown = await loadBreakdown(trace, filePath, identity, options);
     return {
         ...trace,
-        context: computeContextUsage(trace),
-        breakdown: computeContextBreakdown(trace)
+        context: computeContextUsage(trace, breakdown.measuredTokens),
+        breakdown
     };
 }
+const exactBreakdownsInFlight = new Map();
+async function loadBreakdown(trace, filePath, identity, options) {
+    const cacheDir = options.cacheDir ?? defaultTraceTokenCacheDir();
+    if (filePath !== undefined && identity !== undefined) {
+        const cached = await readCachedBreakdown(options.fs, cacheDir, filePath, identity);
+        if (cached !== undefined) {
+            return cached;
+        }
+    }
+    if (options.deferExactTokens === true) {
+        const estimated = await computeContextBreakdown(trace, { mode: "estimated" });
+        if (filePath !== undefined && identity !== undefined && options.signal?.aborted !== true) {
+            scheduleExactBreakdown(trace, filePath, identity, cacheDir, options);
+        }
+        return estimated;
+    }
+    const breakdown = await computeContextBreakdown(trace, { signal: options.signal });
+    if (filePath !== undefined && identity !== undefined && options.signal?.aborted !== true) {
+        await writeCachedBreakdown(options.fs, cacheDir, filePath, identity, breakdown);
+    }
+    return breakdown;
+}
+function scheduleExactBreakdown(trace, filePath, identity, cacheDir, options) {
+    if (exactBreakdownsInFlight.has(filePath)) {
+        return;
+    }
+    const task = (async () => {
+        const breakdown = await computeContextBreakdown(trace);
+        await writeCachedBreakdown(options.fs, cacheDir, filePath, identity, breakdown);
+        options.onExactBreakdown?.(breakdown);
+    })()
+        .catch(() => {
+        // Exact counting is best-effort in the background; the estimate stays visible.
+    })
+        .finally(() => {
+        exactBreakdownsInFlight.delete(filePath);
+    });
+    exactBreakdownsInFlight.set(filePath, task);
+}
 export async function loadSubagentSummaries(view, options) {
     if (view.children === undefined || view.children.length === 0) {
         return [];

package/packages/agent-trace-viewer/dist/render.d.ts

@@ -7,4 +7,7 @@ export declare function renderTraceLine(item: TraceReference): {
     meta: string;
 };
 export declare function renderSubagents(summaries: SubagentSummary[]): string;
-export declare function renderTraceDetail(view: TraceView, subagents?: SubagentSummary[]): string;
+export interface RenderTraceDetailOptions {
+    signal?: AbortSignal;
+}
+export declare function renderTraceDetail(view: TraceView, subagents?: SubagentSummary[], options?: RenderTraceDetailOptions): Promise<string>;

package/packages/agent-trace-viewer/dist/render.js

@@ -8,7 +8,7 @@ const MAX_TRACE_META_CWD_WIDTH = 18;
 const MAX_SUBAGENT_AGENT_WIDTH = 13;
 const MAX_SUBAGENT_DESCRIPTION_WIDTH = 26;
 const COLLAPSED_TURN_LINES = 3;
-const MAX_CONVERSATION_LINES = 48;
+const TURNS_PER_RENDER_YIELD = 256;
 const CATEGORY_ORDER = [
     "system-prompt",
     "skills",
@@ -58,11 +58,14 @@ export function renderBreakdown(breakdown, width = 32) {
         return "Context breakdown\n  No context tokens measured";
     }
     const theme = getTheme();
+    const title = breakdown.source === "estimated"
+        ? `Context breakdown ${theme.muted("(counting exact tokens…)")}`
+        : "Context breakdown";
     const bar = renderSegmentedBar(categories, normalizeGaugeWidth(width), theme);
     const labelWidth = Math.max(10, ...categories.map((category) => category.label.length));
     const tokenWidth = Math.max(1, ...categories.map((category) => formatCount(category.tokens).length));
     const percentWidth = Math.max(3, ...categories.map((category) => `${category.percent}%`.length));
-    const lines = ["Context breakdown", `  ${bar}`];
+    const lines = [title, `  ${bar}`];
     for (const category of categories) {
         const styler = categoryColor(category.id, theme);
         lines.push([
@@ -130,7 +133,7 @@ export function renderSubagents(summaries) {
     }
     return lines.join("\n");
 }
-export function renderTraceDetail(view, subagents = []) {
+export async function renderTraceDetail(view, subagents = [], options = {}) {
     const theme = getTheme();
     const lines = [
         theme.header(truncate(sanitizeInline(view.title?.trim() || view.id), MAX_RENDER_WIDTH)),
@@ -152,26 +155,24 @@ export function renderTraceDetail(view, subagents = []) {
     lines.push("", theme.header("Conversation"));
     if (view.turns.length === 0) {
         lines.push(`  ${theme.muted("No turns")}`);
+        return lines.join("\n");
     }
-    else {
-        const conversationLines = [];
-        let renderedTurns = 0;
-        for (const turn of view.turns) {
-            if (conversationLines.length >= MAX_CONVERSATION_LINES) {
+    for (let index = 0; index < view.turns.length; index += 1) {
+        if (index > 0 && index % TURNS_PER_RENDER_YIELD === 0) {
+            await yieldToEventLoop();
+            if (options.signal?.aborted) {
                 break;
             }
-            conversationLines.push(...renderTurn(turn, theme));
-            renderedTurns += 1;
-        }
-        lines.push(...conversationLines.slice(0, MAX_CONVERSATION_LINES));
-        const truncatedLastTurn = conversationLines.length > MAX_CONVERSATION_LINES;
-        const remaining = view.turns.length - renderedTurns + (truncatedLastTurn ? 1 : 0);
-        if (remaining > 0) {
-            lines.push(`  ${theme.muted(`… ${remaining} more turns`)}`);
         }
+        lines.push(...renderTurn(view.turns[index], theme));
     }
     return lines.join("\n");
 }
+function yieldToEventLoop() {
+    return new Promise((resolve) => {
+        setImmediate(resolve);
+    });
+}
 function renderBreakdownItems(items, minimumTokenWidth, theme) {
     const shown = items.slice(0, 5);
     const labels = shown.map((item) => truncate(item.name, 32));
@@ -247,14 +248,23 @@ function renderCompactContextGauge(context) {
 function renderTurn(turn, theme) {
     const renderer = ROLE_RENDERING[turn.role];
     const role = renderer.color(theme)(`${turn.role} ${renderer.glyph}`);
-    const sanitizedText = sanitizeTraceText(turn.text);
+    const shouldCollapse = turn.role === "tool" || turn.role === "system";
+    let sourceText = turn.text;
+    let collapsedLines = 0;
+    if (shouldCollapse) {
+        const cut = lineEndIndex(sourceText, COLLAPSED_TURN_LINES);
+        if (cut !== -1) {
+            collapsedLines = countNewlines(sourceText, cut);
+            sourceText = sourceText.slice(0, cut);
+        }
+    }
+    const sanitizedText = sanitizeTraceText(sourceText);
     const text = turn.role === "assistant"
         ? stripAnsi(renderMarkdown(sanitizedText)).trimEnd()
         : sanitizedText.trimEnd();
     const rawLines = text.length === 0 ? [""] : text.split("\n");
-    const shouldCollapse = turn.role === "tool" || turn.role === "system";
     const visibleLines = shouldCollapse ? rawLines.slice(0, COLLAPSED_TURN_LINES) : rawLines;
-    const remaining = rawLines.length - visibleLines.length;
+    const remaining = collapsedLines + rawLines.length - visibleLines.length;
     const prefix = `  ${role} `;
     const continuationPrefix = " ".repeat(plainLength(`  ${turn.role} ${renderer.glyph} `));
     const lines = [];
@@ -348,7 +358,41 @@ function padVisible(value, width) {
 function sanitizeInline(value) {
     return sanitizeTraceText(value).split("\n").join(" ");
 }
+function lineEndIndex(value, lineCount) {
+    let index = -1;
+    for (let line = 0; line < lineCount; line += 1) {
+        index = value.indexOf("\n", index + 1);
+        if (index === -1) {
+            return -1;
+        }
+    }
+    return index;
+}
+function countNewlines(value, from) {
+    let count = 0;
+    for (let index = from; index < value.length; index += 1) {
+        if (value.charCodeAt(index) === 10) {
+            count += 1;
+        }
+    }
+    return count;
+}
+function needsSanitize(value) {
+    for (let index = 0; index < value.length; index += 1) {
+        const code = value.charCodeAt(index);
+        if ((code < 32 && code !== 10) || code === 127) {
+            return true;
+        }
+    }
+    return false;
+}
 function sanitizeTraceText(value) {
+    if (!needsSanitize(value)) {
+        return value;
+    }
+    return sanitizeTraceTextSlow(value);
+}
+function sanitizeTraceTextSlow(value) {
     let result = "";
     let index = 0;
     while (index < value.length) {

package/packages/agent-trace-viewer/dist/run.js

@@ -12,7 +12,7 @@ export async function runTraceViewer(options) {
             writeLine(output, JSON.stringify({ ...view, subagents }, null, 2));
             return;
         }
-        writeLine(output, renderTraceDetail(view, subagents));
+        writeLine(output, await renderTraceDetail(view, subagents));
         return;
     }
     const discover = () => listTraces({
@@ -115,12 +115,17 @@ function buildTraceExplorerConfig(options) {
                     ctx.openModal({ title: ctx.row.title, content: cached });
                     return;
                 }
-                const view = await loadTrace(reference, { fs: options.fs });
+                const rowId = ctx.row.id;
+                const view = await loadTrace(reference, {
+                    fs: options.fs,
+                    deferExactTokens: true,
+                    onExactBreakdown: () => state.detailByRowId.delete(rowId)
+                });
                 const subagents = await loadSubagentSummariesIfPresent(view, options.fs);
                 const loaded = { view, subagents };
-                const content = renderTraceDetail(loaded.view, loaded.subagents);
-                state.detailByRowId.set(ctx.row.id, content);
-                state.childrenByRowId.set(ctx.row.id, loaded.view.children ?? []);
+                const content = await renderTraceDetail(loaded.view, loaded.subagents);
+                state.detailByRowId.set(rowId, content);
+                state.childrenByRowId.set(rowId, loaded.view.children ?? []);
                 ctx.openModal({ title: ctx.row.title, content });
             }
         },
@@ -177,8 +182,22 @@ function buildTraceExplorerConfig(options) {
         detail: {
             items: async (row, ctx) => {
                 const reference = getReference(state.referenceByRowId, row.id);
+                const cached = state.detailByRowId.get(row.id);
+                if (cached !== undefined) {
+                    return [
+                        {
+                            id: row.id,
+                            render: () => cached
+                        }
+                    ];
+                }
                 const loaded = await loadUnlessAborted(ctx.signal, async () => {
-                    const view = await loadTrace(reference, { fs: options.fs });
+                    const view = await loadTrace(reference, {
+                        fs: options.fs,
+                        signal: ctx.signal,
+                        deferExactTokens: true,
+                        onExactBreakdown: () => state.detailByRowId.delete(row.id)
+                    });
                     const subagents = await loadSubagentSummariesIfPresent(view, options.fs);
                     return { view, subagents };
                 });
@@ -186,7 +205,12 @@ function buildTraceExplorerConfig(options) {
                     return [];
                 }
                 state.childrenByRowId.set(row.id, loaded.view.children ?? []);
-                const content = renderTraceDetail(loaded.view, loaded.subagents);
+                const content = await renderTraceDetail(loaded.view, loaded.subagents, {
+                    signal: ctx.signal
+                });
+                if (ctx.signal.aborted) {
+                    return [];
+                }
                 state.detailByRowId.set(row.id, content);
                 return [
                     {

package/packages/agent-trace-viewer/dist/token-cache.d.ts

@@ -0,0 +1,10 @@
+import type { AgentTraceFileSystem } from "../../agent-traces/dist/index.js";
+import type { ContextBreakdown } from "./types.js";
+export interface TraceFileIdentity {
+    mtimeMs: number;
+    size: number;
+}
+export declare function defaultTraceTokenCacheDir(): string;
+export declare function traceFileIdentity(fs: AgentTraceFileSystem, filePath: string): Promise<TraceFileIdentity | undefined>;
+export declare function readCachedBreakdown(fs: AgentTraceFileSystem, cacheDir: string, filePath: string, identity: TraceFileIdentity): Promise<ContextBreakdown | undefined>;
+export declare function writeCachedBreakdown(fs: AgentTraceFileSystem, cacheDir: string, filePath: string, identity: TraceFileIdentity, breakdown: ContextBreakdown): Promise<void>;

package/packages/agent-trace-viewer/dist/token-cache.js

@@ -0,0 +1,56 @@
+import { createHash } from "node:crypto";
+import path from "node:path";
+import { resolveCacheDir } from "@poe-code/cached-resource";
+const CACHE_VERSION = 2;
+export function defaultTraceTokenCacheDir() {
+    return path.join(resolveCacheDir("poe-code"), "trace-tokens");
+}
+export async function traceFileIdentity(fs, filePath) {
+    try {
+        const stats = await fs.stat(filePath);
+        const mtimeMs = stats.mtime instanceof Date ? stats.mtime.getTime() : undefined;
+        if (mtimeMs === undefined || Number.isNaN(mtimeMs) || typeof stats.size !== "number") {
+            return undefined;
+        }
+        return { mtimeMs, size: stats.size };
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function readCachedBreakdown(fs, cacheDir, filePath, identity) {
+    let entry;
+    try {
+        entry = JSON.parse(await fs.readFile(cacheFilePath(cacheDir, filePath), "utf8"));
+    }
+    catch {
+        return undefined;
+    }
+    if (entry.version !== CACHE_VERSION ||
+        entry.mtimeMs !== identity.mtimeMs ||
+        entry.size !== identity.size ||
+        typeof entry.breakdown?.measuredTokens !== "number" ||
+        entry.breakdown.source !== "exact") {
+        return undefined;
+    }
+    return entry.breakdown;
+}
+export async function writeCachedBreakdown(fs, cacheDir, filePath, identity, breakdown) {
+    const entry = {
+        version: CACHE_VERSION,
+        mtimeMs: identity.mtimeMs,
+        size: identity.size,
+        breakdown
+    };
+    try {
+        await fs.mkdir(cacheDir, { recursive: true });
+        await fs.writeFile(cacheFilePath(cacheDir, filePath), JSON.stringify(entry));
+    }
+    catch {
+        // Token caching is best-effort; recomputing on the next view is always safe.
+    }
+}
+function cacheFilePath(cacheDir, filePath) {
+    const hash = createHash("sha256").update(filePath).digest("hex").slice(0, 32);
+    return path.join(cacheDir, `${hash}.json`);
+}

package/packages/agent-trace-viewer/dist/types.d.ts

@@ -11,6 +11,10 @@ export interface ListTracesOptions {
 }
 export interface LoadTraceOptions {
     fs: AgentTraceFileSystem;
+    signal?: AbortSignal;
+    cacheDir?: string;
+    deferExactTokens?: boolean;
+    onExactBreakdown?: (breakdown: ContextBreakdown) => void;
 }
 export interface ContextUsage {
     tokens: number;
@@ -33,6 +37,7 @@ export interface ContextBreakdownCategory {
 export interface ContextBreakdown {
     measuredTokens: number;
     categories: ContextBreakdownCategory[];
+    source: "exact" | "estimated";
 }
 export type TraceView = NormalizedTrace & {
     context: ContextUsage;

package/packages/agent-traces/dist/types.d.ts

@@ -12,6 +12,7 @@ export interface AgentTraceFileSystem {
         isFile(): boolean;
         isDirectory(): boolean;
         mtime?: Date;
+        size?: number;
     }>;
 }
 export interface SqliteTraceDatabase {

package/packages/tiny-http-mcp-server/dist/cli.js

@@ -7,11 +7,10 @@ import { loadOAuthVerifier } from "./load-oauth-verifier.js";
 function readPackageInfo() {
     try {
         const packageJson = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
-        if (typeof packageJson.name === "string" &&
-            typeof packageJson.version === "string") {
+        if (typeof packageJson.name === "string" && typeof packageJson.version === "string") {
             return {
                 name: packageJson.name,
-                version: packageJson.version,
+                version: packageJson.version
             };
         }
     }
@@ -20,7 +19,7 @@ function readPackageInfo() {
     }
     return {
         name: "tiny-http-mcp-server",
-        version: "0.0.0",
+        version: "0.0.0"
     };
 }
 const packageInfo = readPackageInfo();
@@ -45,6 +44,8 @@ const HELP_TEXT = [
     "                        Maximum concurrent GET SSE streams per session",
     "  --max-sse-event-history <count>",
     "                        Number of SSE events retained for Last-Event-ID replay",
+    "  --sse-keep-alive-ms <ms>",
+    "                        GET SSE keepalive interval (default: 30000; 0 disables)",
     "  --max-concurrent-tool-calls <count>",
     "                        Maximum concurrent tool calls across sessions",
     "  --trusted-proxy        Trust X-Forwarded-Proto and X-Forwarded-Host",
@@ -67,7 +68,7 @@ const HELP_TEXT = [
     "                        Module that exports the TokenVerifier implementation",
     "  --oauth-verifier-export <name>",
     "                        Export name to load from the verifier module (default: default)",
-    "  -h, --help             Show this help message",
+    "  -h, --help             Show this help message"
 ].join("\n");
 function parsePort(value) {
     if (value === undefined) {
@@ -126,7 +127,7 @@ function hasConfiguredOAuthFlag(values) {
         values["oauth-required-scope"],
         values["oauth-bearer-method"],
         values["oauth-verifier-module"],
-        values["oauth-verifier-export"],
+        values["oauth-verifier-export"]
     ].some((value) => value !== undefined);
 }
 function parseRepeatableStrings(value, flagName) {
@@ -174,9 +175,7 @@ function parseCliOAuthOptions(values) {
         ...(supportedScopes === undefined ? {} : { scopesSupported: supportedScopes }),
         ...(bearerMethods === undefined ? {} : { bearerMethodsSupported: bearerMethods }),
         verifierModule,
-        verifierExport: typeof verifierExport === "string" && verifierExport.length > 0
-            ? verifierExport
-            : "default",
+        verifierExport: typeof verifierExport === "string" && verifierExport.length > 0 ? verifierExport : "default"
     };
 }
 function parseCliOptions(args) {
@@ -198,6 +197,7 @@ function parseCliOptions(args) {
             "session-ttl-ms": { type: "string" },
             "max-streams-per-session": { type: "string" },
             "max-sse-event-history": { type: "string" },
+            "sse-keep-alive-ms": { type: "string" },
             "max-concurrent-tool-calls": { type: "string" },
             "trusted-proxy": { type: "boolean" },
             "request-timeout-ms": { type: "string" },
@@ -210,8 +210,8 @@ function parseCliOptions(args) {
             "oauth-bearer-method": { type: "string", multiple: true },
             "oauth-verifier-module": { type: "string" },
             "oauth-verifier-export": { type: "string" },
-            help: { type: "boolean", short: "h" },
-        },
+            help: { type: "boolean", short: "h" }
+        }
     });
     const maxRequestBytes = parseOptionalInteger(values["max-request-bytes"], "--max-request-bytes", 1);
     const maxBatchSize = parseOptionalInteger(values["max-batch-size"], "--max-batch-size", 1);
@@ -219,6 +219,7 @@ function parseCliOptions(args) {
     const sessionTtlMs = parseOptionalInteger(values["session-ttl-ms"], "--session-ttl-ms", 1);
     const maxStreamsPerSession = parseOptionalInteger(values["max-streams-per-session"], "--max-streams-per-session", 1);
     const maxSseEventHistory = parseOptionalInteger(values["max-sse-event-history"], "--max-sse-event-history", 0);
+    const sseKeepAliveMs = parseOptionalInteger(values["sse-keep-alive-ms"], "--sse-keep-alive-ms", 0);
     const maxConcurrentToolCalls = parseOptionalInteger(values["max-concurrent-tool-calls"], "--max-concurrent-tool-calls", 1);
     const requestTimeoutMs = parseOptionalInteger(values["request-timeout-ms"], "--request-timeout-ms", 0);
     const headersTimeoutMs = parseOptionalInteger(values["headers-timeout-ms"], "--headers-timeout-ms", 0);
@@ -235,7 +236,7 @@ function parseCliOptions(args) {
             : {}),
         ...(Array.isArray(values["allowed-origin"]) && values["allowed-origin"].length > 0
             ? {
-                allowedOrigins: values["allowed-origin"].map((value) => parseOrigin(value, "--allowed-origin")),
+                allowedOrigins: values["allowed-origin"].map((value) => parseOrigin(value, "--allowed-origin"))
             }
             : {}),
         ...(maxRequestBytes === undefined ? {} : { maxRequestBytes }),
@@ -244,12 +245,13 @@ function parseCliOptions(args) {
         ...(sessionTtlMs === undefined ? {} : { sessionTtlMs }),
         ...(maxStreamsPerSession === undefined ? {} : { maxStreamsPerSession }),
         ...(maxSseEventHistory === undefined ? {} : { maxSseEventHistory }),
+        ...(sseKeepAliveMs === undefined ? {} : { sseKeepAliveMs }),
         ...(maxConcurrentToolCalls === undefined ? {} : { maxConcurrentToolCalls }),
         trustedProxy: values["trusted-proxy"] ?? false,
         ...(requestTimeoutMs === undefined ? {} : { requestTimeoutMs }),
         ...(headersTimeoutMs === undefined ? {} : { headersTimeoutMs }),
         ...(keepAliveTimeoutMs === undefined ? {} : { keepAliveTimeoutMs }),
-        oauth: parseCliOAuthOptions(values),
+        oauth: parseCliOAuthOptions(values)
     };
 }
 function waitForShutdown(shutdown) {
@@ -306,8 +308,8 @@ export async function runCli(args = process.argv.slice(2), dependencies = {}) {
                     : {}),
                 verifier: await loadVerifier({
                     modulePath: options.oauth.verifierModule,
-                    exportName: options.oauth.verifierExport,
-                }),
+                    exportName: options.oauth.verifierExport
+                })
             };
         const server = createServer({
             name: packageInfo.name,
@@ -316,7 +318,9 @@ export async function runCli(args = process.argv.slice(2), dependencies = {}) {
             ...(options.jsonResponse ? { enableJsonResponse: true } : {}),
             ...(options.allowedHosts === undefined ? {} : { allowedHosts: options.allowedHosts }),
             ...(options.allowedOrigins === undefined ? {} : { allowedOrigins: options.allowedOrigins }),
-            ...(options.maxRequestBytes === undefined ? {} : { maxRequestBytes: options.maxRequestBytes }),
+            ...(options.maxRequestBytes === undefined
+                ? {}
+                : { maxRequestBytes: options.maxRequestBytes }),
             ...(options.maxBatchSize === undefined ? {} : { maxBatchSize: options.maxBatchSize }),
             ...(options.maxSessions === undefined ? {} : { maxSessions: options.maxSessions }),
             ...(options.sessionTtlMs === undefined ? {} : { sessionTtlMs: options.sessionTtlMs }),
@@ -326,11 +330,12 @@ export async function runCli(args = process.argv.slice(2), dependencies = {}) {
             ...(options.maxSseEventHistory === undefined
                 ? {}
                 : { maxSseEventHistory: options.maxSseEventHistory }),
+            ...(options.sseKeepAliveMs === undefined ? {} : { sseKeepAliveMs: options.sseKeepAliveMs }),
             ...(options.maxConcurrentToolCalls === undefined
                 ? {}
                 : { maxConcurrentToolCalls: options.maxConcurrentToolCalls }),
             ...(options.trustedProxy ? { trustedProxy: true } : {}),
-            ...(oauth === undefined ? {} : { oauth }),
+            ...(oauth === undefined ? {} : { oauth })
         });
         handle = await server.listenHttp({
             port: options.port,
@@ -344,7 +349,7 @@ export async function runCli(args = process.argv.slice(2), dependencies = {}) {
                 : { headersTimeoutMs: options.headersTimeoutMs }),
             ...(options.keepAliveTimeoutMs === undefined
                 ? {}
-                : { keepAliveTimeoutMs: options.keepAliveTimeoutMs }),
+                : { keepAliveTimeoutMs: options.keepAliveTimeoutMs })
         });
         const shutdown = async () => {
             await handle?.close();