@messenger-agent/claude-agent 0.24.0-alpha.2

package/dist/schemas.d.ts

@@ -0,0 +1,188 @@
+import { z } from "zod";
+export declare const ChatTextPartSchema: z.ZodObject<{
+    type: z.ZodLiteral<"text">;
+    text: z.ZodString;
+}, z.core.$strip>;
+export declare const ChatFilePartSchema: z.ZodObject<{
+    type: z.ZodLiteral<"file">;
+    mediaType: z.ZodString;
+    filename: z.ZodOptional<z.ZodString>;
+    url: z.ZodString;
+}, z.core.$strip>;
+export declare const ChatStepStartPartSchema: z.ZodObject<{
+    type: z.ZodLiteral<"step-start">;
+}, z.core.$strip>;
+export declare const ChatToolPartSchema: z.ZodObject<{
+    type: z.ZodLiteral<"tool">;
+    toolCallId: z.ZodString;
+    toolName: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    state: z.ZodString;
+    input: z.ZodOptional<z.ZodUnknown>;
+    output: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>;
+export declare const ClaudeAskUserQuestionOutputSchema: z.ZodObject<{
+    answers: z.ZodRecord<z.ZodString, z.ZodString>;
+}, z.core.$strip>;
+export declare const AskUserQuestionToolPartSchema: z.ZodObject<{
+    type: z.ZodLiteral<"tool">;
+    toolCallId: z.ZodString;
+    toolName: z.ZodEnum<{
+        AskUserQuestion: "AskUserQuestion";
+        ask_user_question: "ask_user_question";
+    }>;
+    state: z.ZodLiteral<"output-available">;
+    output: z.ZodObject<{
+        answers: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const ExitPlanModeToolPartSchema: z.ZodObject<{
+    type: z.ZodLiteral<"tool">;
+    toolCallId: z.ZodString;
+    toolName: z.ZodEnum<{
+        ExitPlanMode: "ExitPlanMode";
+        exit_plan_mode: "exit_plan_mode";
+    }>;
+    state: z.ZodLiteral<"output-available">;
+    output: z.ZodUnknown;
+}, z.core.$strip>;
+export declare const ToolApprovalSchema: z.ZodObject<{
+    id: z.ZodString;
+    approved: z.ZodBoolean;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const ToolApprovalPartSchema: z.ZodObject<{
+    type: z.ZodLiteral<"tool">;
+    toolCallId: z.ZodString;
+    toolName: z.ZodString;
+    state: z.ZodLiteral<"approval-responded">;
+    input: z.ZodOptional<z.ZodUnknown>;
+    approval: z.ZodObject<{
+        id: z.ZodString;
+        approved: z.ZodBoolean;
+        reason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const AgentAnswerToolPartSchema: z.ZodUnion<readonly [z.ZodObject<{
+    type: z.ZodLiteral<"tool">;
+    toolCallId: z.ZodString;
+    toolName: z.ZodEnum<{
+        AskUserQuestion: "AskUserQuestion";
+        ask_user_question: "ask_user_question";
+    }>;
+    state: z.ZodLiteral<"output-available">;
+    output: z.ZodObject<{
+        answers: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"tool">;
+    toolCallId: z.ZodString;
+    toolName: z.ZodEnum<{
+        ExitPlanMode: "ExitPlanMode";
+        exit_plan_mode: "exit_plan_mode";
+    }>;
+    state: z.ZodLiteral<"output-available">;
+    output: z.ZodUnknown;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"tool">;
+    toolCallId: z.ZodString;
+    toolName: z.ZodString;
+    state: z.ZodLiteral<"approval-responded">;
+    input: z.ZodOptional<z.ZodUnknown>;
+    approval: z.ZodObject<{
+        id: z.ZodString;
+        approved: z.ZodBoolean;
+        reason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>]>;
+export declare const ChatCustomPartSchema: z.ZodObject<{
+    type: z.ZodString;
+}, z.core.$loose>;
+export declare const CodexChatForkSchema: z.ZodObject<{
+    threadId: z.ZodString;
+    turnId: z.ZodString;
+}, z.core.$strict>;
+export declare const ClaudeChatForkSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+    messageId: z.ZodString;
+}, z.core.$strict>;
+export declare const ChatForkSchema: z.ZodUnion<readonly [z.ZodObject<{
+    threadId: z.ZodString;
+    turnId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    sessionId: z.ZodString;
+    messageId: z.ZodString;
+}, z.core.$strict>]>;
+export declare const ChatBodySchema: z.ZodObject<{
+    conversationId: z.ZodOptional<z.ZodString>;
+    fork: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        threadId: z.ZodString;
+        turnId: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        sessionId: z.ZodString;
+        messageId: z.ZodString;
+    }, z.core.$strict>]>>;
+    model: z.ZodString;
+    message: z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        role: z.ZodOptional<z.ZodEnum<{
+            user: "user";
+            assistant: "assistant";
+        }>>;
+        parts: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            type: z.ZodLiteral<"text">;
+            text: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"file">;
+            mediaType: z.ZodString;
+            filename: z.ZodOptional<z.ZodString>;
+            url: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"step-start">;
+        }, z.core.$strip>, z.ZodUnion<readonly [z.ZodObject<{
+            type: z.ZodLiteral<"tool">;
+            toolCallId: z.ZodString;
+            toolName: z.ZodEnum<{
+                AskUserQuestion: "AskUserQuestion";
+                ask_user_question: "ask_user_question";
+            }>;
+            state: z.ZodLiteral<"output-available">;
+            output: z.ZodObject<{
+                answers: z.ZodRecord<z.ZodString, z.ZodString>;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"tool">;
+            toolCallId: z.ZodString;
+            toolName: z.ZodEnum<{
+                ExitPlanMode: "ExitPlanMode";
+                exit_plan_mode: "exit_plan_mode";
+            }>;
+            state: z.ZodLiteral<"output-available">;
+            output: z.ZodUnknown;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"tool">;
+            toolCallId: z.ZodString;
+            toolName: z.ZodString;
+            state: z.ZodLiteral<"approval-responded">;
+            input: z.ZodOptional<z.ZodUnknown>;
+            approval: z.ZodObject<{
+                id: z.ZodString;
+                approved: z.ZodBoolean;
+                reason: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+        }, z.core.$strip>]>, z.ZodObject<{
+            type: z.ZodLiteral<"tool">;
+            toolCallId: z.ZodString;
+            toolName: z.ZodString;
+            title: z.ZodOptional<z.ZodString>;
+            state: z.ZodString;
+            input: z.ZodOptional<z.ZodUnknown>;
+            output: z.ZodOptional<z.ZodUnknown>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodString;
+        }, z.core.$loose>]>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type ChatBody = z.infer<typeof ChatBodySchema>;
+export type ChatMessagePart = ChatBody["message"]["parts"][number];
+export type AgentAnswerToolPart = z.infer<typeof AgentAnswerToolPartSchema>;

package/dist/schemas.js

@@ -0,0 +1,89 @@
+import { z } from "zod";
+export const ChatTextPartSchema = z.object({
+    type: z.literal("text"),
+    text: z.string(),
+});
+export const ChatFilePartSchema = z.object({
+    type: z.literal("file"),
+    mediaType: z.string(),
+    filename: z.string().optional(),
+    url: z.string(),
+});
+export const ChatStepStartPartSchema = z.object({
+    type: z.literal("step-start"),
+});
+export const ChatToolPartSchema = z.object({
+    type: z.literal("tool"),
+    toolCallId: z.string(),
+    toolName: z.string(),
+    title: z.string().optional(),
+    state: z.string(),
+    input: z.unknown().optional(),
+    output: z.unknown().optional(),
+});
+export const ClaudeAskUserQuestionOutputSchema = z.object({
+    answers: z.record(z.string(), z.string()),
+});
+export const AskUserQuestionToolPartSchema = z.object({
+    type: z.literal("tool"),
+    toolCallId: z.string(),
+    // Accept the camelCase SDK tool names (now passed through downstream) plus the
+    // legacy snake_case aliases for backward compatibility.
+    toolName: z.enum(["AskUserQuestion", "ask_user_question"]),
+    state: z.literal("output-available"),
+    output: ClaudeAskUserQuestionOutputSchema,
+});
+export const ExitPlanModeToolPartSchema = z.object({
+    type: z.literal("tool"),
+    toolCallId: z.string(),
+    toolName: z.enum(["ExitPlanMode", "exit_plan_mode"]),
+    state: z.literal("output-available"),
+    output: z.unknown(),
+});
+export const ToolApprovalSchema = z.object({
+    id: z.string(),
+    approved: z.boolean(),
+    reason: z.string().optional(),
+});
+export const ToolApprovalPartSchema = z.object({
+    type: z.literal("tool"),
+    toolCallId: z.string(),
+    toolName: z.string(),
+    state: z.literal("approval-responded"),
+    input: z.unknown().optional(),
+    approval: ToolApprovalSchema,
+});
+export const AgentAnswerToolPartSchema = z.union([
+    AskUserQuestionToolPartSchema,
+    ExitPlanModeToolPartSchema,
+    ToolApprovalPartSchema,
+]);
+export const ChatCustomPartSchema = z.looseObject({
+    type: z.string(),
+});
+export const CodexChatForkSchema = z.strictObject({
+    threadId: z.string().min(1),
+    turnId: z.string().min(1),
+});
+export const ClaudeChatForkSchema = z.strictObject({
+    sessionId: z.string().min(1),
+    messageId: z.string().min(1),
+});
+export const ChatForkSchema = z.union([CodexChatForkSchema, ClaudeChatForkSchema]);
+export const ChatBodySchema = z.object({
+    conversationId: z.string().optional(),
+    fork: ChatForkSchema.optional(),
+    model: z.string(),
+    message: z.object({
+        id: z.string().optional(),
+        role: z.enum(["user", "assistant"]).optional(),
+        parts: z.array(z.union([
+            ChatTextPartSchema,
+            ChatFilePartSchema,
+            ChatStepStartPartSchema,
+            AgentAnswerToolPartSchema,
+            ChatToolPartSchema,
+            ChatCustomPartSchema,
+        ])),
+    }),
+});

package/dist/session-manager.d.ts

@@ -0,0 +1,14 @@
+import { LiveSession, type LiveSessionInit } from "./live-session.js";
+export type CreateSessionParams = Omit<LiveSessionInit, "idleTimeoutMs" | "onRecycle">;
+export declare class SessionManager {
+    private readonly idleTimeoutMs;
+    private readonly sessions;
+    constructor(idleTimeoutMs: () => number);
+    get(conversationId: string | undefined): LiveSession | undefined;
+    create(params: CreateSessionParams): LiveSession;
+    bind(session: LiveSession, conversationId: string): void;
+    cancel(conversationId: string): boolean;
+    get size(): number;
+    private recycle;
+    private removeByValue;
+}

package/dist/session-manager.js

@@ -0,0 +1,57 @@
+import { LiveSession } from "./live-session.js";
+export class SessionManager {
+    idleTimeoutMs;
+    sessions = new Map();
+    constructor(idleTimeoutMs) {
+        this.idleTimeoutMs = idleTimeoutMs;
+    }
+    get(conversationId) {
+        if (!conversationId)
+            return undefined;
+        const session = this.sessions.get(conversationId);
+        if (session?.isDead) {
+            this.removeByValue(session);
+            return undefined;
+        }
+        return session;
+    }
+    create(params) {
+        const session = new LiveSession({
+            ...params,
+            idleTimeoutMs: this.idleTimeoutMs(),
+            onRecycle: (candidate, generation) => this.recycle(candidate, generation),
+        });
+        this.sessions.set(params.conversationId, session);
+        return session;
+    }
+    bind(session, conversationId) {
+        if (session.isDead)
+            return;
+        const previousId = session.conversationId;
+        session.bindConversation(conversationId);
+        this.sessions.set(conversationId, session);
+        if (previousId !== conversationId && this.sessions.get(previousId) === session)
+            this.sessions.delete(previousId);
+    }
+    cancel(conversationId) {
+        const session = this.get(conversationId);
+        if (!session)
+            return false;
+        session.abort();
+        return true;
+    }
+    get size() {
+        return new Set(this.sessions.values()).size;
+    }
+    recycle(session, generation) {
+        if (!session.isDead || generation !== session.currentGeneration)
+            return;
+        this.removeByValue(session);
+    }
+    removeByValue(session) {
+        for (const [key, candidate] of this.sessions) {
+            if (candidate === session)
+                this.sessions.delete(key);
+        }
+    }
+}

package/dist/task-aggregator.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Aggregates Claude Code's incremental task tools (TaskCreate / TaskUpdate /
+ * TaskList / TaskGet / TaskStop / TaskOutput) into a single todo list that is
+ * compatible with the legacy `TodoWrite` event shape consumed downstream:
+ *
+ *   { todos: [{ content, status, activeForm? }] }
+ *
+ * Claude Code replaced the old all-at-once `TodoWrite` tool with a set of
+ * incremental CRUD tools that persist each task as a JSON file under
+ * `<claude config dir>/tasks/<session_id>/<N>.json` (N starts at 1):
+ *
+ *   {
+ *     "id": "1",
+ *     "subject": "...",
+ *     "description": "...",
+ *     "activeForm": "...",
+ *     "status": "pending" | "in_progress" | "completed",
+ *     "blocks": [],
+ *     "blockedBy": []
+ *   }
+ *
+ * Rather than replaying tool_use / tool_result payloads (whose shapes are not
+ * guaranteed by the minified SDK), this aggregator reads those files directly
+ * after each Task* tool call completes, which is the canonical source of truth.
+ */
+export type TodoStatus = "pending" | "in_progress" | "completed";
+export interface TodoItem {
+    content: string;
+    status: TodoStatus;
+    activeForm?: string;
+}
+/** Root directory under which per-session task files are persisted. */
+export declare function defaultTasksRoot(): string;
+/** Reads and orders the task files for a single session directory. */
+export declare function readSessionTasks(tasksRoot: string, sessionId: string): TodoItem[];
+export interface TaskAggregator {
+    /** Learn the active session id so subsequent refreshes read the right dir. */
+    setSessionId(sessionId: string | undefined): void;
+    /** Returns true if the tool is a Task* tool (and is consumed by the aggregator). */
+    isTaskTool(name: string): boolean;
+    /**
+     * Record a Task* tool_use. The persisted file is usually written by the time
+     * the matching tool_result arrives, so this mostly registers the call id for
+     * downstream suppression. Returns true if the on-disk list changed.
+     */
+    applyToolUse(toolCallId: string, name: string, input: unknown): boolean;
+    /**
+     * Record a Task* tool_result and re-read the session's task files. Returns
+     * true if the on-disk list changed since the last snapshot.
+     */
+    applyToolResult(toolCallId: string, result: unknown): boolean;
+    /** Whether the given tool_use_id belonged to a Task* tool call. */
+    isTaskToolCall(toolCallId: string): boolean;
+    /** Re-read task files for the active session; returns true if changed. */
+    refresh(): boolean;
+    /** Current ordered todo list. */
+    snapshot(): {
+        todos: TodoItem[];
+    };
+    /** Whether the list changed since the last `clearDirty()`. */
+    dirty(): boolean;
+    /** Reset the dirty flag (call after emitting an aggregated event). */
+    clearDirty(): void;
+}
+export interface TaskAggregatorOptions {
+    tasksRoot?: string;
+    sessionId?: string;
+}
+export declare function createTaskAggregator(options?: TaskAggregatorOptions): TaskAggregator;

package/dist/task-aggregator.js

@@ -0,0 +1,143 @@
+/**
+ * Aggregates Claude Code's incremental task tools (TaskCreate / TaskUpdate /
+ * TaskList / TaskGet / TaskStop / TaskOutput) into a single todo list that is
+ * compatible with the legacy `TodoWrite` event shape consumed downstream:
+ *
+ *   { todos: [{ content, status, activeForm? }] }
+ *
+ * Claude Code replaced the old all-at-once `TodoWrite` tool with a set of
+ * incremental CRUD tools that persist each task as a JSON file under
+ * `<claude config dir>/tasks/<session_id>/<N>.json` (N starts at 1):
+ *
+ *   {
+ *     "id": "1",
+ *     "subject": "...",
+ *     "description": "...",
+ *     "activeForm": "...",
+ *     "status": "pending" | "in_progress" | "completed",
+ *     "blocks": [],
+ *     "blockedBy": []
+ *   }
+ *
+ * Rather than replaying tool_use / tool_result payloads (whose shapes are not
+ * guaranteed by the minified SDK), this aggregator reads those files directly
+ * after each Task* tool call completes, which is the canonical source of truth.
+ */
+import { readdirSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+const TASK_TOOL_NAMES = new Set(["TaskCreate", "TaskUpdate", "TaskList", "TaskGet", "TaskStop", "TaskOutput"]);
+function isRecord(value) {
+    return Boolean(value && typeof value === "object");
+}
+function asString(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function normalizeStatus(value) {
+    if (value === "pending" || value === "in_progress" || value === "completed")
+        return value;
+    return undefined;
+}
+/** Root directory under which per-session task files are persisted. */
+export function defaultTasksRoot() {
+    const base = process.env.CLAUDE_CONFIG_DIR?.trim() || join(homedir(), ".claude");
+    return join(base, "tasks");
+}
+function toTodo(raw) {
+    if (!isRecord(raw))
+        return undefined;
+    const status = normalizeStatus(raw.status);
+    // Files may exist for tasks in states we do not surface; skip unknown ones.
+    if (!status)
+        return undefined;
+    const content = asString(raw.subject) ?? asString(raw.activeForm) ?? asString(raw.description);
+    if (!content)
+        return undefined;
+    const activeForm = asString(raw.activeForm);
+    return { content, status, ...(activeForm ? { activeForm } : null) };
+}
+/** Reads and orders the task files for a single session directory. */
+export function readSessionTasks(tasksRoot, sessionId) {
+    const dir = join(tasksRoot, sessionId);
+    let files;
+    try {
+        files = readdirSync(dir);
+    }
+    catch {
+        return [];
+    }
+    const ordered = files
+        .filter((name) => name.endsWith(".json"))
+        .map((name) => ({ name, n: Number.parseInt(name, 10) }))
+        .filter((entry) => Number.isFinite(entry.n))
+        .sort((a, b) => a.n - b.n);
+    const todos = [];
+    for (const { name } of ordered) {
+        try {
+            const raw = JSON.parse(readFileSync(join(dir, name), "utf-8"));
+            const todo = toTodo(raw);
+            if (todo)
+                todos.push(todo);
+        }
+        catch {
+            // Ignore unreadable / partially-written files; the next refresh recovers.
+        }
+    }
+    return todos;
+}
+export function createTaskAggregator(options = {}) {
+    const tasksRoot = options.tasksRoot ?? defaultTasksRoot();
+    // All tool_use_ids that belonged to Task* tools, so their raw tool input /
+    // result can be suppressed downstream in favor of the aggregated event.
+    const taskToolCallIds = new Set();
+    let sessionId = options.sessionId;
+    let todos = [];
+    let lastSerialized = JSON.stringify(todos);
+    let isDirty = false;
+    const refresh = () => {
+        if (!sessionId)
+            return false;
+        const next = readSessionTasks(tasksRoot, sessionId);
+        const serialized = JSON.stringify(next);
+        if (serialized === lastSerialized)
+            return false;
+        todos = next;
+        lastSerialized = serialized;
+        isDirty = true;
+        return true;
+    };
+    return {
+        setSessionId(next) {
+            if (next && next !== sessionId) {
+                sessionId = next;
+            }
+        },
+        isTaskTool(name) {
+            return TASK_TOOL_NAMES.has(name);
+        },
+        applyToolUse(toolCallId, name) {
+            if (!TASK_TOOL_NAMES.has(name))
+                return false;
+            taskToolCallIds.add(toolCallId);
+            return refresh();
+        },
+        applyToolResult(toolCallId) {
+            if (!taskToolCallIds.has(toolCallId))
+                return false;
+            return refresh();
+        },
+        isTaskToolCall(toolCallId) {
+            return taskToolCallIds.has(toolCallId);
+        },
+        refresh,
+        snapshot() {
+            return { todos: todos.map((todo) => ({ ...todo })) };
+        },
+        dirty() {
+            return isDirty;
+        },
+        clearDirty() {
+            isDirty = false;
+        },
+    };
+}

package/dist/token-usage.d.ts

@@ -0,0 +1,23 @@
+import type { SDKResultMessage } from "./claude.js";
+type TokenBreakdown = {
+    input_tokens: number;
+    output_tokens: number;
+    total_tokens: number;
+};
+export type ClaudeTokenUsage = {
+    last: TokenBreakdown;
+    context?: {
+        used_tokens: number;
+        window_tokens: number;
+    };
+};
+export type ClaudeContextSnapshot = {
+    usedTokens: number;
+    model?: string;
+};
+export declare function claudeContextSnapshot(message: {
+    usage?: unknown;
+    model?: unknown;
+}): ClaudeContextSnapshot | undefined;
+export declare function claudeTokenUsage(message: SDKResultMessage, contextSnapshot: ClaudeContextSnapshot | undefined): ClaudeTokenUsage | undefined;
+export {};

package/dist/token-usage.js

@@ -0,0 +1,75 @@
+function sumTokens(...values) {
+    let total = 0;
+    for (const value of values) {
+        if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0)
+            return undefined;
+        total += value;
+        if (!Number.isSafeInteger(total))
+            return undefined;
+    }
+    return total;
+}
+function resultBreakdown(message) {
+    const modelUsages = Object.values(message.modelUsage ?? {});
+    if (modelUsages.length === 0)
+        return undefined;
+    let result;
+    for (const usage of modelUsages) {
+        const inputTokens = sumTokens(usage.inputTokens, usage.cacheCreationInputTokens, usage.cacheReadInputTokens);
+        const outputTokens = sumTokens(usage.outputTokens);
+        if (inputTokens === undefined || outputTokens === undefined)
+            return undefined;
+        const totalTokens = sumTokens(inputTokens, outputTokens);
+        if (totalTokens === undefined)
+            return undefined;
+        result = addBreakdowns(result, {
+            input_tokens: inputTokens,
+            output_tokens: outputTokens,
+            total_tokens: totalTokens,
+        });
+        if (!result)
+            return undefined;
+    }
+    return result;
+}
+function addBreakdowns(left, right) {
+    const inputTokens = sumTokens(left?.input_tokens ?? 0, right.input_tokens);
+    const outputTokens = sumTokens(left?.output_tokens ?? 0, right.output_tokens);
+    const totalTokens = sumTokens(left?.total_tokens ?? 0, right.total_tokens);
+    if (inputTokens === undefined || outputTokens === undefined || totalTokens === undefined)
+        return undefined;
+    return { input_tokens: inputTokens, output_tokens: outputTokens, total_tokens: totalTokens };
+}
+export function claudeContextSnapshot(message) {
+    const rawUsage = message.usage;
+    if (!rawUsage || typeof rawUsage !== "object")
+        return undefined;
+    const usage = rawUsage;
+    const usedTokens = sumTokens(usage.input_tokens, usage.cache_creation_input_tokens, usage.cache_read_input_tokens, usage.output_tokens);
+    if (usedTokens === undefined)
+        return undefined;
+    return {
+        usedTokens,
+        ...(typeof message.model === "string" && message.model ? { model: message.model } : {}),
+    };
+}
+function modelContextWindow(message, model) {
+    const entries = Object.entries(message.modelUsage ?? {});
+    const selected = entries.length === 1 ? entries[0][1] : model ? entries.find(([name]) => name === model)?.[1] : undefined;
+    const contextWindow = selected?.contextWindow;
+    return typeof contextWindow === "number" && Number.isSafeInteger(contextWindow) && contextWindow > 0
+        ? contextWindow
+        : undefined;
+}
+export function claudeTokenUsage(message, contextSnapshot) {
+    const last = resultBreakdown(message);
+    if (!last)
+        return undefined;
+    const contextWindow = modelContextWindow(message, contextSnapshot?.model);
+    return {
+        last,
+        ...(contextSnapshot && contextWindow !== undefined
+            ? { context: { used_tokens: contextSnapshot.usedTokens, window_tokens: contextWindow } }
+            : {}),
+    };
+}

package/dist/tunnel-client.d.ts

@@ -0,0 +1,15 @@
+import { type AppConfig } from "./config.js";
+export type TunnelClientConfig = AppConfig["tunnel"];
+export declare class ClaudeTunnelClient {
+    private readonly config;
+    private stopped;
+    private socket;
+    private running;
+    constructor(config: TunnelClientConfig);
+    start(): Promise<void>;
+    stop(): void;
+    private connectOnce;
+    private send;
+    private handleRequest;
+}
+export declare function startClaudeTunnelClient(config?: TunnelClientConfig): ClaudeTunnelClient | undefined;