@midhunxavier/code-flow 0.0.0-stage → 0.1.0-preview.3

package/src/adapters/codex-app-server.js

@@ -0,0 +1,555 @@
+import { lstatSync, realpathSync } from "node:fs";
+import { dirname, isAbsolute, relative, resolve, sep } from "node:path";
+import { classifyError, cliErrorLine } from "./errors.js";
+import { startJsonlProcess, stderrTail, stringify, truncate } from "./process.js";
+const CLIENT_INFO = { name: "code_flow", title: "code-flow", version: "0.1.0" };
+const QUIET = [
+  "item/plan/delta",
+  "item/reasoning/summaryPartAdded",
+  "item/reasoning/textDelta",
+  "item/fileChange/outputDelta",
+  "item/fileChange/patchUpdated",
+  "turn/diff/updated"
+];
+const IGNORED = /* @__PURE__ */ new Set([
+  ...QUIET,
+  "thread/started",
+  "thread/closed",
+  "thread/status/changed",
+  "thread/name/updated",
+  "thread/archived",
+  "thread/unarchived",
+  "thread/compacted",
+  "account/updated",
+  "account/rateLimits/updated",
+  "account/login/completed",
+  "mcpServer/oauthLogin/completed",
+  "mcpServer/startupStatus/updated",
+  "item/mcpToolCall/progress",
+  "item/commandExecution/terminalInteraction",
+  "rawResponseItem/completed",
+  "serverRequest/resolved",
+  "model/rerouted",
+  "deprecationNotice",
+  "configWarning",
+  "windows/worldWritableWarning",
+  "fuzzyFileSearch/sessionUpdated",
+  "fuzzyFileSearch/sessionCompleted",
+  "sessionConfigured",
+  "authStatusChange",
+  "loginChatGptComplete"
+]);
+const IGNORED_ITEMS = /* @__PURE__ */ new Set(["userMessage", "contextCompaction", "enteredReviewMode", "exitedReviewMode", "imageView", "plan"]);
+const INIT_TIMEOUT_MS = 2e4;
+const REQUEST_TIMEOUT_MS = 2 * 6e4;
+const INTERRUPT_MS = 3e3;
+const SHUTDOWN_MS = 5e3;
+class RpcError extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
+}
+class RpcTimeout extends Error {
+  constructor(method, ms) {
+    super(`${method} got no answer within ${seconds(ms)}`);
+  }
+}
+class TurnError extends Error {
+  constructor(message, kind) {
+    super(message);
+    this.kind = kind;
+  }
+}
+async function runAppServerTurn(turn) {
+  let threadId;
+  let turnId;
+  let turnStarted = false;
+  let turnEnded = false;
+  let completed;
+  const turnDone = new Promise((resolve2) => completed = resolve2);
+  let tokensBefore;
+  let tokensNow;
+  let nextId = 1;
+  const pending = /* @__PURE__ */ new Map();
+  let exit;
+  const approvalRequests = /* @__PURE__ */ new Map();
+  const approvalItems = /* @__PURE__ */ new Map();
+  const stop = new AbortController();
+  const proc = startJsonlProcess({
+    command: "codex",
+    args: ["app-server", ...turn.config],
+    cwd: turn.cwd,
+    signal: stop.signal,
+    timeoutMs: turn.timeoutMs,
+    idleTimeoutMs: turn.idleTimeoutMs,
+    isPaused: turn.isPaused,
+    interactive: true,
+    agentContainer: turn.agentContainer ? { config: turn.agentContainer, mode: turn.sandbox === "read-only" ? "read" : "write" } : void 0,
+    onText: turn.onText,
+    onJson: (msg) => {
+      if (msg.method === void 0 && msg.id !== void 0) {
+        const waiter = pending.get(msg.id);
+        pending.delete(msg.id);
+        if (msg.error) waiter?.reject(new RpcError(msg.error.code, msg.error.message ?? stringify(msg.error)));
+        else waiter?.resolve(msg.result);
+      } else if (msg.id !== void 0) {
+        answerServerRequest(msg);
+      } else {
+        onNotification(msg.method, msg.params ?? {});
+      }
+    }
+  });
+  const exited = proc.outcome.then((outcome) => {
+    exit = outcome;
+    abortApprovals(false);
+    for (const waiter of pending.values()) waiter.reject(new Error("codex app-server exited"));
+    pending.clear();
+    return outcome;
+  });
+  const request = (method, params, timeoutMs = turn.requestTimeoutMs ?? REQUEST_TIMEOUT_MS) => new Promise((resolve2, reject) => {
+    if (exit) return reject(new Error("codex app-server exited"));
+    const id = nextId++;
+    const timer = setTimeout(() => {
+      pending.delete(id);
+      reject(new RpcTimeout(method, timeoutMs));
+    }, timeoutMs);
+    pending.set(id, {
+      resolve: (result) => {
+        clearTimeout(timer);
+        resolve2(result);
+      },
+      reject: (err) => {
+        clearTimeout(timer);
+        reject(err);
+      }
+    });
+    if (!proc.send({ id, method, params })) {
+      pending.delete(id);
+      clearTimeout(timer);
+      reject(new Error("codex app-server isn't accepting input"));
+    }
+  });
+  function onNotification(method, params) {
+    if (params.threadId && threadId && params.threadId !== threadId) return;
+    if (params.turnId && turnId && params.turnId !== turnId) return;
+    switch (method) {
+      case "item/agentMessage/delta":
+      case "item/reasoning/summaryTextDelta":
+      case "item/commandExecution/outputDelta":
+        if (typeof params.delta === "string" && typeof params.itemId === "string") {
+          turn.onMessage({ type: "item.delta", item: { id: params.itemId, type: method === "item/agentMessage/delta" ? "agent_message" : method === "item/reasoning/summaryTextDelta" ? "reasoning" : "command_execution", text: params.delta } });
+        }
+        break;
+      case "turn/started":
+        turnId ??= params.turn?.id;
+        break;
+      case "item/started":
+      case "item/completed": {
+        if (method === "item/started" && params.item?.id && params.threadId === threadId && params.turnId === turnId) {
+          if (approvalItems.size < 256) approvalItems.set(params.item.id, params.item);
+        }
+        if (method === "item/completed") approvalItems.delete(params.item?.id);
+        const item = execItem(params.item);
+        if (item) turn.onMessage({ type: method === "item/started" ? "item.started" : "item.completed", item });
+        break;
+      }
+      case "turn/plan/updated":
+        turn.onMessage({
+          type: "item.completed",
+          item: { type: "todo_list", items: (params.plan ?? []).map((p) => ({ text: p.step, completed: p.status === "completed" })) }
+        });
+        break;
+      case "thread/tokenUsage/updated": {
+        if (!turnStarted || turnId && params.turnId && params.turnId !== turnId) break;
+        const total = tokens(params.tokenUsage?.total);
+        tokensBefore ??= minus(total, tokens(params.tokenUsage?.last));
+        tokensNow = total;
+        break;
+      }
+      case "error":
+        turn.onMessage({ type: "error", message: errorText(params.error), kind: errorKind(params.error) });
+        break;
+      case "turn/completed":
+        if (!turnId || !params.turn?.id || params.turn.id === turnId) {
+          turnEnded = true;
+          abortApprovals(false);
+          proc.resultSeen();
+          completed?.(params.turn ?? {});
+        }
+        break;
+      case "serverRequest/resolved": {
+        if (params.threadId !== threadId) break;
+        const approval = approvalRequests.get(String(params.requestId));
+        if (approval) {
+          approval.replyAllowed = false;
+          approval.controller.abort();
+        }
+        break;
+      }
+      default:
+        if (!IGNORED.has(method) && !method.startsWith("codex/event/")) turn.onMessage({ type: "unrecognized", name: method });
+    }
+  }
+  function answerServerRequest(msg) {
+    const method = String(msg.method);
+    const reply = (result) => proc.send({ id: msg.id, result });
+    const declined = "declined \u2014 code-flow runs Codex without approval prompts";
+    const questionGuidance = turn.questionProtocol === "structured" ? "Return a needs_info outcome with an addressed question and checkpoint; code-flow can supply the answer on your next turn." : "It runs Codex headless.";
+    switch (method) {
+      case "item/tool/requestUserInput":
+        if (turn.onQuestion && msg.params?.threadId === threadId && msg.params?.turnId === turnId && Array.isArray(msg.params.questions)) void answerQuestion(msg);
+        else {
+          turn.onText(`Codex asked for input (${method})${requestDetail(msg.params)}; native input unavailable. ${questionGuidance}`);
+          reply({ answers: {} });
+        }
+        break;
+      case "item/commandExecution/requestApproval":
+      case "item/fileChange/requestApproval":
+        if (turn.interactiveApprovals && turn.onApproval) void answerApproval(msg);
+        else {
+          turn.onText(`Codex asked for approval (${method.split("/")[1]}); ${declined}`);
+          reply({ decision: "decline" });
+        }
+        break;
+      case "execCommandApproval":
+      case "applyPatchApproval":
+        turn.onText(`Codex asked for approval (${method}); ${declined}`);
+        reply({ decision: { denied: { rejection: "code-flow runs Codex without approval prompts" } } });
+        break;
+      case "item/permissions/requestApproval":
+        turn.onText(`Codex asked for ${method}${requestDetail(msg.params)}; additional permissions declined`);
+        reply({ permissions: {}, scope: "turn" });
+        break;
+      default: {
+        const detail = requestDetail(msg.params);
+        if (/approval|permission/i.test(method)) {
+          turn.onText(`Codex asked for ${method}${detail}; ${declined}`);
+          reply({ decision: "decline" });
+        } else if (/elicitation/i.test(method)) {
+          turn.onText(`Codex asked for input (${method})${detail}; native input declined. ${questionGuidance}`);
+          reply({ action: "decline", content: null });
+        } else {
+          turn.onText(`Codex asked code-flow for ${method}${detail}; native request unsupported. ${questionGuidance}`);
+          proc.send({ id: msg.id, error: { code: -32601, message: `code-flow doesn't handle ${method}. ${questionGuidance}` } });
+        }
+      }
+    }
+  }
+  async function answerApproval(msg) {
+    const id = String(msg.id);
+    const duplicate = approvalRequests.get(id);
+    if (duplicate) {
+      duplicate.controller.abort();
+      return;
+    }
+    const params = msg.params ?? {};
+    const item = approvalItems.get(params.itemId);
+    const action = approvalAction(msg, item, turn.cwd, turn.sandbox);
+    if (!action || approvalRequests.size >= 32 || !threadId || !turnId || params.threadId !== threadId || params.turnId !== turnId || turnEnded || exit || turn.signal?.aborted) {
+      turn.onText(`Codex approval declined: the action is outside this turn's supported scope`);
+      proc.send({ id: msg.id, result: { decision: "decline" } });
+      return;
+    }
+    const approval = { controller: new AbortController(), replyAllowed: true };
+    approvalRequests.set(id, approval);
+    proc.pauseIdle(true);
+    const timeout = Number.isFinite(turn.approvalTimeoutMs) && turn.approvalTimeoutMs > 0 ? Math.min(10 * 6e4, turn.approvalTimeoutMs) : 2 * 6e4;
+    const timer = setTimeout(() => approval.controller.abort(), timeout);
+    turn.onText(`Codex is waiting for approval of this ${action.kind === "command" ? "command" : "file change"}`);
+    let decision = "decline";
+    try {
+      const cancelled = new Promise((resolve2) => approval.controller.signal.addEventListener("abort", () => resolve2("decline"), { once: true }));
+      decision = await Promise.race([Promise.resolve().then(() => turn.onApproval(action, approval.controller.signal)), cancelled]);
+    } catch (error) {
+      turn.onText(`Codex approval declined: ${error.message}`);
+    } finally {
+      clearTimeout(timer);
+      approvalRequests.delete(id);
+      proc.pauseIdle(approvalRequests.size > 0);
+    }
+    if (approval.replyAllowed && !exit && !turnEnded) {
+      const accepted = decision === "approve" && !approval.controller.signal.aborted && !turn.signal?.aborted;
+      proc.send({ id: msg.id, result: { decision: accepted ? "accept" : "decline" } });
+      turn.onText(`Codex ${action.kind === "command" ? "command" : "file change"} ${accepted ? "approved once" : "declined"}`);
+    }
+    approval.controller.abort();
+  }
+  async function answerQuestion(msg) {
+    const id = String(msg.id);
+    if (approvalRequests.has(id) || approvalRequests.size >= 32 || turnEnded || exit) {
+      proc.send({ id: msg.id, result: { answers: {} } });
+      return;
+    }
+    const approval = { controller: new AbortController(), replyAllowed: true };
+    approvalRequests.set(id, approval);
+    proc.pauseIdle(true);
+    const timer = setTimeout(() => approval.controller.abort(), 6e5);
+    let answers;
+    try {
+      const questions = msg.params.questions.map((q) => ({ id: q.id, question: q.question, options: q.options?.map((o) => o.label) }));
+      answers = await Promise.race([turn.onQuestion(questions, approval.controller.signal), new Promise((resolve2) => approval.controller.signal.addEventListener("abort", () => resolve2(void 0), { once: true }))]);
+    } catch {
+    } finally {
+      clearTimeout(timer);
+      approvalRequests.delete(id);
+      proc.pauseIdle(approvalRequests.size > 0);
+    }
+    if (approval.replyAllowed && !exit && !turnEnded) proc.send({ id: msg.id, result: { answers: Object.fromEntries(Object.entries(answers ?? {}).map(([key, value]) => [key, { answers: [value] }])) } });
+    approval.controller.abort();
+  }
+  function abortApprovals(replyAllowed) {
+    for (const approval of approvalRequests.values()) {
+      approval.replyAllowed = replyAllowed;
+      approval.controller.abort();
+    }
+  }
+  const steer = async (text) => {
+    if (!threadId || !turnId || exit) return false;
+    try {
+      await request("turn/steer", { threadId, expectedTurnId: turnId, input: [textInput(text)] });
+      return true;
+    } catch {
+      return false;
+    }
+  };
+  let cancelling = false;
+  const cancel = () => {
+    if (cancelling) return;
+    cancelling = true;
+    abortApprovals(true);
+    void (async () => {
+      if (threadId && turnId && turnStarted && !turnEnded && !exit) {
+        request("turn/interrupt", { threadId, turnId }, INTERRUPT_MS).catch(() => void 0);
+        await Promise.race([turnDone, exited, delay(INTERRUPT_MS)]);
+      }
+      stop.abort();
+    })();
+  };
+  turn.signal?.addEventListener("abort", cancel, { once: true });
+  if (turn.signal?.aborted) cancel();
+  let steerable = false;
+  try {
+    try {
+      await request(
+        "initialize",
+        { clientInfo: CLIENT_INFO, capabilities: { experimentalApi: false, requestAttestation: false, optOutNotificationMethods: QUIET } },
+        turn.initTimeoutMs ?? INIT_TIMEOUT_MS
+      );
+    } catch (err) {
+      proc.kill();
+      const outcome2 = await exited;
+      if (outcome2.aborted || outcome2.timedOut || outcome2.stalled) return outcome2;
+      const tail = stderrTail(outcome2, 3);
+      if (noAppServer(tail) || err instanceof RpcError) return { unavailable: tail || err.message };
+      const message = err instanceof RpcTimeout ? `codex app-server didn't answer within ${seconds(turn.initTimeoutMs ?? INIT_TIMEOUT_MS)} of starting` : `codex app-server stopped before it was ready${tail ? `: ${tail}` : ""}`;
+      const kind = err instanceof RpcTimeout ? "transient" : classifyError(cliErrorLine(outcome2.stderr));
+      turn.onMessage({ type: "turn.failed", error: { message, kind: kind === "other" && !/ENOENT|EACCES/.test(tail) ? "transient" : kind } });
+      return outcome2;
+    }
+    proc.send({ method: "initialized" });
+    const threadParams = { cwd: turn.cwd, sandbox: turn.sandbox, approvalPolicy: turn.interactiveApprovals && turn.onApproval ? "on-request" : "never", model: turn.model, ...turn.threadConfig ? { config: turn.threadConfig } : {} };
+    let thread;
+    try {
+      thread = turn.forkThreadId ? await request("thread/fork", { threadId: turn.forkThreadId, ...threadParams }) : turn.resumeThreadId ? await request("thread/resume", { threadId: turn.resumeThreadId, excludeTurns: true, ...threadParams }) : await request("thread/start", threadParams);
+    } catch (err) {
+      if ((turn.resumeThreadId || turn.forkThreadId) && err instanceof RpcError && /no rollout found|thread[^\n]{0,20}not found|invalid thread id/i.test(err.message)) {
+        throw new TurnError(err.message, "session_not_found");
+      }
+      if (unsupported(err) || turn.resumeThreadId && err instanceof RpcError && err.code === -32602) {
+        proc.kill();
+        await exited;
+        return { unavailable: err.message };
+      }
+      throw err;
+    }
+    threadId = thread?.thread?.id ?? turn.resumeThreadId;
+    turn.onMessage({ type: "thread.started", thread_id: threadId });
+    turnStarted = true;
+    const started = await request("turn/start", {
+      threadId,
+      input: [textInput(turn.prompt)],
+      effort: turn.effort,
+      outputSchema: turn.outputSchema
+    });
+    turnId ??= started?.turn?.id;
+    turn.onSteerable?.(steer);
+    steerable = true;
+    const result = await Promise.race([turnDone, exited.then(() => void 0)]);
+    if (!result || turn.signal?.aborted) return await exited;
+    if (steerable) turn.onSteerable?.(void 0);
+    steerable = false;
+    if (result.status === "completed") {
+      const used = tokensNow ? minus(tokensNow, tokensBefore ?? zero()) : void 0;
+      turn.onMessage({
+        type: "turn.completed",
+        usage: used && { input_tokens: used.inputTokens, cached_input_tokens: used.cachedInputTokens, output_tokens: used.outputTokens }
+      });
+    } else {
+      turn.onMessage({
+        type: "turn.failed",
+        error: {
+          message: result.error ? errorText(result.error) : result.status === "interrupted" ? "Codex turn was interrupted" : void 0,
+          kind: errorKind(result.error)
+        }
+      });
+    }
+    await request("thread/unsubscribe", { threadId }, SHUTDOWN_MS).catch(() => void 0);
+    proc.endInput();
+    const timer = setTimeout(() => proc.kill(), SHUTDOWN_MS);
+    const outcome = await exited;
+    clearTimeout(timer);
+    return { ...outcome, exitCode: 0 };
+  } catch (err) {
+    if (!exit) {
+      const kind = err instanceof TurnError ? err.kind : err instanceof RpcTimeout ? "transient" : void 0;
+      turn.onMessage({ type: "turn.failed", error: { message: `Codex: ${err.message}`, kind } });
+    }
+    proc.kill();
+    return await exited;
+  } finally {
+    abortApprovals(false);
+    if (steerable) turn.onSteerable?.(void 0);
+    turn.signal?.removeEventListener("abort", cancel);
+  }
+}
+function approvalAction(msg, item, cwd, sandbox) {
+  const params = msg.params ?? {};
+  if ([params.sandboxPermissions, params.sandbox_permissions, item?.sandboxPermissions, item?.sandbox_permissions].some((value) => value !== void 0 && value !== "use_default") || item?.additionalPermissions) return;
+  if (sandbox === "read-only" || params.grantRoot || params.networkApprovalContext || params.additionalPermissions || params.kind && params.kind !== "command" || params.environmentId !== void 0 && params.environmentId !== null) return;
+  const reason = typeof params.reason === "string" ? params.reason.slice(0, 4e3) : void 0;
+  const id = String(msg.id);
+  if (!id || id.length > 240) return;
+  if (msg.method === "item/commandExecution/requestApproval") {
+    const command = params.command ?? item?.command;
+    const requestedCwd = params.cwd ?? item?.cwd ?? cwd;
+    if (typeof command !== "string" || !command.trim() || command.length > 16e3 || command.includes("\0") || typeof requestedCwd !== "string" || !isAbsolute(requestedCwd) || !workspacePath(cwd, requestedCwd)) return;
+    return { id, kind: "command", command, cwd: requestedCwd, ...reason ? { reason } : {} };
+  }
+  if (!item || item.type !== "fileChange" || !Array.isArray(item.changes) || !item.changes.length || item.changes.length > 200) return;
+  if (item.changes.some((change) => !["add", "delete", "update"].includes(change.kind?.type ?? change.kind))) return;
+  const paths = item.changes.flatMap((change) => [change.path, ...change.kind?.move_path ? [change.kind.move_path] : []]);
+  if (paths.some((path) => typeof path !== "string" || !path || path.length > 4096 || path.includes("\0") || !workspacePath(cwd, path))) return;
+  return { id, kind: "file-change", paths, cwd, ...reason ? { reason } : {} };
+}
+function workspacePath(cwd, requested) {
+  try {
+    const root = realpathSync(cwd);
+    const target = isAbsolute(requested) ? resolve(requested) : resolve(root, requested);
+    let existing = target;
+    while (true) {
+      try {
+        const info = lstatSync(existing);
+        if (info.isSymbolicLink()) return false;
+        break;
+      } catch (error) {
+        if (error.code !== "ENOENT") return false;
+        const parent = dirname(existing);
+        if (parent === existing) return false;
+        existing = parent;
+      }
+    }
+    const canonical = resolve(realpathSync(existing), relative(existing, target));
+    return canonical === root || canonical.startsWith(root + sep);
+  } catch {
+    return false;
+  }
+}
+function execItem(item) {
+  switch (item?.type) {
+    case "agentMessage":
+      return { id: item.id, type: "agent_message", text: item.text, phase: item.phase };
+    case "reasoning":
+      return { id: item.id, type: "reasoning", text: (item.summary?.length ? item.summary : item.content ?? []).join("\n\n") };
+    case "commandExecution":
+      return {
+        id: item.id,
+        type: "command_execution",
+        command: item.command,
+        aggregated_output: item.aggregatedOutput ?? "",
+        exit_code: item.exitCode,
+        status: item.status === "inProgress" ? "in_progress" : item.status
+      };
+    case "fileChange":
+      return {
+        id: item.id,
+        type: "file_change",
+        changes: (item.changes ?? []).map((c) => ({ path: c.path, kind: c.kind?.type ?? c.kind })),
+        status: item.status === "inProgress" ? "in_progress" : item.status
+      };
+    case "mcpToolCall":
+      return { id: item.id, type: "mcp_tool_call", server: item.server, tool: item.tool, arguments: item.arguments, result: item.result, error: item.error, status: item.status };
+    case "webSearch":
+      return { id: item.id, type: "web_search", query: item.query };
+    default:
+      return item?.type && IGNORED_ITEMS.has(item.type) ? void 0 : { id: item?.id, type: "unrecognized", name: item?.type };
+  }
+}
+function textInput(text) {
+  return { type: "text", text, text_elements: [] };
+}
+function errorText(error) {
+  const message = [error?.message || "Codex turn failed", error?.additionalDetails].filter(Boolean).join(": ");
+  const kind = errorInfoKind(error);
+  const hint = kind === "usageLimitExceeded" ? "usage limit" : kind === "serverOverloaded" ? "overloaded" : kind === "rateLimitExceeded" ? "rate limit" : kind === "httpConnectionFailed" || kind === "responseStreamConnectionFailed" || kind === "responseStreamDisconnected" ? "connection error" : void 0;
+  return hint && !message.toLowerCase().includes(hint) ? `${message} (${hint})` : message;
+}
+function errorInfoKind(error) {
+  const info = error?.codexErrorInfo;
+  return typeof info === "string" ? info : info && typeof info === "object" ? Object.keys(info)[0] : void 0;
+}
+function errorKind(error) {
+  const kind = errorInfoKind(error);
+  const status = kind && typeof error.codexErrorInfo === "object" ? error.codexErrorInfo[kind]?.httpStatusCode : void 0;
+  if (status === 401) return "auth";
+  if (status === 429) return "rate_limit";
+  switch (kind) {
+    case "usageLimitExceeded":
+      return "usage_limit";
+    case "unauthorized":
+      return "auth";
+    case "rateLimitExceeded":
+      return "rate_limit";
+    case "serverOverloaded":
+    case "internalServerError":
+    case "httpConnectionFailed":
+    case "responseStreamConnectionFailed":
+    case "responseStreamDisconnected":
+    case "responseTooManyFailedAttempts":
+      return "transient";
+    default:
+      return void 0;
+  }
+}
+function unsupported(err) {
+  return err instanceof RpcError && (err.code === -32601 || /method not found|unknown method|unknown variant `[\w-]+\/[\w/-]+`/i.test(err.message));
+}
+function noAppServer(stderr) {
+  return /unrecognized subcommand|unexpected argument|wasn't expected|(?:unknown|invalid|no such) (?:sub)?command/i.test(stderr);
+}
+function requestDetail(params) {
+  const text = [params?.reason, params?.message, params?.command, params?.prompt].find((v) => typeof v === "string" && v.trim());
+  return text ? `: "${truncate(text.trim().replace(/\s+/g, " "), 160)}"` : "";
+}
+function tokens(t) {
+  return { inputTokens: t?.inputTokens ?? 0, cachedInputTokens: t?.cachedInputTokens ?? 0, outputTokens: t?.outputTokens ?? 0 };
+}
+function minus(a, b) {
+  return {
+    inputTokens: Math.max(0, a.inputTokens - b.inputTokens),
+    cachedInputTokens: Math.max(0, a.cachedInputTokens - b.cachedInputTokens),
+    outputTokens: Math.max(0, a.outputTokens - b.outputTokens)
+  };
+}
+function zero() {
+  return { inputTokens: 0, cachedInputTokens: 0, outputTokens: 0 };
+}
+function seconds(ms) {
+  return ms < 1e3 ? `${ms} ms` : `${Math.round(ms / 1e3)}s`;
+}
+function delay(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms).unref());
+}
+export {
+  runAppServerTurn
+};