@nyte-ai/plugin 0.0.23 → 0.0.24

package/dist/chunks/billing-0y7dfkp2.js

@@ -1,146 +0,0 @@
-// examples/claude-code/wire.ts
-import { Type } from "typebox";
-import { Value } from "typebox/value";
-var recordSchema = Type.Record(Type.String(), Type.Unknown());
-var usageSchema = Type.Object({
-  input_tokens: Type.Number(),
-  output_tokens: Type.Number(),
-  cache_read_input_tokens: Type.Optional(Type.Number()),
-  cache_creation_input_tokens: Type.Optional(Type.Number()),
-  cache_creation: Type.Optional(Type.Object({ ephemeral_1h_input_tokens: Type.Optional(Type.Number()) })),
-  output_tokens_details: Type.Optional(Type.Object({ thinking_tokens: Type.Optional(Type.Number()) }))
-});
-var contentSchema = Type.Union([
-  Type.Object({ type: Type.Literal("text"), text: Type.String() }),
-  Type.Object({
-    type: Type.Literal("thinking"),
-    thinking: Type.String(),
-    signature: Type.Optional(Type.String())
-  }),
-  Type.Object({ type: Type.Literal("redacted_thinking"), data: Type.String() }),
-  Type.Object({
-    type: Type.Literal("tool_use"),
-    id: Type.String(),
-    name: Type.String(),
-    input: recordSchema
-  })
-]);
-var messageSchema2 = Type.Intersect([
-  recordSchema,
-  Type.Object({
-    id: Type.Optional(Type.String()),
-    role: Type.Literal("assistant"),
-    content: Type.Array(contentSchema),
-    usage: Type.Optional(usageSchema),
-    stop_reason: Type.Optional(Type.Union([Type.String(), Type.Null()])),
-    stop_sequence: Type.Optional(Type.Union([Type.String(), Type.Null()]))
-  })
-]);
-var streamEventSchema = Type.Union([
-  Type.Object({ type: Type.Literal("message_start"), message: messageSchema2 }),
-  Type.Object({
-    type: Type.Literal("content_block_start"),
-    index: Type.Integer({ minimum: 0 }),
-    content_block: contentSchema
-  }),
-  Type.Object({
-    type: Type.Literal("content_block_delta"),
-    index: Type.Integer({ minimum: 0 }),
-    delta: Type.Union([
-      Type.Object({ type: Type.Literal("text_delta"), text: Type.String() }),
-      Type.Object({ type: Type.Literal("thinking_delta"), thinking: Type.String() }),
-      Type.Object({ type: Type.Literal("signature_delta"), signature: Type.String() }),
-      Type.Object({ type: Type.Literal("input_json_delta"), partial_json: Type.String() })
-    ])
-  }),
-  Type.Object({ type: Type.Literal("content_block_stop"), index: Type.Integer({ minimum: 0 }) }),
-  Type.Object({
-    type: Type.Literal("message_delta"),
-    delta: Type.Object({
-      stop_reason: Type.Optional(Type.Union([Type.String(), Type.Null()])),
-      stop_sequence: Type.Optional(Type.Union([Type.String(), Type.Null()]))
-    }),
-    usage: Type.Optional(Type.Partial(usageSchema))
-  }),
-  Type.Object({ type: Type.Literal("message_stop") }),
-  Type.Object({
-    type: Type.Literal("error"),
-    error: Type.Optional(Type.Object({ type: Type.Optional(Type.String()), message: Type.Optional(Type.String()) }))
-  })
-]);
-var outputEventSchema = Type.Union([
-  Type.Object({
-    type: Type.Literal("assistant"),
-    message: messageSchema2,
-    error: Type.Optional(Type.Unknown())
-  }),
-  Type.Object({
-    type: Type.Literal("result"),
-    subtype: Type.Optional(Type.String()),
-    is_error: Type.Optional(Type.Boolean()),
-    num_turns: Type.Optional(Type.Number()),
-    usage: Type.Optional(usageSchema),
-    total_cost_usd: Type.Optional(Type.Number()),
-    modelUsage: Type.Optional(recordSchema)
-  }),
-  Type.Object({ type: Type.Literal("stream_event"), event: streamEventSchema }),
-  Type.Object({
-    type: Type.Literal("rate_limit_event"),
-    rate_limit_info: Type.Optional(Type.Object({
-      status: Type.Optional(Type.String()),
-      rateLimitType: Type.Optional(Type.String()),
-      resetsAt: Type.Optional(Type.Number()),
-      isUsingOverage: Type.Optional(Type.Boolean()),
-      overageStatus: Type.Optional(Type.String()),
-      overageDisabledReason: Type.Optional(Type.String())
-    }))
-  }),
-  Type.Object({ type: Type.Literal("control_response"), response: recordSchema })
-]);
-var requestMessageSchema = Type.Object({
-  role: Type.Optional(Type.String()),
-  content: Type.Optional(Type.Unknown())
-});
-var requestMessagesSchema = Type.Array(requestMessageSchema);
-var requestSchema = Type.Intersect([
-  recordSchema,
-  Type.Object({ messages: requestMessagesSchema, system: Type.Optional(Type.Unknown()) })
-]);
-function matchesRecord2(value) {
-  return Value.Check(recordSchema, value);
-}
-function parseRecord2(text) {
-  const value = JSON.parse(text);
-  if (!matchesRecord2(value))
-    throw new Error("Expected a JSON object");
-  return value;
-}
-function parseStreamEvent2(text) {
-  const value = JSON.parse(text);
-  if (matchesRecord2(value) && value.type === "ping")
-    return;
-  if (!Value.Check(streamEventSchema, value))
-    throw new Error("Invalid Anthropic stream event");
-  return value;
-}
-function parseOutputEvent2(text) {
-  const value = parseRecord2(text);
-  if (!["assistant", "result", "stream_event", "rate_limit_event", "control_response"].includes(String(value.type)))
-    return;
-  if (!Value.Check(outputEventSchema, value))
-    throw new Error("Invalid Claude Code output event");
-  return value;
-}
-function parseRequest2(body) {
-  const value = JSON.parse(body.toString("utf8"));
-  if (!Value.Check(requestSchema, value))
-    throw new Error("Invalid Claude Code request");
-  return value;
-}
-function parseRequestMessages2(value) {
-  if (!Value.Check(requestMessagesSchema, value))
-    throw new Error("Invalid Claude Code replay messages");
-  return value;
-}
-
-export { messageSchema2, matchesRecord2, parseRecord2, parseStreamEvent2, parseOutputEvent2, parseRequest2, parseRequestMessages2 };

package/dist/chunks/billing-3scqmkzb.js

@@ -1,559 +0,0 @@
-import {
-  usageCreditsAllowed2,
-  usageCreditsChargeError2
-} from "./billing-tzr3cebf.js";
-import {
-  INERT_MCP_SOURCE2
-} from "./billing-t1qrxe16.js";
-import {
-  matchesRecord2,
-  parseOutputEvent2
-} from "./billing-0y7dfkp2.js";
-import {
-  configuredCommand2,
-  readyClaudeCommand2,
-  spawnCommand2,
-  childExit2,
-  killProcessTree2,
-  processEnvironment2
-} from "./billing-cy1rg619.js";
-import {
-  deriveInitialUserPrefix2,
-  deriveInitialSystemMessages2,
-  rewriteInitialRequest2
-} from "./billing-j643d12p.js";
-import {
-  TurnRelay2
-} from "./billing-a9vqn66p.js";
-import {
-  TOOL_PREFIX2
-} from "./billing-ejx2hv52.js";
-
-// examples/claude-code/claude-cli.ts
-import { createHash } from "node:crypto";
-import { mkdtemp, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join, resolve as resolvePath } from "node:path";
-import { createInterface } from "node:readline";
-import { registerSessionResourceCleanup } from "@nyte-ai/ai";
-class AsyncQueue {
-  values = [];
-  waiters = [];
-  ended = false;
-  failure;
-  push(value) {
-    const waiter = this.waiters.shift();
-    if (waiter)
-      waiter({ value, done: false });
-    else
-      this.values.push(value);
-  }
-  end(error) {
-    this.ended = true;
-    this.failure = error;
-    for (const waiter of this.waiters.splice(0))
-      waiter({ value: undefined, done: true });
-  }
-  async next(signal, timeoutMs) {
-    if (this.values.length)
-      return this.values.shift();
-    if (this.ended) {
-      if (this.failure)
-        throw this.failure;
-      return;
-    }
-    signal?.throwIfAborted();
-    return new Promise((resolve, reject) => {
-      let settled = false;
-      const finish = (fn) => {
-        if (settled)
-          return;
-        settled = true;
-        clearTimeout(timer);
-        signal?.removeEventListener("abort", onAbort);
-        const index = this.waiters.findIndex((pending) => pending === waiter);
-        if (index >= 0)
-          this.waiters.splice(index, 1);
-        fn();
-      };
-      const waiter = (item) => finish(() => {
-        if (item.done && this.failure)
-          reject(this.failure);
-        else
-          resolve(item.done ? undefined : item.value);
-      });
-      const onAbort = () => finish(() => reject(signal?.reason ?? new Error("Claude Code request aborted")));
-      const timer = setTimeout(() => finish(() => reject(new Error("Claude Code stream timed out"))), timeoutMs);
-      this.waiters.push(waiter);
-      signal?.addEventListener("abort", onAbort, { once: true });
-    });
-  }
-}
-async function writeFrame(child, frame) {
-  const input = child.stdin;
-  if (!input?.writable)
-    throw new Error("Claude Code stdin closed during history replay");
-  if (!input.write(`${JSON.stringify(frame)}
-`)) {
-    await new Promise((resolve, reject) => {
-      input.once("drain", resolve);
-      input.once("error", reject);
-    });
-  }
-}
-function nativeErrorText(event) {
-  const messageError = event.message.error;
-  if (!event.error && !messageError)
-    return;
-  return event.message.content.filter((block) => block.type === "text").map((block) => block.text).join(`
-`);
-}
-var CLAUDE_PROCESS_MAX_AGE_MS = 5 * 60 * 1000;
-var MAX_CACHED_CLAUDE_PROCESSES = 2;
-function canonicalJson(value) {
-  if (value === undefined)
-    return "null";
-  if (value === null || typeof value !== "object")
-    return JSON.stringify(value);
-  if (Array.isArray(value))
-    return `[${value.map(canonicalJson).join(",")}]`;
-  if (!matchesRecord2(value))
-    throw new Error("Expected a JSON value");
-  return `{${Object.entries(value).filter(([, child]) => child !== undefined).toSorted(([left], [right]) => left.localeCompare(right)).map(([key, child]) => `${JSON.stringify(key)}:${canonicalJson(child)}`).join(",")}}`;
-}
-function digest(value) {
-  return createHash("sha256").update(canonicalJson(value)).digest("hex");
-}
-function frameHistoryHash(frames) {
-  return digest(frames.map((frame) => ({
-    type: frame.type,
-    message: frame.message
-  })));
-}
-function launchPlan(input) {
-  const timeoutMs = input.timeoutMs ?? 180000;
-  const env = processEnvironment2(input.env, input.extraBody);
-  return {
-    env,
-    timeoutMs,
-    fingerprint: digest({
-      command: configuredCommand2(env),
-      cwd: resolvePath(input.cwd ?? process.cwd()),
-      env,
-      extraBody: input.extraBody,
-      manifest: input.manifest,
-      model: input.model,
-      systemPrompt: input.systemPrompt,
-      timeoutMs,
-      upstreamUrl: input.upstreamUrl ?? "https://api.anthropic.com"
-    })
-  };
-}
-
-class ClaudeProcess {
-  busy = false;
-  createdAt = Date.now();
-  lastUsed = this.createdAt;
-  tipHash;
-  expiryTimer;
-  closed = false;
-  stderr = "";
-  fingerprint;
-  root;
-  child;
-  relay;
-  queue;
-  readTask;
-  exitOutcome;
-  timeoutMs;
-  constructor(fingerprint, root, child, relay, queue, readTask, exitOutcome, timeoutMs) {
-    this.fingerprint = fingerprint;
-    this.root = root;
-    this.child = child;
-    this.relay = relay;
-    this.queue = queue;
-    this.readTask = readTask;
-    this.exitOutcome = exitOutcome;
-    this.timeoutMs = timeoutMs;
-    child.stderr?.setEncoding("utf8");
-    child.stderr?.on("data", (chunk) => this.stderr = (this.stderr + chunk).slice(-65536));
-  }
-  static async create(input, plan) {
-    input.signal?.throwIfAborted();
-    const command = await readyClaudeCommand2({ ...process.env, ...input.env }, input.signal);
-    const root = await mkdtemp(join(tmpdir(), "nyte-claude-code-"));
-    const toolsPath = join(root, "tools.json");
-    const settingsPath = join(root, "settings.json");
-    const systemPath = join(root, "system.md");
-    const inertMcpPath = join(root, "inert-mcp.mjs");
-    let child;
-    let relay;
-    try {
-      await Promise.all([
-        writeFile(inertMcpPath, INERT_MCP_SOURCE2, "utf8"),
-        writeFile(toolsPath, JSON.stringify(input.manifest), "utf8"),
-        writeFile(settingsPath, JSON.stringify({ env: { CLAUDE_CODE_EXTRA_BODY: JSON.stringify(input.extraBody) } }), "utf8"),
-        writeFile(systemPath, input.systemPrompt, "utf8")
-      ]);
-      relay = new TurnRelay2(input.upstreamUrl ?? "https://api.anthropic.com", plan.timeoutMs);
-      const env = { ...plan.env, ANTHROPIC_BASE_URL: await relay.start() };
-      const mcp = {
-        mcpServers: {
-          nyte: {
-            command: process.versions.bun === undefined ? process.execPath : "node",
-            args: [inertMcpPath, toolsPath],
-            env: { ELECTRON_RUN_AS_NODE: "1" }
-          }
-        }
-      };
-      const args = [
-        "-p",
-        "--model",
-        input.model,
-        "--input-format",
-        "stream-json",
-        "--output-format",
-        "stream-json",
-        "--verbose",
-        "--include-partial-messages",
-        "--tools",
-        "",
-        "--system-prompt-file",
-        systemPath,
-        "--settings",
-        settingsPath,
-        "--setting-sources",
-        "",
-        "--strict-mcp-config",
-        "--disable-slash-commands",
-        "--max-turns",
-        "1",
-        "--permission-mode",
-        "dontAsk",
-        "--no-session-persistence",
-        "--mcp-config",
-        JSON.stringify(mcp)
-      ];
-      child = spawnCommand2(command, args, {
-        cwd: input.cwd ?? process.cwd(),
-        env,
-        detached: process.platform !== "win32",
-        windowsHide: true,
-        stdio: ["pipe", "pipe", "pipe"]
-      });
-      const queue = new AsyncQueue;
-      if (child.stdout === null)
-        throw new Error("Claude Code stdout is unavailable");
-      const reader = createInterface({ input: child.stdout, crlfDelay: Infinity });
-      const readTask = (async () => {
-        try {
-          for await (const line of reader) {
-            if (!line.trim())
-              continue;
-            try {
-              const event = parseOutputEvent2(line);
-              if (event !== undefined)
-                queue.push(event);
-            } catch (error) {
-              throw new Error(`Invalid Claude Code stream-json output: ${line.slice(0, 300)}`, {
-                cause: error
-              });
-            }
-          }
-          queue.end();
-        } catch (error) {
-          queue.end(error instanceof Error ? error : new Error(String(error)));
-        }
-      })();
-      const exitOutcome = childExit2(child).then((code) => ({ code }), (error) => ({ error: error instanceof Error ? error : new Error(String(error)) }));
-      return new ClaudeProcess(plan.fingerprint, root, child, relay, queue, readTask, exitOutcome, plan.timeoutMs);
-    } catch (error) {
-      relay?.abort();
-      if (child && child.exitCode === null)
-        killProcessTree2(child);
-      await relay?.close();
-      await rm(root, { recursive: true, force: true });
-      throw error;
-    }
-  }
-  isAlive() {
-    return !this.closed && this.child.exitCode === null && !!this.child.stdin?.writable;
-  }
-  isExpired(now = Date.now()) {
-    return now - this.createdAt >= CLAUDE_PROCESS_MAX_AGE_MS;
-  }
-  canContinue(input) {
-    if (!this.tipHash || input.frames.length === 0)
-      return false;
-    return frameHistoryHash(input.frames.slice(0, -1)) === this.tipHash;
-  }
-  clearExpiryTimer() {
-    if (this.expiryTimer)
-      clearTimeout(this.expiryTimer);
-    this.expiryTimer = undefined;
-  }
-  armExpiryTimer(expire) {
-    this.clearExpiryTimer();
-    this.lastUsed = Date.now();
-    const remainingLifetime = CLAUDE_PROCESS_MAX_AGE_MS - (this.lastUsed - this.createdAt);
-    this.expiryTimer = setTimeout(expire, Math.max(0, remainingLifetime));
-    this.expiryTimer.unref?.();
-  }
-  commit(input, message) {
-    if (message.content.some((block) => block.type === "tool_use")) {
-      this.tipHash = undefined;
-      return false;
-    }
-    this.tipHash = frameHistoryHash([
-      ...input.frames,
-      { type: "assistant", message: { role: "assistant", content: message.content } }
-    ]);
-    return true;
-  }
-  async run(input, continuation) {
-    if (!this.isAlive())
-      throw new Error("Claude Code process is no longer available");
-    input.signal?.throwIfAborted();
-    let sawMessageStop = false;
-    const deliver = (event) => {
-      if (event.type === "message_stop")
-        sawMessageStop = true;
-      input.onEvent?.(event);
-    };
-    const canonicalInitialUser = input.frames.find((frame) => frame.type === "user")?.message.content ?? [];
-    this.relay.beginTurn(deliver, input.initialUserPrefix || input.initialSystemMessages || input.nativeSystemInjections ? (body) => rewriteInitialRequest2(body, input.initialUserPrefix, canonicalInitialUser, input.initialSystemMessages, input.nativeSystemInjections) : undefined, input.betas);
-    const abort = () => {
-      this.relay.abort();
-      this.closeNow();
-    };
-    input.signal?.addEventListener("abort", abort, { once: true });
-    const assistants = [];
-    let result;
-    let nativeError;
-    let rateLimit;
-    try {
-      const frames = continuation ? input.frames.slice(-1) : input.frames;
-      for (const frame of frames) {
-        await writeFrame(this.child, frame);
-        if (frame.shouldQuery === false) {
-          for (;; ) {
-            const event = await this.queue.next(input.signal, this.timeoutMs);
-            if (!event)
-              throw await this.exitError("Claude Code exited before acknowledging history replay");
-            if (event.type === "result") {
-              if (event.num_turns !== 0 || event.is_error) {
-                throw new Error("Claude Code rejected zero-turn history replay");
-              }
-              break;
-            }
-          }
-        }
-      }
-      for (;; ) {
-        const event = await this.queue.next(input.signal, this.timeoutMs);
-        if (!event)
-          throw await this.exitError("Claude Code exited before completing its response");
-        if (event.type === "assistant") {
-          const error = nativeErrorText(event);
-          if (error !== undefined)
-            nativeError = error;
-          else
-            assistants.push(event.message);
-        } else if (event.type === "result") {
-          result = event;
-          break;
-        } else if (event.type === "rate_limit_event") {
-          if (event.rate_limit_info && typeof event.rate_limit_info === "object")
-            rateLimit = event.rate_limit_info;
-        } else if (event.type === "stream_event" && !this.relay.used) {
-          deliver(event.event);
-        }
-      }
-      await this.relay.settled();
-      input.signal?.throwIfAborted();
-      let message;
-      if (this.relay.used) {
-        if (this.relay.status !== 200 || !this.relay.capture.complete || !this.relay.capture.message) {
-          let detail = `status ${this.relay.status ?? "unknown"}, capture ${this.relay.capture.complete ? "complete" : "incomplete"}`;
-          if (this.relay.failure)
-            detail += `, relay failure ${this.relay.failure}`;
-          if (this.relay.denied)
-            detail += `, native retries denied ${this.relay.denied}`;
-          const upstreamError = this.relay.errorText();
-          if (upstreamError)
-            detail += `, upstream said: ${upstreamError.slice(0, 500)}`;
-          throw new Error(`Incomplete Claude Code upstream response (${detail})`);
-        }
-        message = this.relay.capture.message;
-        sawMessageStop = true;
-      } else {
-        message = assistants.at(-1);
-      }
-      if (!message || !sawMessageStop || !result) {
-        throw new Error(`Incomplete Claude Code response: assistant, message_stop and one result required${this.stderr ? ` (${this.stderr.trim().slice(-500)})` : ""}`);
-      }
-      const nativeFailureHandled = this.relay.denied > 0 || message.stop_reason === "refusal";
-      if (nativeError && !nativeFailureHandled)
-        throw new Error(`Claude Code API error: ${nativeError}`);
-      const hasTools = message.content.some((block) => block.type === "tool_use");
-      const maxTurnsBoundary = hasTools && result.subtype === "error_max_turns";
-      if (!maxTurnsBoundary && !nativeFailureHandled && (result.is_error || result.subtype !== "success")) {
-        throw new Error(`Claude Code request failed: ${result.subtype ?? "unknown result"}`);
-      }
-      for (const block of message.content) {
-        if (block.type !== "tool_use")
-          continue;
-        if (!block.name.startsWith(TOOL_PREFIX2) || !input.toolNames.has(block.name.slice(TOOL_PREFIX2.length))) {
-          throw new Error("Claude Code returned a tool outside Nyte's current tool inventory");
-        }
-      }
-      const usage = message.usage ?? result.usage;
-      if (!usage || typeof usage.input_tokens !== "number" || typeof usage.output_tokens !== "number") {
-        throw new Error("Claude Code response did not include complete token usage");
-      }
-      if (rateLimit?.isUsingOverage === true && !usageCreditsAllowed2({ ...process.env, ...input.env })) {
-        throw usageCreditsChargeError2(rateLimit);
-      }
-      return {
-        message,
-        usage,
-        relay: {
-          upstreamRequests: Number(this.relay.used),
-          blockedRequests: this.relay.denied,
-          requestId: this.relay.requestId
-        },
-        initialUserPrefix: input.initialUserPrefix ?? deriveInitialUserPrefix2(this.relay.originalRequestBody, canonicalInitialUser),
-        initialSystemMessages: input.initialSystemMessages ?? deriveInitialSystemMessages2(this.relay.originalRequestBody),
-        rateLimit
-      };
-    } finally {
-      input.signal?.removeEventListener("abort", abort);
-      this.relay.finishTurn();
-    }
-  }
-  async close() {
-    this.closeNow();
-    await Promise.allSettled([this.readTask, this.exitOutcome, this.relay.close()]);
-    await rm(this.root, { recursive: true, force: true });
-  }
-  closeNow() {
-    if (this.closed)
-      return;
-    this.closed = true;
-    this.clearExpiryTimer();
-    this.relay.abort();
-    if (this.child.exitCode === null)
-      killProcessTree2(this.child);
-  }
-  async exitError(fallback) {
-    const outcome = await this.exitOutcome;
-    if (outcome.error)
-      return outcome.error;
-    const detail = this.stderr.trim().slice(-500);
-    return new Error(`${fallback} (exit ${outcome.code ?? "unknown"}${detail ? `: ${detail}` : ""})`);
-  }
-}
-var processCache = new Map;
-var managerTail = Promise.resolve();
-async function withManagerLock(operation) {
-  const previous = managerTail;
-  const pending = Promise.withResolvers();
-  managerTail = pending.promise;
-  await previous;
-  try {
-    return await operation();
-  } finally {
-    pending.resolve();
-  }
-}
-async function expireProcess(sessionId, worker) {
-  const expired = await withManagerLock(() => {
-    if (processCache.get(sessionId) !== worker || worker.busy || !worker.isExpired())
-      return false;
-    processCache.delete(sessionId);
-    return true;
-  });
-  if (expired)
-    await worker.close();
-}
-async function discardProcess(acquired) {
-  const { sessionId, worker } = acquired;
-  if (sessionId && processCache.get(sessionId) === worker) {
-    await withManagerLock(() => {
-      if (processCache.get(sessionId) === worker)
-        processCache.delete(sessionId);
-    });
-  }
-  await worker.close();
-}
-async function acquireProcess(input, plan) {
-  return withManagerLock(async () => {
-    const sessionId = input.sessionId;
-    const cached = sessionId ? processCache.get(sessionId) : undefined;
-    if (sessionId && cached && !cached.busy) {
-      cached.clearExpiryTimer();
-      if (cached.isAlive() && !cached.isExpired() && cached.fingerprint === plan.fingerprint && cached.canContinue(input)) {
-        cached.busy = true;
-        return { worker: cached, retained: true, continuation: true, sessionId };
-      }
-      processCache.delete(sessionId);
-      await cached.close();
-    }
-    const retain = !!sessionId && !cached?.busy;
-    if (retain) {
-      while (processCache.size >= MAX_CACHED_CLAUDE_PROCESSES) {
-        const victim = [...processCache.entries()].filter(([, worker]) => !worker.busy).toSorted((left, right) => left[1].lastUsed - right[1].lastUsed)[0];
-        if (!victim)
-          break;
-        processCache.delete(victim[0]);
-        await victim[1].close();
-      }
-    }
-    const worker = await ClaudeProcess.create(input, plan);
-    worker.busy = true;
-    const retained = retain && processCache.size < MAX_CACHED_CLAUDE_PROCESSES;
-    if (retained && sessionId)
-      processCache.set(sessionId, worker);
-    return { worker, retained, continuation: false, sessionId };
-  });
-}
-async function closeClaudeProcesses(sessionId) {
-  const workers = await withManagerLock(() => {
-    if (sessionId) {
-      const worker = processCache.get(sessionId);
-      processCache.delete(sessionId);
-      return worker ? [worker] : [];
-    }
-    const all = [...processCache.values()];
-    processCache.clear();
-    return all;
-  });
-  await Promise.allSettled(workers.map((worker) => worker.close()));
-}
-registerSessionResourceCleanup((sessionId) => {
-  closeClaudeProcesses(sessionId);
-});
-async function runClaudeRequest2(input) {
-  input.signal?.throwIfAborted();
-  const plan = launchPlan(input);
-  const acquired = await acquireProcess(input, plan);
-  try {
-    const output = await acquired.worker.run(input, acquired.continuation);
-    const stable = acquired.worker.commit(input, output.message);
-    if (stable && acquired.retained && acquired.sessionId && processCache.get(acquired.sessionId) === acquired.worker) {
-      acquired.worker.busy = false;
-      const sessionId = acquired.sessionId;
-      acquired.worker.armExpiryTimer(() => {
-        expireProcess(sessionId, acquired.worker);
-      });
-    } else {
-      await discardProcess(acquired);
-    }
-    return output;
-  } catch (error) {
-    await discardProcess(acquired);
-    throw error;
-  }
-}
-
-export { runClaudeRequest2 };