copillm 0.1.5 → 0.2.0

package/dist/cli.js

@@ -16,7 +16,7 @@ import { acquireLock, inspectLock, LockAlreadyRunningError, releaseLock } from "
 import { startProxyServer } from "./server/proxy.js";
 import { defaultOutputDir, generateCodexHome } from "./codex/init.js";
 import { defaultOutputDir as defaultPiOutputDir, generatePiHome } from "./pi/init.js";
-import { getCopillmHome } from "./config/home.js";
+import { debugLogPath, getCopillmHome } from "./config/home.js";
 import { clearClaudeGatewayCache } from "./claude/cache.js";
 import { detectClaudeSettingsConflicts, formatSettingsConflictWarning } from "./claude/settingsConflict.js";
 import { buildClaudeExportCommand as buildClaudeExport, computeAnthropicDefaults, readModelIdsFromCache } from "./models/anthropicDefaults.js";
@@ -30,6 +30,7 @@ const logger = createLogger();
 const program = new Command();
 program.name("copillm").description("Local Copilot proxy").version("0.1.0");
 program.enablePositionalOptions();
+program.option("--debug", "Enable copillm debug mode (debug endpoint plus verbose daemon diagnostics)");
 program
     .command("login")
     .description("[deprecated] Use `copillm auth login`")
@@ -129,6 +130,8 @@ program
     .option("--no-pi", "Skip generating ~/.pi/agent/models.json for pi coding agent")
     .option("--json", "JSON output")
     .action(async (opts) => {
+    const debug = resolveCopillmDebug(opts.debug);
+    enableRuntimeDebug(debug);
     if (opts.detach) {
         // Fail fast on missing credentials rather than letting the detached
         // child die silently and surface as a generic "start timed out" error.
@@ -138,6 +141,7 @@ program
         }
         const existingLock = await readLiveLock();
         if (existingLock) {
+            const activeDebug = await warnIfDebugRequestedButInactive(debug, existingLock.port);
             const codex = opts.codex === false ? null : await refreshCodexHome(existingLock.port, opts.codexModel ?? null);
             const pi = opts.pi === false ? null : await refreshPiHome(existingLock.port);
             const claude = buildClaudeExportCommand(existingLock.port, null);
@@ -145,7 +149,8 @@ program
                 port: existingLock.port,
                 pid: existingLock.pid,
                 mode: "already_running",
-                debug: false,
+                debug: activeDebug,
+                debugLogPath: null,
                 codex,
                 pi
             });
@@ -153,6 +158,7 @@ program
                 status: "already_running",
                 pid: existingLock.pid,
                 port: existingLock.port,
+                debug: activeDebug,
                 url: `http://127.0.0.1:${existingLock.port}`,
                 codex_home: codex?.outDir ?? null,
                 codex_export_command: codex?.exportCommand ?? null,
@@ -169,12 +175,13 @@ program
             return;
         }
         const daemonArgs = [process.argv[1], "daemon"];
-        if (opts.debug) {
+        if (debug) {
             daemonArgs.push("--debug");
         }
         const child = spawn(process.execPath, daemonArgs, {
             detached: true,
-            stdio: "ignore"
+            stdio: "ignore",
+            env: daemonSpawnEnv(debug)
         });
         child.unref();
         const started = await waitForDaemonReady(child.pid ?? null, 8_000);
@@ -188,7 +195,8 @@ program
             port: started.port,
             pid: started.pid,
             mode: "detached",
-            debug: Boolean(opts.debug),
+            debug,
+            debugLogPath: currentDebugLogPath(debug),
             codex,
             pi
         });
@@ -197,7 +205,8 @@ program
             mode: "detached",
             pid: started.pid,
             port: started.port,
-            debug: Boolean(opts.debug),
+            debug,
+            debug_log_path: currentDebugLogPath(debug),
             url: `http://127.0.0.1:${started.port}`,
             codex_home: codex?.outDir ?? null,
             codex_export_command: codex?.exportCommand ?? null,
@@ -217,8 +226,9 @@ program
     }
     // Foreground path: interactively prompt for login if needed.
     await ensureAuthenticatedInteractive();
-    const started = await runDaemon({ debug: Boolean(opts.debug) });
+    const started = await runDaemon({ debug });
     if (started.kind === "already_running") {
+        const activeDebug = await warnIfDebugRequestedButInactive(debug, started.lock.port);
         const codex = opts.codex === false ? null : await refreshCodexHome(started.lock.port, opts.codexModel ?? null);
         const pi = opts.pi === false ? null : await refreshPiHome(started.lock.port);
         const claude = buildClaudeExportCommand(started.lock.port, null);
@@ -226,7 +236,8 @@ program
             port: started.lock.port,
             pid: started.lock.pid,
             mode: "already_running",
-            debug: false,
+            debug: activeDebug,
+            debugLogPath: null,
             codex,
             pi
         });
@@ -234,6 +245,7 @@ program
             status: "already_running",
             pid: started.lock.pid,
             port: started.lock.port,
+            debug: activeDebug,
             url: `http://127.0.0.1:${started.lock.port}`,
             codex_home: codex?.outDir ?? null,
             codex_export_command: codex?.exportCommand ?? null,
@@ -256,7 +268,8 @@ program
         port: started.port,
         pid: process.pid,
         mode: "foreground",
-        debug: Boolean(opts.debug),
+        debug,
+        debugLogPath: currentDebugLogPath(debug),
         codex,
         pi
     });
@@ -265,7 +278,8 @@ program
         mode: "foreground",
         pid: process.pid,
         port: started.port,
-        debug: Boolean(opts.debug),
+        debug,
+        debug_log_path: currentDebugLogPath(debug),
         url: `http://127.0.0.1:${started.port}`,
         caller_secret: started.callerSecret,
         codex_home: codex?.outDir ?? null,
@@ -288,11 +302,13 @@ program
     .description("Internal background command")
     .option("--debug", "Enable debug endpoints")
     .action(async (opts) => {
-    const started = await runDaemon({ debug: Boolean(opts.debug) });
+    const debug = resolveCopillmDebug(opts.debug);
+    enableRuntimeDebug(debug);
+    const started = await runDaemon({ debug });
     if (started.kind === "already_running") {
         process.exit(0);
     }
-    process.stdout.write(`copillm listening on http://127.0.0.1:${started.port}${opts.debug ? " [debug]" : ""}\n`);
+    process.stdout.write(`copillm listening on http://127.0.0.1:${started.port}${debug ? " [debug]" : ""}\n`);
 });
 program
     .command("stop")
@@ -655,7 +671,9 @@ program
     .helpOption(false)
     .argument("[args...]", "Args forwarded to codex")
     .action(async (forwardedArgs, opts) => {
-    const lock = await ensureDaemonRunningForLauncher({ debug: Boolean(opts.copillmDebug) });
+    const debug = resolveCopillmDebug(opts.copillmDebug);
+    enableRuntimeDebug(debug);
+    const lock = await ensureDaemonRunningForLauncher({ debug });
     const codex = await refreshCodexHome(lock.port, null);
     if (!codex) {
         throw new Error("Failed to prepare Codex home (see warning above).");
@@ -693,7 +711,9 @@ program
     .helpOption(false)
     .argument("[args...]", "Args forwarded to claude")
     .action(async (forwardedArgs, opts) => {
-    const lock = await ensureDaemonRunningForLauncher({ debug: Boolean(opts.copillmDebug) });
+    const debug = resolveCopillmDebug(opts.copillmDebug);
+    enableRuntimeDebug(debug);
+    const lock = await ensureDaemonRunningForLauncher({ debug });
     const claude = buildClaudeExportCommand(lock.port, null);
     const pinnedSpec = opts.copillmUse ?? process.env.COPILLM_CLAUDE_VERSION ?? undefined;
     const conflicts = detectClaudeSettingsConflicts(claude.bundle.env);
@@ -730,7 +750,9 @@ program
     .helpOption(false)
     .argument("[args...]", "Args forwarded to pi")
     .action(async (forwardedArgs, opts) => {
-    const lock = await ensureDaemonRunningForLauncher({ debug: Boolean(opts.copillmDebug) });
+    const debug = resolveCopillmDebug(opts.copillmDebug);
+    enableRuntimeDebug(debug);
+    const lock = await ensureDaemonRunningForLauncher({ debug });
     const pi = await refreshPiHome(lock.port);
     if (!pi) {
         throw new Error("Failed to prepare pi models.json (see warning above).");
@@ -985,6 +1007,32 @@ function writeCommandOutput(opts, humanLine, payload) {
     }
     process.stdout.write(`${humanLine}\n`);
 }
+function resolveCopillmDebug(commandDebug) {
+    return Boolean(commandDebug) || Boolean(program.opts().debug);
+}
+function enableRuntimeDebug(debug) {
+    if (!debug) {
+        return;
+    }
+    process.env.COPILLM_LOG_LEVEL = "debug";
+    logger.level = "debug";
+}
+function currentDebugLogPath(debug) {
+    if (!debug) {
+        return null;
+    }
+    return process.env.COPILLM_LOG_FILE ?? debugLogPath();
+}
+function daemonSpawnEnv(debug) {
+    if (!debug) {
+        return process.env;
+    }
+    return {
+        ...process.env,
+        COPILLM_LOG_LEVEL: "debug",
+        COPILLM_LOG_FILE: currentDebugLogPath(true) ?? debugLogPath()
+    };
+}
 function formatStopHumanLine(primary, cache) {
     if (cache.cleared) {
         return `${primary} Cleared Claude Code gateway cache.`;
@@ -1057,6 +1105,9 @@ function formatStartBanner(input) {
     if (input.codex) {
         lines.push(`   ${input.codex.modelCount} Copilot models discovered \u00B7 default: ${input.codex.defaultModel}`);
     }
+    if (input.debugLogPath) {
+        lines.push(`   debug log: ${displayHomePath(input.debugLogPath)}`);
+    }
     if (input.pi) {
         lines.push(`   pi: wrote ${input.pi.modelCount} models to ${displayHomePath(input.pi.configPath)}${input.pi.backupPath ? ` (backed up prior config to ${displayHomePath(input.pi.backupPath)})` : ""}`);
     }
@@ -1096,6 +1147,25 @@ async function probeLivez(port) {
         return false;
     }
 }
+async function warnIfDebugRequestedButInactive(debugRequested, port) {
+    if (!debugRequested) {
+        return false;
+    }
+    const active = await probeDebugEndpoint(port);
+    if (!active) {
+        process.stderr.write(`warning: copillm is already running without debug mode; run \`copillm stop\` then \`copillm --debug start --detach\` to enable daemon diagnostics.\n`);
+    }
+    return active;
+}
+async function probeDebugEndpoint(port) {
+    try {
+        const response = await fetch(`http://127.0.0.1:${port}/_debug`, { signal: AbortSignal.timeout(1_200) });
+        return response.ok;
+    }
+    catch {
+        return false;
+    }
+}
 async function probeHealth(port) {
     try {
         const response = await fetch(`http://127.0.0.1:${port}/healthz`, { signal: AbortSignal.timeout(1_500) });
@@ -1200,15 +1270,21 @@ function parseAgentName(raw) {
 }
 async function ensureDaemonRunningForLauncher(opts) {
     const live = await readLiveLock();
-    if (live)
+    if (live) {
+        await warnIfDebugRequestedButInactive(opts.debug, live.port);
         return live;
-    process.stderr.write(`Starting copillm in background...\n`);
+    }
+    const debugLog = currentDebugLogPath(opts.debug);
+    process.stderr.write(opts.debug && debugLog
+        ? `Starting copillm in background with debug logging at ${displayHomePath(debugLog)}...\n`
+        : `Starting copillm in background...\n`);
     const daemonArgs = [process.argv[1], "daemon"];
     if (opts.debug)
         daemonArgs.push("--debug");
     const child = spawn(process.execPath, daemonArgs, {
         detached: true,
-        stdio: "ignore"
+        stdio: "ignore",
+        env: daemonSpawnEnv(opts.debug)
     });
     child.unref();
     const started = await waitForDaemonReady(child.pid ?? null, 10_000);

package/dist/config/home.js

@@ -32,6 +32,9 @@ export function modelsCachePath() {
 export function modelsCacheReadPath() {
     return resolveReadablePath("models.cache.json");
 }
+export function debugLogPath() {
+    return path.join(getCopillmHome(), "debug.log");
+}
 function resolveReadablePath(fileName) {
     const canonical = path.join(getCopillmHome(), fileName);
     if (fs.existsSync(canonical)) {

package/dist/config/logging.js

@@ -1,7 +1,11 @@
 import pino from "pino";
-export function createLogger() {
-    return pino({
-        level: process.env.COPILLM_LOG_LEVEL ?? "info",
+import fs from "node:fs";
+import path from "node:path";
+import { applyModeIfSupported } from "./fsSecurity.js";
+export function createLogger(input) {
+    const destinationPath = input?.destinationPath ?? process.env.COPILLM_LOG_FILE;
+    const options = {
+        level: input?.level ?? process.env.COPILLM_LOG_LEVEL ?? "info",
         redact: {
             paths: [
                 "req.headers.authorization",
@@ -27,7 +31,25 @@ export function createLogger() {
             remove: true
         },
         transport: process.env.COPILLM_LOG_PRETTY === "1"
-            ? { target: "pino-pretty", options: { colorize: true } }
+            ? { target: "pino-pretty", options: { colorize: destinationPath ? false : true, destination: destinationPath ?? 2 } }
             : undefined
-    });
+    };
+    if (process.env.COPILLM_LOG_PRETTY === "1") {
+        if (destinationPath) {
+            prepareLogFile(destinationPath);
+        }
+        return pino(options);
+    }
+    if (destinationPath) {
+        prepareLogFile(destinationPath);
+        return pino(options, pino.destination(destinationPath));
+    }
+    return pino(options, pino.destination(2));
+}
+function prepareLogFile(filePath) {
+    const resolvedPath = path.resolve(filePath);
+    fs.mkdirSync(path.dirname(resolvedPath), { recursive: true, mode: 0o700 });
+    const fd = fs.openSync(resolvedPath, "a", 0o600);
+    fs.closeSync(fd);
+    applyModeIfSupported(resolvedPath, 0o600);
 }

package/dist/models/anthropicDefaults.js

@@ -8,6 +8,7 @@ const SUFFIX_BLOCKLIST = [
     "-low",
     "-min",
     "-1m",
+    "[1m]",
     "-internal",
     "-preview",
     "-beta",

package/dist/server/proxy.js

@@ -150,6 +150,7 @@ export async function startProxyServer(input) {
                 }
                 await handleDebug(res, {
                     config: input.config,
+                    logger: input.logger,
                     tokenManager: input.tokenManager,
                     githubToken: input.githubToken,
                     port: input.port
@@ -194,6 +195,17 @@ export async function startProxyServer(input) {
                 beginAnthropicSseResponse(res, req);
                 prelude = writeAnthropicPrelude(res, requestedModel ?? "");
             }
+            input.logger.debug({
+                event: "request_prepared",
+                request_id: requestId,
+                route: route.kind,
+                anthro_shape: route.anthroShape,
+                requested_model: requestedModel,
+                upstream_model: readRequestedModel(upstreamBody),
+                model_resolution_rule: resolvedModel?.rule ?? null,
+                upstream_path: upstreamPath,
+                ...summarizeUpstreamPayload(upstreamBody)
+            }, "prepared upstream request");
             try {
                 const upstream = await postToCopilot({
                     tokenManager: input.tokenManager,
@@ -204,7 +216,12 @@ export async function startProxyServer(input) {
                     upstreamPath,
                     signal: lifecycle.signal
                 });
-                await forwardResponse(upstream, route.anthroShape, res, requestedModel ?? undefined, prelude);
+                await forwardResponse(upstream, route.anthroShape, res, {
+                    requestedModel: requestedModel ?? undefined,
+                    prelude,
+                    logger: input.logger,
+                    requestId
+                });
             }
             catch (error) {
                 if (isBenignSocketError(error)) {
@@ -291,7 +308,25 @@ async function postToCopilot(input) {
             throw abortErrorFromSignal(input.signal);
         }
         try {
+            const attemptStartedAt = Date.now();
+            input.logger.debug({
+                event: "upstream_request",
+                request_id: input.requestId,
+                attempt,
+                upstream_path: input.upstreamPath,
+                force_refresh: forceRefresh
+            }, "posting upstream request");
             const response = await postWithCurrentBearer(input.tokenManager, input.accountType, input.body, forceRefresh, input.requestId, input.upstreamPath, input.signal);
+            input.logger.debug({
+                event: "upstream_response",
+                request_id: input.requestId,
+                attempt,
+                upstream_path: input.upstreamPath,
+                status_code: response.status,
+                duration_ms: Date.now() - attemptStartedAt,
+                content_type: response.headers.get("content-type"),
+                retry_after: response.headers.get("retry-after")
+            }, "received upstream response");
             forceRefresh = false;
             if (response.status === 401 && !authRefreshRetried && attempt < MAX_UPSTREAM_ATTEMPTS) {
                 authRefreshRetried = true;
@@ -344,43 +379,57 @@ function abortErrorFromSignal(signal) {
     err.name = "AbortError";
     return err;
 }
-async function forwardResponse(upstream, anthroShape, res, requestedModel, prelude) {
+async function forwardResponse(upstream, anthroShape, res, diagnostics) {
     if (!upstream.ok) {
-        await discardUpstreamBody(upstream);
+        const upstreamError = await readUpstreamError(upstream);
+        const category = upstreamStatusCategory(upstream.status);
+        diagnostics.logger.warn({
+            event: "upstream_non_ok",
+            request_id: diagnostics.requestId,
+            status_code: upstream.status,
+            error: category,
+            upstream_content_type: upstreamError.contentType,
+            upstream_error_code: upstreamError.code,
+            upstream_error_type: upstreamError.type,
+            upstream_error_message: upstreamError.message,
+            upstream_response_bytes: upstreamError.responseBytes
+        }, "upstream request failed");
+        const message = formatUpstreamErrorMessage(category, upstreamError);
+        const prelude = diagnostics.prelude ?? null;
         if (prelude) {
-            writeAnthropicSseError(res, prelude, upstreamStatusCategory(upstream.status));
+            writeAnthropicSseError(res, prelude, message);
             return;
         }
-        sendJson(res, upstream.status, { error: upstreamStatusCategory(upstream.status) });
+        sendJson(res, upstream.status, buildUpstreamErrorPayload(category, upstream.status, diagnostics.requestId, upstreamError, anthroShape));
         return;
     }
     if (isEventStream(upstream)) {
         if (anthroShape) {
             if (!upstream.body) {
-                if (prelude) {
-                    writeAnthropicSseError(res, prelude, "invalid_upstream_response");
+                if (diagnostics.prelude) {
+                    writeAnthropicSseError(res, diagnostics.prelude, "invalid_upstream_response");
                     return;
                 }
                 sendJson(res, 502, { error: "invalid_upstream_response", detail: "Upstream stream body is missing." });
                 return;
             }
-            if (!prelude) {
+            if (!diagnostics.prelude) {
                 beginAnthropicSseResponse(res);
             }
             const upstreamReadable = Readable.fromWeb(upstream.body);
             await translateOpenAIStreamToAnthropic({
                 upstream: upstreamReadable,
                 downstream: res,
-                fallbackModel: requestedModel,
-                preEmittedMessageId: prelude?.messageId
+                fallbackModel: diagnostics.requestedModel,
+                preEmittedMessageId: diagnostics.prelude?.messageId
             });
             return;
         }
         await pipeEventStream(upstream, res);
         return;
     }
-    if (prelude) {
-        writeAnthropicSseError(res, prelude, "invalid_upstream_response");
+    if (diagnostics.prelude) {
+        writeAnthropicSseError(res, diagnostics.prelude, "invalid_upstream_response");
         return;
     }
     let json;
@@ -604,7 +653,9 @@ async function handleDebug(res, input) {
             uptime_seconds: uptimeSeconds,
             account_type: input.config.accountType,
             selected_models: input.config.selectedModels,
-            require_caller_secret: input.config.requireCallerSecret
+            require_caller_secret: input.config.requireCallerSecret,
+            log_level: input.logger.level,
+            log_file: process.env.COPILLM_LOG_FILE ?? null
         },
         auth: {
             bearer_ttl_seconds: bearerTtlSeconds,
@@ -712,6 +763,165 @@ function upstreamStatusCategory(status) {
     }
     return "upstream_error";
 }
+async function readUpstreamError(response) {
+    const contentType = response.headers.get("content-type");
+    let text;
+    try {
+        text = await response.text();
+    }
+    catch {
+        return { contentType, code: null, type: null, message: null, responseBytes: null };
+    }
+    const trimmed = text.trim();
+    const responseBytes = Buffer.byteLength(text, "utf8");
+    if (trimmed.length === 0) {
+        return { contentType, code: null, type: null, message: null, responseBytes };
+    }
+    try {
+        const parsed = JSON.parse(trimmed);
+        const extracted = extractErrorFields(parsed);
+        if (extracted.message || extracted.code || extracted.type) {
+            return { contentType, responseBytes, ...extracted };
+        }
+    }
+    catch {
+        // Fall through to a plain-text snippet below.
+    }
+    return {
+        contentType,
+        code: null,
+        type: null,
+        message: truncateForDiagnostics(trimmed),
+        responseBytes
+    };
+}
+function extractErrorFields(payload) {
+    if (!payload || typeof payload !== "object") {
+        return { code: null, type: null, message: typeof payload === "string" ? truncateForDiagnostics(payload) : null };
+    }
+    const record = payload;
+    const nested = record.error;
+    if (typeof nested === "string") {
+        return {
+            code: readStringField(record, "code"),
+            type: readStringField(record, "type"),
+            message: truncateForDiagnostics(nested)
+        };
+    }
+    if (nested && typeof nested === "object") {
+        const errorRecord = nested;
+        return {
+            code: readStringField(errorRecord, "code") ?? readStringField(record, "code"),
+            type: readStringField(errorRecord, "type") ?? readStringField(record, "type"),
+            message: readTruncatedStringField(errorRecord, "message") ??
+                readTruncatedStringField(errorRecord, "detail") ??
+                readTruncatedStringField(record, "message") ??
+                readTruncatedStringField(record, "detail")
+        };
+    }
+    return {
+        code: readStringField(record, "code"),
+        type: readStringField(record, "type"),
+        message: readTruncatedStringField(record, "message") ?? readTruncatedStringField(record, "detail")
+    };
+}
+function buildUpstreamErrorPayload(category, statusCode, requestId, upstreamError, anthroShape) {
+    const code = upstreamError.code ?? category;
+    const type = upstreamError.type ?? category;
+    const message = formatUserFacingUpstreamErrorMessage(category, upstreamError);
+    if (anthroShape) {
+        return {
+            type: "error",
+            error: {
+                type,
+                message,
+                code,
+                upstream_status_code: statusCode,
+                request_id: requestId
+            }
+        };
+    }
+    return {
+        error: {
+            type,
+            code,
+            message,
+            upstream_status_code: statusCode,
+            request_id: requestId
+        }
+    };
+}
+function formatUpstreamErrorMessage(category, upstreamError) {
+    const parts = [upstreamError.code, upstreamError.type, upstreamError.message].filter((part) => typeof part === "string" && part.length > 0);
+    return parts.length > 0 ? `${category}: ${parts.join(": ")}` : category;
+}
+function formatUserFacingUpstreamErrorMessage(category, upstreamError) {
+    if (upstreamError.code && upstreamError.message) {
+        return `${upstreamError.code}: ${upstreamError.message}`;
+    }
+    if (upstreamError.message) {
+        return upstreamError.message;
+    }
+    return upstreamError.code ?? upstreamError.type ?? category;
+}
+function readStringField(record, key) {
+    const value = record[key];
+    return typeof value === "string" && value.length > 0 ? value : null;
+}
+function readTruncatedStringField(record, key) {
+    const value = readStringField(record, key);
+    return value ? truncateForDiagnostics(value) : null;
+}
+function truncateForDiagnostics(value) {
+    const maxChars = 500;
+    return value.length > maxChars ? `${value.slice(0, maxChars)}...` : value;
+}
+function summarizeUpstreamPayload(payload) {
+    let requestBytes = null;
+    try {
+        requestBytes = Buffer.byteLength(JSON.stringify(payload), "utf8");
+    }
+    catch {
+        requestBytes = null;
+    }
+    if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+        return { upstream_request_bytes: requestBytes };
+    }
+    const record = payload;
+    const messages = Array.isArray(record.messages) ? record.messages : null;
+    const input = Array.isArray(record.input) ? record.input : null;
+    return {
+        upstream_request_bytes: requestBytes,
+        stream: record.stream === true,
+        max_tokens: typeof record.max_tokens === "number" ? record.max_tokens : null,
+        message_count: messages?.length ?? null,
+        input_item_count: input?.length ?? null,
+        tool_count: Array.isArray(record.tools) ? record.tools.length : 0,
+        text_characters: sumTextCharacters(payload)
+    };
+}
+function sumTextCharacters(value) {
+    if (typeof value === "string") {
+        return value.length;
+    }
+    if (!value || typeof value !== "object") {
+        return 0;
+    }
+    if (Array.isArray(value)) {
+        return value.reduce((total, item) => total + sumTextCharacters(item), 0);
+    }
+    let total = 0;
+    const record = value;
+    for (const [key, nested] of Object.entries(record)) {
+        if (key === "text" || key === "content" || key === "arguments" || key === "input") {
+            total += sumTextCharacters(nested);
+        }
+        else if (nested && typeof nested === "object" && key !== "data" && key !== "image_url" && key !== "source") {
+            total += sumTextCharacters(nested);
+        }
+    }
+    return total;
+}
 function healthFailure(error) {
     if (error instanceof CopilotTokenExchangeError) {
         if (error.statusCode === 401 || error.statusCode === 403) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "copillm",
-  "version": "0.1.5",
+  "version": "0.2.0",
   "description": "Local Copilot proxy CLI (OpenAI/Anthropic-compatible)",
   "license": "MIT",
   "type": "module",