@pwrdrvr/agent-client 0.1.0

package/dist/index.js

@@ -0,0 +1,1527 @@
+// src/codex-thread-client.ts
+import {
+  noopLogger
+} from "@pwrdrvr/agent-core";
+import {
+  JsonRpcConnection,
+  StdioJsonRpcTransport
+} from "@pwrdrvr/agent-transport";
+import { resolveCodexCommand } from "@pwrdrvr/codex-discovery";
+
+// src/normalize.ts
+import {
+  inferToolKind
+} from "@pwrdrvr/agent-core";
+var CODEX_NOTIFICATION_METHODS = {
+  agentMessageDelta: "item/agentMessage/delta",
+  reasoningDelta: "item/reasoning/delta",
+  reasoningTextDelta: "item/reasoning/textDelta",
+  itemStarted: "item/started",
+  itemCompleted: "item/completed",
+  turnStarted: "turn/started",
+  turnCompleted: "turn/completed",
+  tokenUsage: "thread/tokenUsage/updated",
+  threadSettings: "thread/settings/updated",
+  modelRerouted: "model/rerouted",
+  error: "error"
+};
+var CODEX_APPROVAL_METHODS = /* @__PURE__ */ new Set([
+  "item/commandExecution/requestApproval",
+  "item/fileChange/requestApproval",
+  "item/permissions/requestApproval",
+  "item/tool/requestUserInput",
+  // Legacy v1 method names — older Codex builds still emit these.
+  "applyPatchApproval",
+  "execCommandApproval"
+]);
+var CODEX_TOOL_CALL_METHOD = "item/tool/call";
+function normalizeTokenUsage(usage) {
+  const last = usage.last;
+  return {
+    inputTokens: last.inputTokens,
+    cachedInputTokens: last.cachedInputTokens,
+    outputTokens: last.outputTokens,
+    reasoningOutputTokens: last.reasoningOutputTokens,
+    totalTokens: last.totalTokens,
+    // Top-level on ThreadTokenUsage (sibling to last/total), not on the breakdown.
+    ...usage.modelContextWindow != null ? { contextWindow: usage.modelContextWindow } : {}
+  };
+}
+function normalizeTurnStatus(status) {
+  switch (status) {
+    case "completed":
+      return "completed";
+    case "failed":
+      return "failed";
+    case "interrupted":
+      return "interrupted";
+    case "inProgress":
+      return "in_progress";
+    case "aborted":
+    case "cancelled":
+    case "canceled":
+      return "cancelled";
+    default:
+      return "failed";
+  }
+}
+var DYNAMIC_TOOL_STATUS = {
+  inProgress: "in_progress",
+  completed: "completed",
+  failed: "failed"
+};
+var COMMAND_STATUS = {
+  inProgress: "in_progress",
+  completed: "completed",
+  failed: "failed",
+  declined: "cancelled"
+};
+function joinDynamicResult(contentItems) {
+  if (contentItems === null) return void 0;
+  const text = contentItems.map((item) => item.type === "inputText" ? item.text : item.imageUrl).join("");
+  return text.length > 0 ? text : void 0;
+}
+function normalizeThreadItemToolCall(item) {
+  if (item.type === "dynamicToolCall") {
+    const kind = inferToolKind(item.tool);
+    const status = DYNAMIC_TOOL_STATUS[item.status] ?? "in_progress";
+    const call = {
+      id: item.id,
+      name: item.tool,
+      kind,
+      label: item.tool,
+      status,
+      args: item.arguments
+    };
+    const result = joinDynamicResult(item.contentItems);
+    if (result !== void 0) call.result = result;
+    return call;
+  }
+  if (item.type === "commandExecution") {
+    const status = COMMAND_STATUS[item.status] ?? "in_progress";
+    const call = {
+      id: item.id,
+      name: "command",
+      kind: "command",
+      label: item.command,
+      status,
+      command: {
+        displayCommand: item.command,
+        rawCommand: item.command,
+        cwd: item.cwd,
+        ...item.aggregatedOutput !== null ? { output: item.aggregatedOutput } : {},
+        ...item.exitCode !== null ? { exitCode: item.exitCode } : {},
+        ...item.durationMs !== null ? { durationMs: item.durationMs } : {}
+      }
+    };
+    return call;
+  }
+  if (item.type === "webSearch") {
+    return {
+      id: item.id,
+      name: "web_search",
+      kind: "search",
+      label: item.query,
+      status: "completed",
+      args: { query: item.query }
+    };
+  }
+  if (item.type === "fileChange") {
+    return {
+      id: item.id,
+      name: "file_change",
+      kind: "write",
+      label: "Edit files",
+      status: item.status === "completed" ? "completed" : "in_progress"
+    };
+  }
+  return null;
+}
+function normalizeDynamicToolCall(params) {
+  return {
+    id: params.callId,
+    name: params.tool,
+    kind: inferToolKind(params.tool),
+    label: params.tool,
+    status: "in_progress",
+    args: params.arguments
+  };
+}
+function approvalKindForMethod(method) {
+  if (method.includes("commandExecution") || method === "execCommandApproval") return "exec";
+  if (method.includes("fileChange") || method === "applyPatchApproval") return "patch";
+  if (method.includes("tool")) return "tool";
+  return "other";
+}
+function normalizeApprovalRequest(method, params, approvalId) {
+  const p = params ?? {};
+  const summary = typeof p.reason === "string" ? p.reason : typeof p.command === "string" ? p.command : void 0;
+  const request = {
+    id: approvalId,
+    method,
+    kind: approvalKindForMethod(method),
+    params
+  };
+  if (summary !== void 0) request.summary = summary;
+  return request;
+}
+function normalizeThreadSettings(notification) {
+  return {
+    threadId: notification.threadId,
+    model: notification.threadSettings.model,
+    modelProvider: notification.threadSettings.modelProvider,
+    serviceTier: notification.threadSettings.serviceTier
+  };
+}
+function isToolish(item) {
+  return item.type === "dynamicToolCall" || item.type === "commandExecution" || item.type === "webSearch" || item.type === "fileChange";
+}
+function toUpdate(call) {
+  return call;
+}
+function agentMessageFromItem(item) {
+  if (item.type !== "agentMessage") return null;
+  return { id: item.id, role: "assistant", text: item.text };
+}
+function normalizeNotification(method, params) {
+  switch (method) {
+    case CODEX_NOTIFICATION_METHODS.agentMessageDelta: {
+      const n = params;
+      return {
+        kind: "agent_message_delta",
+        threadId: n.threadId,
+        turnId: n.turnId,
+        itemId: n.itemId,
+        delta: n.delta
+      };
+    }
+    case CODEX_NOTIFICATION_METHODS.reasoningDelta:
+    case CODEX_NOTIFICATION_METHODS.reasoningTextDelta: {
+      const n = params;
+      return {
+        kind: "reasoning_delta",
+        threadId: n.threadId,
+        turnId: n.turnId,
+        itemId: n.itemId,
+        delta: n.delta
+      };
+    }
+    case CODEX_NOTIFICATION_METHODS.turnStarted: {
+      const n = params;
+      return { kind: "turn_started", threadId: n.threadId, turnId: n.turn.id };
+    }
+    case CODEX_NOTIFICATION_METHODS.turnCompleted: {
+      const n = params;
+      return {
+        kind: "turn_completed",
+        threadId: n.threadId,
+        turnId: n.turn.id,
+        status: normalizeTurnStatus(n.turn.status)
+      };
+    }
+    case CODEX_NOTIFICATION_METHODS.tokenUsage: {
+      const n = params;
+      return {
+        kind: "token_usage",
+        threadId: n.threadId,
+        turnId: n.turnId,
+        usage: normalizeTokenUsage(n.tokenUsage)
+      };
+    }
+    case CODEX_NOTIFICATION_METHODS.threadSettings: {
+      const n = params;
+      return { kind: "thread_settings", settings: normalizeThreadSettings(n) };
+    }
+    case CODEX_NOTIFICATION_METHODS.modelRerouted: {
+      const n = params;
+      return {
+        kind: "thread_settings",
+        settings: {
+          threadId: n.threadId,
+          model: n.toModel,
+          modelProvider: "openai",
+          serviceTier: null
+        }
+      };
+    }
+    case CODEX_NOTIFICATION_METHODS.itemStarted: {
+      const n = params;
+      if (isToolish(n.item)) {
+        const call = normalizeThreadItemToolCall(n.item);
+        if (call === null) return null;
+        return { kind: "tool_call", threadId: n.threadId, turnId: n.turnId, toolCall: call };
+      }
+      return null;
+    }
+    case CODEX_NOTIFICATION_METHODS.itemCompleted: {
+      const n = params;
+      const message = agentMessageFromItem(n.item);
+      if (message !== null) {
+        return {
+          kind: "agent_message",
+          threadId: n.threadId,
+          turnId: n.turnId,
+          message
+        };
+      }
+      if (isToolish(n.item)) {
+        const call = normalizeThreadItemToolCall(n.item);
+        if (call === null) return null;
+        return {
+          kind: "tool_call_update",
+          threadId: n.threadId,
+          turnId: n.turnId,
+          toolCall: toUpdate(call)
+        };
+      }
+      return null;
+    }
+    case CODEX_NOTIFICATION_METHODS.error: {
+      const p = params ?? {};
+      const message = typeof p.message === "string" ? p.message : "codex error";
+      const event = {
+        kind: "error",
+        message
+      };
+      if (typeof p.threadId === "string") event.threadId = p.threadId;
+      if (typeof p.turnId === "string") event.turnId = p.turnId;
+      if (typeof p.code === "string") event.code = p.code;
+      return event;
+    }
+    default:
+      return null;
+  }
+}
+
+// src/codex-thread-client.ts
+var DEFAULT_CLIENT_NAME = "agent-kit";
+var DEFAULT_SERVICE_NAME = "agent-kit";
+function approvalResponseFor(decision) {
+  switch (decision) {
+    case "approved":
+      return { decision: "approved" };
+    case "abort":
+      return { decision: "abort" };
+    case "denied":
+    default:
+      return { decision: "denied" };
+  }
+}
+var CodexThreadClient = class {
+  constructor(options = {}) {
+    this.options = options;
+    this.requestTimeoutMs = options.requestTimeoutMs ?? 2e4;
+    this.turnTimeoutMs = options.turnTimeoutMs ?? 12e4;
+    this.logger = options.logger ?? noopLogger;
+    this.transportFactory = options.transportFactory ?? null;
+  }
+  options;
+  requestTimeoutMs;
+  turnTimeoutMs;
+  logger;
+  transportFactory;
+  resolvedCommand = null;
+  connection = null;
+  initializeResponse = null;
+  eventListeners = /* @__PURE__ */ new Set();
+  toolCallHandler = null;
+  approvalHandler = null;
+  loadedThreadIds = /* @__PURE__ */ new Set();
+  /** Subscribe to the normalized event stream. Every native notification is
+   *  routed through `normalizeNotification` before listeners see it. */
+  onEvent(cb) {
+    this.eventListeners.add(cb);
+    return () => {
+      this.eventListeners.delete(cb);
+    };
+  }
+  /** Register the dynamic-tool ServerRequest handler (one at a time). */
+  onToolCall(handler) {
+    this.toolCallHandler = handler;
+    return () => {
+      if (this.toolCallHandler === handler) this.toolCallHandler = null;
+    };
+  }
+  /** Register the approval ServerRequest handler (one at a time). */
+  onApprovalRequest(handler) {
+    this.approvalHandler = handler;
+    return () => {
+      if (this.approvalHandler === handler) this.approvalHandler = null;
+    };
+  }
+  /**
+   * Public `AgentBackend.startThread`: accepts NEUTRAL `AgentStartThreadOptions`
+   * and maps them onto Codex-native `CodexStartThreadOptions` before delegating
+   * to `startThreadNative`. Mapping:
+   *   instructions→baseInstructions, cwd, workspaceRoots→runtimeWorkspaceRoots,
+   *   model/modelProvider, serviceTier (drop `null`), approvalPolicy, sandbox,
+   *   serviceName, config, environments, tools (cast to DynamicToolSpec[])→
+   *   dynamicTools.
+   */
+  async startThread(opts = {}) {
+    const native = {};
+    if (opts.instructions !== void 0) native.baseInstructions = opts.instructions;
+    if (opts.cwd !== void 0) native.cwd = opts.cwd;
+    if (opts.workspaceRoots !== void 0) {
+      native.runtimeWorkspaceRoots = [...opts.workspaceRoots];
+    }
+    if (opts.model !== void 0) native.model = opts.model;
+    if (opts.modelProvider !== void 0) native.modelProvider = opts.modelProvider;
+    if (opts.serviceTier != null) native.serviceTier = opts.serviceTier;
+    if (opts.approvalPolicy !== void 0) native.approvalPolicy = opts.approvalPolicy;
+    if (opts.sandbox !== void 0) native.sandbox = opts.sandbox;
+    if (opts.serviceName !== void 0) native.serviceName = opts.serviceName;
+    if (opts.config !== void 0) native.config = opts.config;
+    if (opts.environments !== void 0) native.environments = opts.environments;
+    if (opts.tools !== void 0) native.dynamicTools = opts.tools;
+    return this.startThreadNative(native);
+  }
+  /** Codex-native thread/start. Builds `ThreadStartParams` directly. Exposed for
+   *  hosts that want full Codex control; the neutral `startThread` delegates here. */
+  async startThreadNative(opts = {}) {
+    const connection = await this.getConnection();
+    await this.initialize();
+    const params = {
+      experimentalRawEvents: false,
+      persistExtendedHistory: false
+    };
+    if (opts.cwd !== void 0) params.cwd = opts.cwd;
+    if (opts.model !== void 0) params.model = opts.model;
+    if (opts.modelProvider !== void 0) params.modelProvider = opts.modelProvider;
+    if (opts.serviceTier !== void 0) params.serviceTier = opts.serviceTier;
+    if (opts.runtimeWorkspaceRoots !== void 0) {
+      params.runtimeWorkspaceRoots = opts.runtimeWorkspaceRoots;
+    }
+    const serviceName = opts.serviceName ?? this.options.serviceName ?? DEFAULT_SERVICE_NAME;
+    params.serviceName = serviceName;
+    if (opts.approvalPolicy !== void 0) {
+      params.approvalPolicy = opts.approvalPolicy;
+    }
+    if (opts.sandbox !== void 0) params.sandbox = opts.sandbox;
+    if (opts.baseInstructions !== void 0) params.baseInstructions = opts.baseInstructions;
+    if (opts.personality !== void 0) params.personality = opts.personality;
+    if (opts.dynamicTools !== void 0) params.dynamicTools = opts.dynamicTools;
+    if (opts.config !== void 0) {
+      params.config = opts.config;
+    }
+    if (opts.environments !== void 0) {
+      params.environments = opts.environments;
+    }
+    const response = await connection.request(
+      "thread/start",
+      params,
+      this.requestTimeoutMs
+    );
+    const threadId = response.thread.id;
+    this.loadedThreadIds.add(threadId);
+    this.logger.debug("thread started", { threadId });
+    return {
+      threadId,
+      model: response.model,
+      modelProvider: response.modelProvider,
+      serviceTier: response.serviceTier
+    };
+  }
+  async resumeThread(threadId) {
+    if (this.loadedThreadIds.has(threadId)) return;
+    const connection = await this.getConnection();
+    await this.initialize();
+    const params = {
+      threadId,
+      persistExtendedHistory: false
+    };
+    const response = await connection.request(
+      "thread/resume",
+      params,
+      this.requestTimeoutMs
+    );
+    this.loadedThreadIds.add(response.thread.id);
+    this.logger.debug("thread resumed", { threadId: response.thread.id });
+  }
+  async clearThreadGitInfo(threadId) {
+    const connection = await this.getConnection();
+    await this.initialize();
+    await connection.request(
+      "thread/metadata/update",
+      { threadId, gitInfo: { sha: null, branch: null, originUrl: null } },
+      this.requestTimeoutMs
+    );
+  }
+  /**
+   * Public `AgentBackend.startTurn`: accepts NEUTRAL `AgentStartTurnOptions` and
+   * maps them onto Codex-native `UserInput[]`. The neutral `input.text` becomes a
+   * leading `{ type: "text" }` item; each `input.imagePaths` entry becomes a
+   * `{ type: "localImage", path }` item appended after the text. `reasoning`
+   * maps to Codex's `effort`.
+   */
+  async startTurn(opts) {
+    const input = [{ type: "text", text: opts.input.text, text_elements: [] }];
+    for (const path of opts.input.imagePaths ?? []) {
+      input.push({ type: "localImage", path });
+    }
+    const native = { threadId: opts.threadId, input };
+    if (opts.reasoning !== void 0) native.effort = opts.reasoning;
+    return this.startTurnNative(native);
+  }
+  /** Codex-native turn/start. Takes pre-built `UserInput[]`. The neutral
+   *  `startTurn` delegates here after mapping text + image paths. */
+  async startTurnNative(opts) {
+    await this.resumeThread(opts.threadId);
+    const connection = await this.getConnection();
+    await this.initialize();
+    const params = {
+      threadId: opts.threadId,
+      input: opts.input
+    };
+    if (opts.effort !== void 0) params.effort = opts.effort;
+    const response = await connection.request(
+      "turn/start",
+      params,
+      this.turnTimeoutMs
+    );
+    const turnId = response.turn.id;
+    this.logger.debug("turn started", { threadId: opts.threadId, turnId });
+    return { turnId };
+  }
+  async interruptTurn(threadId) {
+    const connection = await this.getConnection();
+    await connection.request("turn/interrupt", { threadId }, this.requestTimeoutMs);
+  }
+  async archiveThread(threadId) {
+    const connection = await this.getConnection();
+    await connection.request("thread/archive", { threadId }, this.requestTimeoutMs);
+  }
+  async close() {
+    const connection = this.connection;
+    this.connection = null;
+    this.initializeResponse = null;
+    this.loadedThreadIds.clear();
+    if (connection) await connection.close();
+  }
+  // ---- internals ----
+  emit(event) {
+    for (const listener of this.eventListeners) listener(event);
+  }
+  async resolveCommand() {
+    if (this.resolvedCommand !== null) return this.resolvedCommand;
+    const resolved = await resolveCodexCommand({
+      command: this.options.command ?? "codex",
+      env: this.options.env ?? process.env
+    });
+    this.resolvedCommand = resolved.command;
+    return resolved.command;
+  }
+  async initialize() {
+    if (this.initializeResponse) return this.initializeResponse;
+    const connection = await this.getConnection();
+    const name = this.options.clientName ?? DEFAULT_CLIENT_NAME;
+    const params = {
+      clientInfo: {
+        name,
+        title: this.options.clientTitle ?? name,
+        version: this.options.clientVersion ?? "0.0.0"
+      },
+      capabilities: {
+        experimentalApi: true,
+        // We don't proxy through OpenAI's edge attestation flow, so opting in
+        // would add per-turn latency for an unused round-trip.
+        requestAttestation: false
+      }
+    };
+    const response = await connection.request(
+      "initialize",
+      params,
+      this.requestTimeoutMs
+    );
+    this.initializeResponse = response;
+    return response;
+  }
+  async getConnection() {
+    if (this.connection) return this.connection;
+    let transport;
+    if (this.transportFactory !== null) {
+      transport = this.transportFactory(this.options.command ?? "codex");
+    } else {
+      const command = await this.resolveCommand();
+      transport = new StdioJsonRpcTransport({
+        command,
+        args: ["app-server"],
+        ...this.options.env !== void 0 ? { env: this.options.env } : {},
+        logger: this.logger
+      });
+    }
+    const connection = new JsonRpcConnection(transport, this.requestTimeoutMs, void 0, {
+      logger: this.logger,
+      logContext: { owner: "codex-thread-client" }
+    });
+    connection.setNotificationHandler((method, params) => {
+      this.handleNotification(method, params);
+    });
+    connection.setRequestHandler((method, params) => this.handleServerRequest(method, params));
+    await connection.connect();
+    this.connection = connection;
+    return connection;
+  }
+  handleNotification(method, params) {
+    const event = normalizeNotification(method, params);
+    if (event !== null) this.emit(event);
+  }
+  async handleServerRequest(method, params) {
+    if (method === CODEX_TOOL_CALL_METHOD) {
+      const handler = this.toolCallHandler;
+      if (!handler) {
+        this.logger.warn("tool call received with no handler registered");
+        return {
+          contentItems: [
+            { type: "inputText", text: "No tool handler is registered for this thread." }
+          ],
+          success: false
+        };
+      }
+      const call = { method, params };
+      return await handler(call);
+    }
+    if (CODEX_APPROVAL_METHODS.has(method)) {
+      const handler = this.approvalHandler;
+      if (!handler) {
+        this.logger.warn("approval request received with no handler registered", { method });
+        return approvalResponseFor("denied");
+      }
+      const decision = await handler(method, params);
+      return approvalResponseFor(decision);
+    }
+    this.logger.debug("unhandled codex server request", { method });
+    return {};
+  }
+};
+
+// src/codex-oneshot-client.ts
+import { mkdir } from "fs/promises";
+import { tmpdir } from "os";
+import { join } from "path";
+import {
+  noopLogger as noopLogger2
+} from "@pwrdrvr/agent-core";
+import {
+  JsonRpcConnection as JsonRpcConnection2,
+  StdioJsonRpcTransport as StdioJsonRpcTransport2
+} from "@pwrdrvr/agent-transport";
+import { resolveCodexCommand as resolveCodexCommand2 } from "@pwrdrvr/codex-discovery";
+var DEFAULT_CLIENT_NAME2 = "agent-kit";
+var DEFAULT_SERVICE_NAME2 = "agent-kit";
+var CodexOneShotClient = class {
+  constructor(options = {}) {
+    this.options = options;
+    this.requestTimeoutMs = options.requestTimeoutMs ?? 2e4;
+    this.turnTimeoutMs = options.turnTimeoutMs ?? 12e4;
+    this.logger = options.logger ?? noopLogger2;
+    this.transportFactory = options.transportFactory ?? null;
+  }
+  options;
+  requestTimeoutMs;
+  turnTimeoutMs;
+  logger;
+  transportFactory;
+  resolvedCommand = null;
+  connection = null;
+  initializeResponse = null;
+  pendingTurn = null;
+  workerThread = null;
+  queue = Promise.resolve();
+  /** Run one structured-output turn. Calls are serialized — only one turn is in
+   *  flight at a time against the shared worker thread. */
+  async run(request) {
+    const run = this.queue.catch(() => void 0).then(() => this.runInner(request));
+    this.queue = run.then(
+      () => void 0,
+      () => void 0
+    );
+    return run;
+  }
+  async runInner(request) {
+    const connection = await this.getConnection();
+    const initialized = await this.initialize();
+    let thread = null;
+    let turnId = null;
+    let rolledBack = false;
+    let aborted = false;
+    const abortHandler = () => {
+      aborted = true;
+      if (thread && turnId) {
+        void connection.request("turn/interrupt", { threadId: thread.threadId, turnId }, this.requestTimeoutMs).catch((error) => {
+          this.logger.warn("turn interrupt failed", {
+            error: error instanceof Error ? error.message : String(error)
+          });
+        });
+      }
+    };
+    request.abortSignal?.addEventListener("abort", abortHandler, { once: true });
+    try {
+      if (request.abortSignal?.aborted) {
+        throw new DOMException("one-shot turn aborted", "AbortError");
+      }
+      thread = await this.getWorkerThread(
+        request.model ?? null,
+        request.modelProvider ?? null,
+        request.baseInstructions ?? ""
+      );
+      const input = [
+        { type: "text", text: request.prompt, text_elements: [] },
+        ...imagePathsToLocalImageInputs(request.imagePaths ?? [])
+      ];
+      const turnResponse = await connection.request(
+        "turn/start",
+        {
+          threadId: thread.threadId,
+          model: request.model ?? null,
+          input,
+          effort: request.effort ?? "low",
+          ...request.outputSchema !== void 0 ? { outputSchema: request.outputSchema } : {}
+        },
+        this.requestTimeoutMs
+      );
+      turnId = turnResponse.turn.id;
+      if (request.abortSignal?.aborted || aborted) {
+        throw new DOMException("one-shot turn aborted", "AbortError");
+      }
+      const { rawText, tokenUsage } = await this.waitForTurn(thread.threadId, turnId);
+      await this.rollbackWorkerThread(thread.threadId);
+      rolledBack = true;
+      return {
+        rawText,
+        threadId: thread.threadId,
+        turnId,
+        userAgent: initialized.userAgent,
+        model: thread.model,
+        modelProvider: thread.modelProvider,
+        serviceTier: thread.serviceTier,
+        tokenUsage: tokenUsage === null ? null : normalizeTokenUsage(tokenUsage)
+      };
+    } finally {
+      request.abortSignal?.removeEventListener("abort", abortHandler);
+      if (thread && turnId && !rolledBack) {
+        await this.rollbackWorkerThread(thread.threadId).catch((error) => {
+          this.logger.warn("worker thread rollback failed", {
+            threadId: thread?.threadId,
+            error: error instanceof Error ? error.message : String(error)
+          });
+        });
+      }
+    }
+  }
+  async listModels(input = {}) {
+    const connection = await this.getConnection();
+    await this.initialize();
+    const models = [];
+    let cursor = null;
+    do {
+      const response = await connection.request(
+        "model/list",
+        { cursor, limit: 100, includeHidden: input.includeHidden ?? false },
+        this.requestTimeoutMs
+      );
+      models.push(...response.data.map(modelToOption));
+      cursor = response.nextCursor;
+    } while (cursor !== null);
+    return models;
+  }
+  async close() {
+    const connection = this.connection;
+    const thread = this.workerThread;
+    this.connection = null;
+    this.initializeResponse = null;
+    this.workerThread = null;
+    this.queue = Promise.resolve();
+    if (connection) {
+      if (thread) {
+        await connection.request("thread/archive", { threadId: thread.threadId }, this.requestTimeoutMs).catch((error) => {
+          this.logger.warn("thread archive failed", {
+            threadId: thread.threadId,
+            error: error instanceof Error ? error.message : String(error)
+          });
+        });
+      }
+      await connection.close();
+    }
+  }
+  // ---- worker-thread management ----
+  async getWorkerThread(model, modelProvider, baseInstructions) {
+    const modelKey = `${model ?? "__default__"}@${modelProvider ?? "__default__"}::${baseInstructions}`;
+    if (this.workerThread?.modelKey === modelKey) {
+      return this.workerThread;
+    }
+    if (this.workerThread) {
+      const stale = this.workerThread;
+      this.workerThread = null;
+      const connection2 = await this.getConnection();
+      await connection2.request("thread/archive", { threadId: stale.threadId }, this.requestTimeoutMs).catch((error) => {
+        this.logger.warn("thread archive failed", {
+          threadId: stale.threadId,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      });
+    }
+    const connection = await this.getConnection();
+    const workspaceDir = await this.prepareWorkspace();
+    const threadResponse = await connection.request(
+      "thread/start",
+      {
+        model,
+        ...modelProvider !== null ? { modelProvider } : {},
+        ephemeral: false,
+        cwd: workspaceDir,
+        runtimeWorkspaceRoots: [workspaceDir],
+        serviceName: this.options.serviceName ?? DEFAULT_SERVICE_NAME2,
+        approvalPolicy: "never",
+        sandbox: "read-only",
+        ...baseInstructions.length > 0 ? { baseInstructions } : {},
+        // Persistent worker thread for a prompt-cache experiment: keep the
+        // thread id stable across requests, then roll back each turn. The
+        // dedicated cwd keeps the worker out of any host repo/worktree.
+        ...this.options.threadConfig !== void 0 ? { config: this.options.threadConfig } : {},
+        environments: [],
+        experimentalRawEvents: false,
+        persistExtendedHistory: false
+      },
+      this.requestTimeoutMs
+    );
+    await this.clearThreadGitInfo(threadResponse.thread.id);
+    await this.setWorkerThreadName(threadResponse.thread.id);
+    this.workerThread = {
+      threadId: threadResponse.thread.id,
+      modelKey,
+      baseInstructions,
+      model: threadResponse.model,
+      modelProvider: threadResponse.modelProvider,
+      serviceTier: threadResponse.serviceTier
+    };
+    return this.workerThread;
+  }
+  async rollbackWorkerThread(threadId) {
+    const connection = await this.getConnection();
+    await connection.request("thread/rollback", { threadId, numTurns: 1 }, this.requestTimeoutMs);
+  }
+  async prepareWorkspace() {
+    const workspaceDir = this.options.workspaceDir ?? join(tmpdir(), "agent-kit", "oneshot-worker");
+    await mkdir(workspaceDir, { recursive: true });
+    return workspaceDir;
+  }
+  async clearThreadGitInfo(threadId) {
+    const connection = await this.getConnection();
+    await connection.request(
+      "thread/metadata/update",
+      { threadId, gitInfo: { sha: null, branch: null, originUrl: null } },
+      this.requestTimeoutMs
+    ).catch((error) => {
+      this.logger.warn("thread git metadata clear failed", {
+        threadId,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    });
+  }
+  async setWorkerThreadName(threadId) {
+    const connection = await this.getConnection();
+    await connection.request(
+      "thread/name/set",
+      { threadId, name: this.options.workerThreadName ?? "agent-kit One-Shot Worker" },
+      this.requestTimeoutMs
+    ).catch((error) => {
+      this.logger.warn("worker thread name set failed", {
+        threadId,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    });
+  }
+  // ---- connection / turn plumbing ----
+  async resolveCommand() {
+    if (this.resolvedCommand !== null) return this.resolvedCommand;
+    const resolved = await resolveCodexCommand2({
+      command: this.options.command ?? "codex",
+      env: this.options.env ?? process.env
+    });
+    this.resolvedCommand = resolved.command;
+    return resolved.command;
+  }
+  async initialize() {
+    if (this.initializeResponse) return this.initializeResponse;
+    const connection = await this.getConnection();
+    const name = this.options.clientName ?? DEFAULT_CLIENT_NAME2;
+    const params = {
+      clientInfo: {
+        name,
+        title: this.options.clientTitle ?? name,
+        version: this.options.clientVersion ?? "0.0.0"
+      },
+      capabilities: {
+        experimentalApi: true,
+        requestAttestation: false
+      }
+    };
+    const response = await connection.request(
+      "initialize",
+      params,
+      this.requestTimeoutMs
+    );
+    this.initializeResponse = response;
+    return response;
+  }
+  async getConnection() {
+    if (this.connection) return this.connection;
+    let transport;
+    if (this.transportFactory !== null) {
+      transport = this.transportFactory(this.options.command ?? "codex");
+    } else {
+      const command = await this.resolveCommand();
+      transport = new StdioJsonRpcTransport2({
+        command,
+        args: ["app-server"],
+        ...this.options.env !== void 0 ? { env: this.options.env } : {},
+        logger: this.logger
+      });
+    }
+    const connection = new JsonRpcConnection2(transport, this.requestTimeoutMs, void 0, {
+      logger: this.logger,
+      logContext: { owner: "codex-oneshot-client" }
+    });
+    connection.setNotificationHandler((method, params) => {
+      this.handleNotification(method, params);
+    });
+    connection.setRequestHandler((method, params) => this.handleServerRequest(method, params));
+    await connection.connect();
+    this.connection = connection;
+    return connection;
+  }
+  waitForTurn(threadId, turnId) {
+    if (this.pendingTurn) {
+      throw new Error("codex one-shot client already has an active turn");
+    }
+    return new Promise(
+      (resolve, reject) => {
+        const timer = setTimeout(() => {
+          this.pendingTurn = null;
+          reject(new Error("codex one-shot turn timed out"));
+        }, this.turnTimeoutMs);
+        this.pendingTurn = {
+          threadId,
+          turnId,
+          agentMessages: [],
+          tokenUsage: null,
+          resolve,
+          reject,
+          timer
+        };
+      }
+    );
+  }
+  handleNotification(method, params) {
+    if (method === "item/completed") {
+      this.handleItemCompleted(params);
+      return;
+    }
+    if (method === "rawResponseItem/completed") {
+      this.handleRawResponseItemCompleted(params);
+      return;
+    }
+    if (method === "thread/tokenUsage/updated") {
+      this.handleThreadTokenUsageUpdated(params);
+      return;
+    }
+    if (method === "turn/completed") {
+      this.handleTurnCompleted(params);
+    }
+  }
+  handleItemCompleted(params) {
+    const pending = this.pendingTurn;
+    if (!pending || params.threadId !== pending.threadId || params.turnId !== pending.turnId) {
+      return;
+    }
+    if (params.item.type === "agentMessage") {
+      pending.agentMessages.push(params.item.text);
+    }
+  }
+  handleRawResponseItemCompleted(params) {
+    const pending = this.pendingTurn;
+    if (!pending || typeof params !== "object" || params === null) {
+      return;
+    }
+    const maybe = params;
+    if (maybe.threadId !== pending.threadId || maybe.turnId !== pending.turnId) {
+      return;
+    }
+    const item = maybe.item;
+    if (item?.type !== "message" || item.role !== "assistant") {
+      return;
+    }
+    const text = item.content.filter((content) => content.type === "output_text").map((content) => content.text).join("");
+    if (text) {
+      pending.agentMessages.push(text);
+    }
+  }
+  handleTurnCompleted(params) {
+    const pending = this.pendingTurn;
+    if (!pending || params.threadId !== pending.threadId || params.turn.id !== pending.turnId) {
+      return;
+    }
+    clearTimeout(pending.timer);
+    this.pendingTurn = null;
+    if (params.turn.status === "failed") {
+      pending.reject(new Error(params.turn.error?.message ?? "codex one-shot turn failed"));
+      return;
+    }
+    if (params.turn.status === "interrupted") {
+      pending.reject(new DOMException("one-shot turn aborted", "AbortError"));
+      return;
+    }
+    const rawText = pending.agentMessages.at(-1)?.trim();
+    if (!rawText) {
+      pending.reject(new Error("codex one-shot turn returned no assistant message"));
+      return;
+    }
+    pending.resolve({ rawText, tokenUsage: pending.tokenUsage });
+  }
+  handleThreadTokenUsageUpdated(params) {
+    const pending = this.pendingTurn;
+    if (!pending || params.threadId !== pending.threadId || params.turnId !== pending.turnId) {
+      return;
+    }
+    pending.tokenUsage = params.tokenUsage;
+  }
+  async handleServerRequest(method, _params) {
+    if (method === "item/tool/call") {
+      return {
+        contentItems: [
+          { type: "inputText", text: "This one-shot run does not expose tools." }
+        ],
+        success: false
+      };
+    }
+    this.logger.debug("unhandled codex server request", { method });
+    return {};
+  }
+};
+function modelToOption(model) {
+  return {
+    id: model.id,
+    model: model.model,
+    displayName: model.displayName,
+    description: model.description,
+    hidden: model.hidden,
+    inputModalities: model.inputModalities,
+    defaultServiceTier: model.defaultServiceTier,
+    isDefault: model.isDefault
+  };
+}
+function imagePathsToLocalImageInputs(imagePaths) {
+  return imagePaths.map((path) => ({ type: "localImage", path }));
+}
+
+// src/codex-thread-config.ts
+var DISABLE_CODING_AGENT_THREAD_CONFIG = {
+  web_search: "disabled",
+  include_permissions_instructions: false,
+  include_apps_instructions: false,
+  include_collaboration_mode_instructions: false,
+  include_environment_context: false,
+  skills: {
+    include_instructions: false
+  },
+  features: {
+    apps: false,
+    plugins: false,
+    tool_suggest: false,
+    image_generation: false,
+    multi_agent: false,
+    goals: false
+  }
+};
+
+// src/chat/define-tool.ts
+import { z } from "zod";
+function defineTool(spec) {
+  return spec;
+}
+function toDynamicToolSpec(spec) {
+  return {
+    namespace: spec.namespace,
+    name: spec.name,
+    description: spec.description,
+    inputSchema: z.toJSONSchema(spec.argsSchema)
+  };
+}
+
+// src/chat/tool-catalog.ts
+import "zod";
+function buildToolCatalog(catalog) {
+  return catalog.map(toDynamicToolSpec);
+}
+async function dispatchToolCall(params, catalog) {
+  const entry = catalog.find((tool) => tool.name === params.tool);
+  if (entry === void 0) {
+    return errorResponse(`Unknown tool: ${params.tool}`);
+  }
+  if (params.namespace !== null && params.namespace !== entry.namespace) {
+    return errorResponse(`Tool "${params.tool}" is not in namespace "${params.namespace}".`);
+  }
+  const parsed = entry.argsSchema.safeParse(params.arguments);
+  if (!parsed.success) {
+    return errorResponse(`Invalid arguments for "${params.tool}": ${formatZodError(parsed.error)}`);
+  }
+  let result;
+  try {
+    result = await entry.dispatch(parsed.data, { threadId: params.threadId });
+  } catch (cause) {
+    return errorResponse(
+      `Tool "${params.tool}" failed: ${cause instanceof Error ? cause.message : String(cause)}`
+    );
+  }
+  if (!result.ok) {
+    return errorResponse(result.error);
+  }
+  if ("contentItems" in result) {
+    return { success: true, contentItems: result.contentItems };
+  }
+  return {
+    success: true,
+    contentItems: [{ type: "inputText", text: JSON.stringify(result.data) }]
+  };
+}
+function errorResponse(message) {
+  return {
+    success: false,
+    contentItems: [{ type: "inputText", text: message }]
+  };
+}
+function formatZodError(error) {
+  return error.issues.map((issue) => {
+    const path = issue.path.join(".");
+    return path.length > 0 ? `${path}: ${issue.message}` : issue.message;
+  }).join("; ");
+}
+
+// src/chat/chat-thread-controller.ts
+import {
+  noopLogger as noopLogger3
+} from "@pwrdrvr/agent-core";
+var RATE_LIMIT_TURNS = 5;
+var RATE_LIMIT_WINDOW_MS = 6e4;
+var ChatThreadController = class {
+  deps;
+  logger;
+  turns = /* @__PURE__ */ new Map();
+  pendingApprovals = /* @__PURE__ */ new Map();
+  /** Per-thread recent turn timestamps for rate limiting. */
+  turnTimestamps = /* @__PURE__ */ new Map();
+  threadModels = /* @__PURE__ */ new Map();
+  wired = false;
+  constructor(deps) {
+    this.deps = deps;
+    this.logger = deps.logger ?? noopLogger3;
+  }
+  /** Wire the shared backend's subscription hooks ONCE. Idempotent. */
+  wire() {
+    if (this.wired) return;
+    this.wired = true;
+    const { client } = this.deps;
+    client.onEvent((event) => this.onBackendEvent(event));
+    client.onToolCall((call) => this.onToolCall(call));
+    client.onApprovalRequest((method, params) => this.onApprovalRequest(method, params));
+  }
+  now() {
+    return this.deps.now ? this.deps.now() : Date.now();
+  }
+  // ---- thread lifecycle ----
+  async createThread(opts = {}) {
+    const anchorId = opts.anchorId ?? null;
+    const settings = await this.deps.readSettings();
+    const baseInstructions = this.deps.buildSystemPrompt({ settings, anchorId });
+    const displayName = opts.name && opts.name.trim().length > 0 ? opts.name.trim() : this.defaultName();
+    const preparedDir = await this.deps.store.prepareThreadDir(displayName);
+    const startOptions = {
+      instructions: baseInstructions,
+      cwd: preparedDir.path,
+      workspaceRoots: [preparedDir.path]
+    };
+    if (this.deps.approvalPolicy !== void 0) startOptions.approvalPolicy = this.deps.approvalPolicy;
+    if (this.deps.sandbox !== void 0) startOptions.sandbox = this.deps.sandbox;
+    if (this.deps.model !== void 0) startOptions.model = this.deps.model;
+    if (this.deps.modelProvider !== void 0) startOptions.modelProvider = this.deps.modelProvider;
+    if (this.deps.serviceName !== void 0) startOptions.serviceName = this.deps.serviceName;
+    if (this.deps.catalog !== void 0) startOptions.tools = this.deps.catalog;
+    if (this.deps.threadConfig !== void 0) startOptions.config = this.deps.threadConfig;
+    if (this.deps.threadEnvironments !== void 0) {
+      startOptions.environments = this.deps.threadEnvironments;
+    }
+    let started;
+    try {
+      started = await this.deps.client.startThread(startOptions);
+    } catch (cause) {
+      await this.deps.store.discardPreparedThreadDir(preparedDir).catch(() => void 0);
+      throw cause;
+    }
+    await this.deps.client.clearThreadGitInfo?.(started.threadId).catch((cause) => {
+      this.logger.warn("chat thread git metadata clear failed", {
+        threadId: started.threadId,
+        message: cause instanceof Error ? cause.message : String(cause)
+      });
+    });
+    this.threadModels.set(started.threadId, {
+      model: started.model ?? null,
+      modelProvider: started.modelProvider ?? null,
+      serviceTier: started.serviceTier ?? null
+    });
+    const record = await this.deps.store.create({
+      threadId: started.threadId,
+      name: displayName,
+      anchorId,
+      preparedDir
+    });
+    const view = this.toView(record);
+    this.deps.broadcast({ type: "thread_updated", thread: view });
+    return view;
+  }
+  async listThreads(opts = {}) {
+    const listOpts = {
+      includeArchived: opts.includeArchived ?? false,
+      ...opts.anchorId !== void 0 ? { anchorId: opts.anchorId } : {}
+    };
+    const records = await this.deps.store.list(listOpts);
+    return records.map((r) => this.toView(r));
+  }
+  async rename(threadId, name) {
+    const record = await this.deps.store.update(threadId, { name: name.trim() });
+    const view = this.toView(record);
+    this.deps.broadcast({ type: "thread_updated", thread: view });
+    return view;
+  }
+  async archive(threadId, archived) {
+    const record = await this.deps.store.update(threadId, { archived });
+    if (archived) await this.deps.client.archiveThread?.(threadId).catch(() => void 0);
+    const view = this.toView(record);
+    this.deps.broadcast({ type: "thread_updated", thread: view });
+    return view;
+  }
+  // ---- turns ----
+  async sendMessage(input) {
+    const { threadId } = input;
+    if (this.turns.has(threadId)) {
+      throw new Error("a turn is already in progress for this thread");
+    }
+    this.enforceRateLimit(threadId);
+    if (input.anchorId !== void 0 && input.anchorId !== null) {
+      await this.deps.store.appendAnchor(threadId, input.anchorId);
+    }
+    const userMessage = {
+      id: this.randomId(),
+      role: "user",
+      text: input.text,
+      createdAt: this.now()
+    };
+    await this.commitMessage(threadId, userMessage);
+    const settingsSnapshot = await this.deps.readSettings();
+    const anchorForTurn = input.anchorId ?? await this.currentAnchor(threadId);
+    let turnText = input.text;
+    if (anchorForTurn !== null && this.deps.buildTurnContext !== void 0) {
+      turnText = `${this.deps.buildTurnContext(anchorForTurn)}
+
+${input.text}`;
+    }
+    const turnInput = { text: turnText };
+    if (input.imagePaths !== void 0) turnInput.imagePaths = input.imagePaths;
+    const startTurnOptions = {
+      threadId,
+      input: turnInput,
+      reasoning: this.deps.effort ?? "medium"
+    };
+    let turnId;
+    try {
+      const started = await this.deps.client.startTurn(startTurnOptions);
+      turnId = started.turnId;
+    } catch (cause) {
+      const failed = {
+        id: this.randomId(),
+        role: "assistant",
+        text: "",
+        createdAt: this.now()
+      };
+      await this.commitMessage(threadId, failed);
+      this.logger.warn("chat turn start failed", {
+        threadId,
+        message: cause instanceof Error ? cause.message : String(cause)
+      });
+      throw cause;
+    }
+    const assistantMessageId = this.randomId();
+    this.turns.set(threadId, {
+      turnId,
+      assistantMessageId,
+      buffer: "",
+      settingsSnapshot,
+      tokenUsage: null
+    });
+    this.recordTurn(threadId);
+    await this.broadcastThreadStatus(threadId, { kind: "streaming", turnId });
+    return { turnId };
+  }
+  async getHistory(threadId) {
+    return this.readJournalMessages(threadId);
+  }
+  async interrupt(threadId) {
+    const turn = this.turns.get(threadId);
+    if (turn === void 0) return;
+    await this.deps.client.interruptTurn(threadId).catch(() => void 0);
+    await this.finalizeAssistant(threadId, "interrupted");
+    this.deps.broadcast({ type: "turn_interrupted", threadId, turnId: turn.turnId });
+  }
+  // ---- approval flow ----
+  async resolveApproval(input) {
+    const key = approvalKey(input.threadId, input.turnId, input.approvalId);
+    const pending = this.pendingApprovals.get(key);
+    if (pending === void 0) {
+      this.logger.warn("resolveApproval: no matching pending approval (stale?)", { key });
+      return;
+    }
+    this.pendingApprovals.delete(key);
+    pending.resolve(input.decision);
+  }
+  // ---- backend subscription handlers ----
+  onBackendEvent(event) {
+    switch (event.kind) {
+      case "agent_message_delta":
+        this.onDelta(event.threadId, event.turnId, event.itemId, event.delta);
+        return;
+      case "token_usage":
+        this.onTokenUsage(event.threadId, event.turnId, event.usage);
+        return;
+      case "thread_settings":
+        this.threadModels.set(event.settings.threadId, {
+          model: event.settings.model ?? null,
+          modelProvider: event.settings.modelProvider ?? null,
+          serviceTier: event.settings.serviceTier ?? null
+        });
+        return;
+      case "turn_completed":
+        void this.onTurnCompleted(event.threadId, event.turnId, event.status);
+        return;
+      default:
+        return;
+    }
+  }
+  onDelta(threadId, turnId, itemId, delta) {
+    const turn = this.turns.get(threadId);
+    if (turn === void 0 || turn.turnId !== turnId) return;
+    turn.buffer += delta;
+    this.deps.broadcast({
+      type: "stream_delta",
+      threadId,
+      turnId,
+      messageId: turn.assistantMessageId,
+      delta
+    });
+  }
+  async onTurnCompleted(threadId, turnId, status) {
+    const turn = this.turns.get(threadId);
+    if (turn === void 0 || turn.turnId !== turnId) return;
+    await this.finalizeAssistant(threadId, status);
+  }
+  onTokenUsage(threadId, turnId, usage) {
+    const turn = this.turns.get(threadId);
+    if (turn === void 0 || turn.turnId !== turnId) return;
+    turn.tokenUsage = usage;
+  }
+  async onToolCall(call) {
+    const params = call.params;
+    const response = this.deps.dispatchToolCall ? await this.deps.dispatchToolCall(params) : {
+      contentItems: [{ type: "inputText", text: "No tools are enabled for this chat yet." }],
+      success: false
+    };
+    this.deps.broadcast({
+      type: "tool_call",
+      threadId: params.threadId,
+      turnId: params.turnId,
+      toolCall: {
+        id: params.callId,
+        name: params.tool,
+        kind: "other",
+        label: humanizeToolCall(params.tool, response.success, this.deps.toolLabels),
+        status: response.success ? "completed" : "failed",
+        args: params.arguments,
+        result: response
+      }
+    });
+    return response;
+  }
+  async onApprovalRequest(method, params) {
+    const p = params ?? {};
+    let threadId = typeof p.threadId === "string" ? p.threadId : "";
+    let turnId = typeof p.turnId === "string" ? p.turnId : "";
+    if (threadId.length === 0) {
+      const onlyEntry = this.turns.size === 1 ? [...this.turns.entries()][0] : void 0;
+      if (onlyEntry !== void 0) {
+        const [onlyThreadId, onlyTurn] = onlyEntry;
+        threadId = onlyThreadId;
+        if (turnId.length === 0) turnId = onlyTurn.turnId;
+      } else {
+        this.logger.warn("approval request without a routable threadId \u2014 auto-denying", {
+          method,
+          inFlightTurns: this.turns.size
+        });
+        return "denied";
+      }
+    }
+    const approvalId = this.randomId();
+    const request = normalizeApprovalParams(method, params, approvalId);
+    const decision = await new Promise((resolve) => {
+      this.pendingApprovals.set(approvalKey(threadId, turnId, approvalId), {
+        threadId,
+        turnId,
+        approvalId,
+        resolve
+      });
+      this.deps.broadcast({ type: "approval_requested", threadId, turnId, approval: request });
+      void this.broadcastThreadStatus(threadId, { kind: "awaiting_approval", approvalId });
+    });
+    const turn = this.turns.get(threadId);
+    void this.broadcastThreadStatus(
+      threadId,
+      turn ? { kind: "streaming", turnId: turn.turnId } : { kind: "idle" }
+    );
+    return decision;
+  }
+  // ---- internals ----
+  async finalizeAssistant(threadId, status) {
+    const turn = this.turns.get(threadId);
+    if (turn === void 0) return;
+    this.turns.delete(threadId);
+    const message = {
+      id: turn.assistantMessageId,
+      role: "assistant",
+      text: turn.buffer,
+      createdAt: this.now()
+    };
+    this.recordUsage(threadId, turn).catch((cause) => {
+      this.logger.warn("chat usage accounting failed", {
+        threadId,
+        turnId: turn.turnId,
+        message: cause instanceof Error ? cause.message : String(cause)
+      });
+    });
+    await this.commitMessage(threadId, message);
+    await this.broadcastThreadStatus(threadId, { kind: "idle" });
+  }
+  async recordUsage(threadId, turn) {
+    if (turn.tokenUsage === null) return;
+    const model = this.threadModels.get(threadId);
+    const usage = turn.tokenUsage;
+    await this.deps.store.recordUsage({
+      threadId,
+      turnId: turn.turnId,
+      ...model?.model != null ? { model: model.model } : {},
+      usage,
+      ...usage.contextWindow !== void 0 ? { contextWindow: usage.contextWindow } : {},
+      at: this.now()
+    });
+  }
+  async commitMessage(threadId, message) {
+    const entry = { kind: "message", message };
+    await this.deps.store.journalAppend(threadId, entry);
+    this.deps.broadcast({ type: "message_committed", threadId, message });
+  }
+  async readJournalMessages(threadId) {
+    const entries = await this.deps.store.readJournal(threadId).catch(() => []);
+    const messages = [];
+    for (const entry of entries) {
+      if (entry !== null && typeof entry === "object" && entry.kind === "message") {
+        const m = entry.message;
+        if (m !== void 0) messages.push(m);
+      }
+    }
+    return messages;
+  }
+  async currentAnchor(threadId) {
+    const record = await this.deps.store.get(threadId);
+    return record?.anchorId ?? null;
+  }
+  enforceRateLimit(threadId) {
+    const stamps = this.turnTimestamps.get(threadId) ?? [];
+    const cutoff = this.now() - RATE_LIMIT_WINDOW_MS;
+    const recent = stamps.filter((t) => t >= cutoff);
+    if (recent.length >= RATE_LIMIT_TURNS) {
+      throw new Error(`rate limit: max ${RATE_LIMIT_TURNS} turns per minute for this thread`);
+    }
+  }
+  recordTurn(threadId) {
+    const stamps = this.turnTimestamps.get(threadId) ?? [];
+    const cutoff = this.now() - RATE_LIMIT_WINDOW_MS;
+    const recent = stamps.filter((t) => t >= cutoff);
+    recent.push(this.now());
+    this.turnTimestamps.set(threadId, recent);
+  }
+  async broadcastThreadStatus(threadId, status) {
+    const record = await this.deps.store.get(threadId);
+    if (record === null) return;
+    this.deps.broadcast({ type: "thread_updated", thread: this.toView(record, status) });
+  }
+  toView(record, status) {
+    const turn = this.turns.get(record.threadId);
+    const resolved = status ?? (turn !== void 0 ? { kind: "streaming", turnId: turn.turnId } : { kind: "idle" });
+    return {
+      threadId: record.threadId,
+      name: record.name,
+      createdAt: record.createdAt,
+      modifiedAt: record.modifiedAt,
+      anchorId: record.anchorId,
+      archived: record.archived,
+      pinned: record.pinned,
+      lastMessagePreview: "",
+      status: resolved
+    };
+  }
+  defaultName() {
+    return `Chat ${localDateStamp(new Date(this.now()))}`;
+  }
+  randomId() {
+    return globalThis.crypto.randomUUID();
+  }
+};
+function localDateStamp(d) {
+  const year = d.getFullYear();
+  const month = String(d.getMonth() + 1).padStart(2, "0");
+  const day = String(d.getDate()).padStart(2, "0");
+  return `${year}-${month}-${day}`;
+}
+function approvalKey(threadId, turnId, approvalId) {
+  return `${threadId}::${turnId}::${approvalId}`;
+}
+function humanizeToolCall(tool, ok, labels = {}) {
+  const label = labels[tool] ?? tool;
+  return ok ? label : `Couldn't: ${label.toLowerCase()}`;
+}
+function normalizeApprovalParams(method, params, approvalId) {
+  const p = params ?? {};
+  const summary = typeof p.summary === "string" ? p.summary : typeof p.reason === "string" ? p.reason : typeof p.command === "string" ? p.command : void 0;
+  const kind = method.includes("commandExecution") ? "exec" : method.includes("fileChange") ? "patch" : method.includes("tool") ? "tool" : "other";
+  const request = { id: approvalId, method, kind, params };
+  if (summary !== void 0) request.summary = summary;
+  return request;
+}
+export {
+  CODEX_APPROVAL_METHODS,
+  CODEX_NOTIFICATION_METHODS,
+  CODEX_TOOL_CALL_METHOD,
+  ChatThreadController,
+  CodexOneShotClient,
+  CodexThreadClient,
+  DISABLE_CODING_AGENT_THREAD_CONFIG,
+  buildToolCatalog,
+  defineTool,
+  dispatchToolCall,
+  localDateStamp,
+  normalizeApprovalRequest,
+  normalizeDynamicToolCall,
+  normalizeNotification,
+  normalizeThreadItemToolCall,
+  normalizeThreadSettings,
+  normalizeTokenUsage,
+  toDynamicToolSpec
+};
+//# sourceMappingURL=index.js.map