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

package/dist/routes/shared.d.ts

@@ -0,0 +1,37 @@
+import type { CommandExecutionItem, DynamicToolCallItem, FileChangeItem, McpToolCallItem, ThreadItem, TurnStartParams, Usage, WebSearchItem } from "../app-server-protocol.js";
+export type TokenUsageBreakdown = {
+    input_tokens: number;
+    output_tokens: number;
+    total_tokens: number;
+};
+export type NormalizedTokenUsage = {
+    total: TokenUsageBreakdown;
+    last: TokenUsageBreakdown;
+    context?: {
+        used_tokens: number;
+        window_tokens: number;
+    };
+};
+export declare function addTokenUsage(left: TokenUsageBreakdown | undefined, right: TokenUsageBreakdown): TokenUsageBreakdown | undefined;
+export declare function toUsage(usage: Usage | null | undefined): NormalizedTokenUsage | undefined;
+export declare function textFromContent(content: string | Array<{
+    type: string;
+    text?: string;
+}>): string;
+export declare function inputToPrompt(input: unknown, instructions: string | undefined, isNewSession: boolean, systemReminder?: string): string;
+export declare function turnOptions(agentMode: string | undefined, model: string): {
+    collaborationMode: TurnStartParams["collaborationMode"];
+};
+export declare function itemText(item: ThreadItem): string | undefined;
+export declare function commandExecutionItem(item: ThreadItem): CommandExecutionItem | undefined;
+export declare function fileChangeItem(item: ThreadItem): FileChangeItem | undefined;
+export declare function mcpToolCallItem(item: ThreadItem): McpToolCallItem | undefined;
+export declare function dynamicToolCallItem(item: ThreadItem): DynamicToolCallItem | undefined;
+export declare function webSearchItem(item: ThreadItem): WebSearchItem | undefined;
+export declare function mcpToolCallOutput(item: McpToolCallItem): string;
+export declare function displayCommand(command: string): string;
+export declare function dynamicToolCallOutput(item: DynamicToolCallItem): string;
+export declare function webSearchPayload(item: WebSearchItem): {
+    query: string;
+    action?: WebSearchItem["action"];
+};

package/dist/routes/shared.js

@@ -0,0 +1,218 @@
+import { HTTPException } from "hono/http-exception";
+export function addTokenUsage(left, right) {
+    const inputTokens = (left?.input_tokens ?? 0) + right.input_tokens;
+    const outputTokens = (left?.output_tokens ?? 0) + right.output_tokens;
+    const totalTokens = (left?.total_tokens ?? 0) + right.total_tokens;
+    if (![inputTokens, outputTokens, totalTokens].every(Number.isSafeInteger))
+        return undefined;
+    return { input_tokens: inputTokens, output_tokens: outputTokens, total_tokens: totalTokens };
+}
+export function toUsage(usage) {
+    const normalizeBreakdown = (breakdown) => {
+        const inputTokens = breakdown?.input_tokens;
+        const outputTokens = breakdown?.output_tokens;
+        const totalTokens = breakdown?.total_tokens;
+        if (typeof inputTokens !== "number" ||
+            typeof outputTokens !== "number" ||
+            typeof totalTokens !== "number" ||
+            !Number.isSafeInteger(inputTokens) ||
+            inputTokens < 0 ||
+            !Number.isSafeInteger(outputTokens) ||
+            outputTokens < 0 ||
+            !Number.isSafeInteger(totalTokens) ||
+            totalTokens < 0) {
+            return undefined;
+        }
+        return { input_tokens: inputTokens, output_tokens: outputTokens, total_tokens: totalTokens };
+    };
+    const total = normalizeBreakdown(usage?.total);
+    const last = normalizeBreakdown(usage?.last);
+    const modelContextWindow = usage?.model_context_window;
+    if (!total || !last)
+        return undefined;
+    return {
+        total,
+        last,
+        ...(typeof modelContextWindow === "number" && Number.isSafeInteger(modelContextWindow) && modelContextWindow > 0
+            ? { context: { used_tokens: last.total_tokens, window_tokens: modelContextWindow } }
+            : {}),
+    };
+}
+export function textFromContent(content) {
+    if (typeof content === "string")
+        return content;
+    return content
+        .filter((part) => part.type === "input_text")
+        .map((part) => part.text ?? "")
+        .join("\n");
+}
+export function inputToPrompt(input, instructions, isNewSession, systemReminder) {
+    const leadingTexts = (isNewSession ? [systemReminder, instructions] : [systemReminder]).filter((text) => Boolean(text));
+    const prefix = leadingTexts.length > 0 ? `${leadingTexts.join("\n\n")}\n\n` : "";
+    if (typeof input === "string")
+        return `${prefix}${input}`;
+    if (!Array.isArray(input)) {
+        throw new HTTPException(400, { message: "Invalid input" });
+    }
+    const lastUserMsg = [...input]
+        .reverse()
+        .find((message) => {
+        return Boolean(message && typeof message === "object" && "role" in message && message.role === "user");
+    });
+    if (!lastUserMsg) {
+        throw new HTTPException(400, { message: "No user message found" });
+    }
+    let systemText = instructions;
+    if (isNewSession && !systemText) {
+        const sysMsg = [...input]
+            .reverse()
+            .find((message) => {
+            return (Boolean(message && typeof message === "object" && "role" in message) &&
+                (message.role === "system" || message.role === "developer"));
+        });
+        if (sysMsg) {
+            systemText = textFromContent(sysMsg.content);
+        }
+    }
+    const arrayLeadingTexts = isNewSession
+        ? [systemReminder, systemText].filter((text) => Boolean(text))
+        : [];
+    return `${arrayLeadingTexts.length > 0 ? `${arrayLeadingTexts.join("\n\n")}\n\n` : ""}${textFromContent(lastUserMsg.content)}`;
+}
+export function turnOptions(agentMode, model) {
+    return {
+        collaborationMode: {
+            mode: agentMode === "plan" ? "plan" : "default",
+            settings: { model: model || null, reasoning_effort: "medium", developer_instructions: null },
+        },
+    };
+}
+export function itemText(item) {
+    if (item.type === "agentMessage") {
+        return item.text;
+    }
+    if (item.type === "reasoning")
+        return item.summary.join("\n") || item.content.join("\n");
+    if (item.type === "plan")
+        return item.text;
+    return undefined;
+}
+export function commandExecutionItem(item) {
+    if (item.type !== "commandExecution") {
+        return undefined;
+    }
+    return item;
+}
+export function fileChangeItem(item) {
+    if (item.type !== "fileChange") {
+        return undefined;
+    }
+    return item;
+}
+export function mcpToolCallItem(item) {
+    if (item.type !== "mcpToolCall") {
+        return undefined;
+    }
+    return item;
+}
+export function dynamicToolCallItem(item) {
+    if (item.type !== "dynamicToolCall") {
+        return undefined;
+    }
+    return item;
+}
+export function webSearchItem(item) {
+    if (item.type !== "webSearch") {
+        return undefined;
+    }
+    return item;
+}
+function textFromMcpContent(content) {
+    if (!Array.isArray(content))
+        return undefined;
+    const text = content
+        .map((part) => {
+        if (part && typeof part === "object" && "type" in part && part.type === "text" && "text" in part) {
+            return typeof part.text === "string" ? part.text : "";
+        }
+        return "";
+    })
+        .filter((part) => part.length > 0)
+        .join("\n");
+    return text.length > 0 ? text : undefined;
+}
+export function mcpToolCallOutput(item) {
+    const structuredContent = item.result?.structuredContent;
+    if (structuredContent &&
+        typeof structuredContent === "object" &&
+        "filePath" in structuredContent &&
+        typeof structuredContent.filePath === "string") {
+        return structuredContent.filePath;
+    }
+    return textFromMcpContent(item.result?.content) ?? JSON.stringify(item.result ?? null);
+}
+function parseShellWord(input) {
+    let index = 0;
+    let value = "";
+    while (index < input.length) {
+        const char = input[index];
+        if (/\s/.test(char))
+            break;
+        if (char === "'") {
+            index += 1;
+            while (index < input.length) {
+                if (input[index] === "'") {
+                    index += 1;
+                    break;
+                }
+                value += input[index];
+                index += 1;
+            }
+            continue;
+        }
+        if (char === '"') {
+            index += 1;
+            while (index < input.length) {
+                const innerChar = input[index];
+                if (innerChar === '"') {
+                    index += 1;
+                    break;
+                }
+                if (innerChar === "\\" && index + 1 < input.length) {
+                    value += input[index + 1];
+                    index += 2;
+                    continue;
+                }
+                value += innerChar;
+                index += 1;
+            }
+            continue;
+        }
+        if (char === "\\" && index + 1 < input.length) {
+            value += input[index + 1];
+            index += 2;
+            continue;
+        }
+        value += char;
+        index += 1;
+    }
+    return input.slice(index).trim() === "" ? value : undefined;
+}
+export function displayCommand(command) {
+    const match = command.match(/^\/bin\/bash\s+-lc\s+([\s\S]+)$/);
+    if (!match)
+        return command;
+    return parseShellWord(match[1].trim()) ?? command;
+}
+export function dynamicToolCallOutput(item) {
+    const texts = (item.contentItems ?? [])
+        .map((content) => (content.type === "inputText" ? content.text : content.imageUrl))
+        .filter((text) => text.length > 0);
+    return texts.join("\n");
+}
+export function webSearchPayload(item) {
+    return {
+        query: item.query,
+        ...(item.action ? { action: item.action } : null),
+    };
+}

package/dist/schemas.d.ts

@@ -0,0 +1,112 @@
+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>;
+    approval: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        approved: z.ZodOptional<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.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>;
+            approval: z.ZodOptional<z.ZodObject<{
+                id: z.ZodString;
+                approved: z.ZodOptional<z.ZodBoolean>;
+                reason: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+        }, 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 declare const ToolRequestUserInputAnswerSchema: z.ZodObject<{
+    answers: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export declare const ToolRequestUserInputResponseSchema: z.ZodObject<{
+    answers: z.ZodRecord<z.ZodString, z.ZodObject<{
+        answers: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const RequestUserInputToolPartSchema: z.ZodObject<{
+    type: z.ZodLiteral<"tool">;
+    toolCallId: z.ZodString;
+    toolName: z.ZodLiteral<"request_user_input">;
+    state: z.ZodLiteral<"output-available">;
+    sourceTurnId: z.ZodOptional<z.ZodString>;
+    output: z.ZodObject<{
+        answers: z.ZodRecord<z.ZodString, z.ZodObject<{
+            answers: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;

package/dist/schemas.js

@@ -0,0 +1,72 @@
+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(),
+    approval: z
+        .object({
+        id: z.string(),
+        approved: z.boolean().optional(),
+        reason: z.string().optional(),
+    })
+        .optional(),
+});
+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,
+            ChatToolPartSchema,
+            ChatCustomPartSchema,
+        ])),
+    }),
+});
+export const ToolRequestUserInputAnswerSchema = z.object({
+    answers: z.array(z.string()),
+});
+export const ToolRequestUserInputResponseSchema = z.object({
+    answers: z.record(z.string(), ToolRequestUserInputAnswerSchema),
+});
+export const RequestUserInputToolPartSchema = z.object({
+    type: z.literal("tool"),
+    toolCallId: z.string(),
+    toolName: z.literal("request_user_input"),
+    state: z.literal("output-available"),
+    sourceTurnId: z.string().min(1).optional(),
+    output: ToolRequestUserInputResponseSchema,
+});

package/dist/tunnel-client.d.ts

@@ -0,0 +1,15 @@
+import { type AppConfig } from "./config.js";
+export type TunnelClientConfig = AppConfig["tunnel"];
+export declare class CodexTunnelClient {
+    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 startCodexTunnelClient(config?: TunnelClientConfig): CodexTunnelClient | undefined;

package/dist/tunnel-client.js

@@ -0,0 +1,232 @@
+import { createRequire } from "node:module";
+import WebSocket from "ws";
+import { ChatBodySchema } from "./schemas.js";
+import { appConfig } from "./config.js";
+import { cancelCodexConversation, ChatRequestError, handleCodexChatStream } from "./routes/chat.js";
+import { logger } from "@messenger-agent/shared/logger";
+import { sendHttpTunnelResponse } from "@messenger-agent/shared/tunnel-http";
+import { CODING_AGENT_TUNNEL_DUPLICATE_CLOSE_CODE, CODING_AGENT_TUNNEL_PROTOCOL_VERSION, } from "@messenger-agent/shared/tunnel-protocol";
+const clientVersion = createRequire(import.meta.url)("../package.json").version;
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function parseServerMessage(raw) {
+    try {
+        const value = JSON.parse(raw.toString());
+        if (!value || typeof value !== "object" || !("type" in value))
+            return undefined;
+        return value;
+    }
+    catch {
+        return undefined;
+    }
+}
+function headersFromRecord(headers) {
+    const result = new Headers();
+    for (const [key, value] of Object.entries(headers ?? {})) {
+        result.set(key, value);
+    }
+    return result;
+}
+function cancelConversationId(message) {
+    if (message.method !== "POST")
+        return undefined;
+    try {
+        const pathname = new URL(message.path, "http://coding-agent-tunnel.local").pathname;
+        const match = /^\/v1\/chat\/([^/]+)\/cancel$/.exec(pathname);
+        return match ? decodeURIComponent(match[1]) : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export class CodexTunnelClient {
+    config;
+    stopped = false;
+    socket;
+    running = new Map();
+    constructor(config) {
+        this.config = config;
+    }
+    async start() {
+        if (!this.config.enabled)
+            return;
+        if (!this.config.serverUrl || !this.config.tunnelId || !this.config.token) {
+            throw new Error("Tunnel config requires server_url, tunnel_id, and token when enabled");
+        }
+        let backoffMs = this.config.reconnectInitialMs;
+        while (!this.stopped) {
+            try {
+                await this.connectOnce();
+                backoffMs = this.config.reconnectInitialMs;
+            }
+            catch (err) {
+                if (this.stopped)
+                    break;
+                logger.warn("[TunnelClient] websocket tunnel connection failed:", err);
+            }
+            if (!this.stopped) {
+                await delay(backoffMs);
+                backoffMs = Math.min(backoffMs * 2, this.config.reconnectMaxMs);
+            }
+        }
+    }
+    stop() {
+        this.stopped = true;
+        for (const request of this.running.values()) {
+            request.abortController.abort();
+        }
+        this.running.clear();
+        this.socket?.close();
+    }
+    connectOnce() {
+        return new Promise((resolve, reject) => {
+            const headers = { Authorization: `Bearer ${this.config.token}` };
+            const ws = new WebSocket(this.config.serverUrl, { headers });
+            this.socket = ws;
+            let heartbeatTimer;
+            let settled = false;
+            const cleanup = () => {
+                if (heartbeatTimer)
+                    clearInterval(heartbeatTimer);
+                if (this.socket === ws)
+                    this.socket = undefined;
+                for (const request of this.running.values()) {
+                    request.abortController.abort(new Error("Tunnel connection closed"));
+                }
+                this.running.clear();
+            };
+            ws.on("open", () => {
+                this.send({
+                    type: "hello",
+                    protocolVersion: CODING_AGENT_TUNNEL_PROTOCOL_VERSION,
+                    tunnelId: this.config.tunnelId,
+                    agentType: "codex",
+                    clientVersion,
+                });
+                heartbeatTimer = setInterval(() => {
+                    this.send({ type: "heartbeat" });
+                }, this.config.heartbeatIntervalMs);
+                logger.info(`[TunnelClient] connected to ${this.config.serverUrl} as ${this.config.tunnelId}`);
+            });
+            ws.on("message", (raw) => {
+                const message = parseServerMessage(raw);
+                if (!message) {
+                    logger.warn("[TunnelClient] received invalid websocket message");
+                    return;
+                }
+                if (message.type === "heartbeat")
+                    return;
+                if (message.type === "cancel") {
+                    this.running.get(message.id)?.abortController.abort();
+                    return;
+                }
+                if (message.type === "request") {
+                    this.handleRequest(message).catch((err) => {
+                        logger.error(`[TunnelClient] request ${message.id} failed:`, err);
+                    });
+                }
+            });
+            ws.once("error", (err) => {
+                if (!settled) {
+                    settled = true;
+                    cleanup();
+                    reject(err);
+                }
+            });
+            ws.once("close", (code, reason) => {
+                cleanup();
+                if (code === CODING_AGENT_TUNNEL_DUPLICATE_CLOSE_CODE) {
+                    this.stopped = true;
+                    logger.warn(`[TunnelClient] duplicate websocket tunnel connection rejected; reconnect disabled: ${reason.toString()}`);
+                }
+                if (!settled) {
+                    settled = true;
+                    resolve();
+                }
+            });
+        });
+    }
+    send(message) {
+        const socket = this.socket;
+        if (!socket || socket.readyState !== WebSocket.OPEN)
+            return;
+        socket.send(JSON.stringify(message));
+    }
+    async handleRequest(message) {
+        const conversationId = cancelConversationId(message);
+        if (conversationId) {
+            let cancelled;
+            try {
+                cancelled = await cancelCodexConversation(conversationId);
+            }
+            catch (err) {
+                const errorText = err instanceof Error ? err.message : "Failed to interrupt Codex conversation";
+                const response = Response.json({ error: { type: "server_error", code: "cancel_failed", message: errorText } }, { status: 500 });
+                await sendHttpTunnelResponse(message.id, response, (responseMessage) => this.send(responseMessage));
+                return;
+            }
+            const response = Response.json(cancelled
+                ? { success: true }
+                : {
+                    error: {
+                        type: "not_found_error",
+                        code: "conversation_not_found",
+                        message: `Conversation not found or already completed: ${conversationId}`,
+                        param: "conversation_id",
+                    },
+                }, { status: cancelled ? 200 : 404 });
+            await sendHttpTunnelResponse(message.id, response, (responseMessage) => this.send(responseMessage));
+            return;
+        }
+        if (message.method !== "POST" || message.path !== "/v1/chat/stream") {
+            this.send({
+                type: "response.error",
+                id: message.id,
+                code: "unsupported_request",
+                errorText: `Unsupported tunnel request: ${message.method} ${message.path}`,
+            });
+            return;
+        }
+        const body = ChatBodySchema.safeParse(message.body);
+        if (!body.success) {
+            this.send({
+                type: "response.error",
+                id: message.id,
+                code: "invalid_request",
+                errorText: `Invalid chat request body: ${body.error.message}`,
+            });
+            return;
+        }
+        const abortController = new AbortController();
+        this.running.set(message.id, { abortController });
+        this.send({ type: "response.start", id: message.id, mode: "sse" });
+        try {
+            await handleCodexChatStream({
+                body: body.data,
+                headers: headersFromRecord(message.headers),
+                signal: abortController.signal,
+            }, {
+                writeData: async (data) => this.send({ type: "response.chunk", id: message.id, data }),
+                writeDone: async () => this.send({ type: "response.end", id: message.id }),
+            });
+        }
+        catch (err) {
+            const errorText = err instanceof Error ? err.message : "Tunnel request failed";
+            const code = err instanceof ChatRequestError ? `http_${err.status}` : "request_failed";
+            this.send({ type: "response.error", id: message.id, code, errorText });
+        }
+        finally {
+            this.running.delete(message.id);
+        }
+    }
+}
+export function startCodexTunnelClient(config = appConfig.tunnel) {
+    if (!config.enabled)
+        return undefined;
+    const client = new CodexTunnelClient(config);
+    client.start().catch((err) => {
+        logger.error("[TunnelClient] stopped unexpectedly:", err);
+    });
+    return client;
+}