replicas-engine 0.1.1042 → 0.1.1044

package/dist/src/headless-agent.js

@@ -2,28 +2,47 @@
 import { createRequire as __createRequire } from 'node:module';
 const require = __createRequire(import.meta.url);
 import {
-  recoverCompletedTurn
-} from "./chunk-P73LGPQO.js";
+  THREAD_TOKEN_USAGE_UPDATED_METHOD,
+  fetchOpencodeModelVariants,
+  getOpenCodeGoModel,
+  getOpencodeProvider,
+  initializeMuse,
+  museTurnStartParams,
+  opencodeConfig,
+  opencodeThinkingVariant,
+  recoverCompletedTurn,
+  spawnMuseMsp,
+  startMuseSession
+} from "./chunk-3RXHH2OK.js";
 import {
   AppServerProcess,
   buildCodexAgentEnv
-} from "./chunk-QDIKROO7.js";
-import "./chunk-XS3QUSHQ.js";
+} from "./chunk-EPG6XMVB.js";
+import "./chunk-VSDRLCZY.js";
 import {
   AGENT,
-  headlessAgentRequestSchema
-} from "./chunk-KXBTOL3R.js";
+  OPENCODE_GO_PROVIDER,
+  codexReasoningEffortForThinkingLevel,
+  extractJsonObject,
+  headlessAgentRequestSchema,
+  headlessAgentUsagePath,
+  isRecord,
+  withTimeout
+} from "./chunk-PZEZIF5C.js";
 import "./chunk-VEQXQN22.js";
 
 // src/headless-agent.ts
 import { readFile, writeFile } from "fs/promises";
 import { query } from "@anthropic-ai/claude-agent-sdk";
+import { createOpencodeClient, createOpencodeServer } from "@opencode-ai/sdk/v2";
+import { Agent as CursorAgent } from "@cursor/sdk";
 async function runClaude(request) {
   const response = query({
     prompt: request.prompt,
     options: {
       cwd: request.workingDirectory,
       model: request.model,
+      ...request.thinkingLevel ? { effort: request.thinkingLevel } : {},
       tools: [],
       permissionMode: "dontAsk",
       settingSources: [],
@@ -32,21 +51,31 @@ async function runClaude(request) {
       env: { ...process.env, CLAUDE_CODE_DISABLE_AUTO_MEMORY: "1" }
     }
   });
-  let result = null;
-  try {
+  const lastResult = async () => {
+    let last = null;
     for await (const message of response) {
-      if (message.type === "result") result = message;
+      if (message.type === "result") last = message;
     }
+    return last;
+  };
+  let result;
+  try {
+    result = await withTimeout(lastResult(), request.timeoutSeconds * 1e3, "Claude run timed out");
   } finally {
     response.close();
   }
   if (!result) throw new Error("Claude Agent SDK returned no result");
   if (result.subtype !== "success") throw new Error(result.errors.join("\n") || result.subtype);
-  return result.structured_output ?? JSON.parse(result.result);
+  const { input_tokens, cache_creation_input_tokens, cache_read_input_tokens, output_tokens } = result.usage;
+  return {
+    output: result.structured_output ?? JSON.parse(result.result),
+    usage: { inputTokens: input_tokens + cache_creation_input_tokens + cache_read_input_tokens, outputTokens: output_tokens }
+  };
 }
 function runCodexTurn(client, params, timeoutMs) {
   return new Promise((resolve, reject) => {
     const completedItems = [];
+    let usage = null;
     const messageDeltas = /* @__PURE__ */ new Map();
     const cleanup = () => {
       clearTimeout(timeout);
@@ -54,6 +83,12 @@ function runCodexTurn(client, params, timeoutMs) {
       client.off("dispose", onDispose);
     };
     const onNotification = (notification) => {
+      if (notification.method === THREAD_TOKEN_USAGE_UPDATED_METHOD) {
+        if (notification.params.threadId !== params.threadId) return;
+        const { inputTokens, outputTokens } = notification.params.tokenUsage.total;
+        usage = { inputTokens, outputTokens };
+        return;
+      }
       if (notification.method === "item/completed") {
         if (notification.params.threadId !== params.threadId || notification.params.item.type !== "agentMessage") return;
         completedItems.push(notification.params.item);
@@ -71,7 +106,7 @@ function runCodexTurn(client, params, timeoutMs) {
       const turn = recoverCompletedTurn(notification.params.turn, completedItems, messageDeltas);
       const message = turn.items.findLast((item) => item.type === "agentMessage")?.text ?? null;
       cleanup();
-      resolve({ turn, message });
+      resolve({ turn, message, usage });
     };
     const onDispose = (error) => {
       cleanup();
@@ -122,20 +157,112 @@ async function runCodex(request) {
       sandbox: "read-only",
       ephemeral: true
     });
-    const { turn, message } = await runCodexTurn(client, {
+    const { turn, message, usage } = await runCodexTurn(client, {
       threadId: thread.thread.id,
       input: [{ type: "text", text: request.prompt, text_elements: [] }],
       outputSchema: request.outputSchema,
+      ...request.thinkingLevel ? { effort: codexReasoningEffortForThinkingLevel(request.thinkingLevel) } : {},
       approvalPolicy: "never",
       approvalsReviewer: "user"
     }, request.timeoutSeconds * 1e3);
     if (turn.status === "failed") throw new Error(turn.error?.message ?? "Codex ASP turn failed");
     if (!message) throw new Error("Codex ASP returned no final message");
-    return JSON.parse(message);
+    return { output: JSON.parse(message), usage };
   } finally {
     await appServer.stop();
   }
 }
+async function runOpencode(request) {
+  const provider = await getOpencodeProvider();
+  const model = provider === OPENCODE_GO_PROVIDER ? getOpenCodeGoModel(request.model) : request.model;
+  const server = await createOpencodeServer({ port: 0, timeout: 3e4, config: opencodeConfig(provider, model) });
+  try {
+    const password = process.env.OPENCODE_SERVER_PASSWORD;
+    const client = createOpencodeClient({
+      baseUrl: server.url,
+      ...password ? { headers: { Authorization: `Basic ${Buffer.from(`opencode:${password}`).toString("base64")}` } } : {}
+    });
+    const variant = opencodeThinkingVariant((await fetchOpencodeModelVariants(client, request.workingDirectory, provider)).get(model), request.thinkingLevel);
+    const session = await client.session.create({ directory: request.workingDirectory, model: { providerID: provider, id: model } }, { throwOnError: true });
+    const result = await client.session.prompt({
+      sessionID: session.data.id,
+      directory: request.workingDirectory,
+      model: { providerID: provider, modelID: model },
+      ...variant ? { variant } : {},
+      format: { type: "json_schema", schema: request.outputSchema, retryCount: 2 },
+      parts: [{ type: "text", text: request.prompt }]
+    }, { throwOnError: true, signal: AbortSignal.timeout(request.timeoutSeconds * 1e3) });
+    const { info } = result.data;
+    if (info.error) throw new Error(`${info.error.name}: ${JSON.stringify(info.error.data)}`);
+    if (info.structured === void 0) throw new Error("Opencode returned no structured output");
+    return {
+      output: info.structured,
+      usage: { inputTokens: info.tokens.input + info.tokens.cache.read + info.tokens.cache.write, outputTokens: info.tokens.output + info.tokens.reasoning }
+    };
+  } finally {
+    server.close();
+  }
+}
+var jsonReplyPrompt = (request) => `${request.prompt}
+
+Reply with only JSON, no prose or code fences, matching this JSON Schema:
+${JSON.stringify(request.outputSchema)}`;
+function parseJsonReply(reply) {
+  const output = extractJsonObject(reply);
+  if (output === null) throw new Error(`Reply was not JSON: ${reply.slice(0, 200)}`);
+  return output;
+}
+async function runCursor(request) {
+  const apiKey = process.env.CURSOR_API_KEY;
+  if (!apiKey) throw new Error("Cursor API key is not configured");
+  const agent = await CursorAgent.create({ apiKey, model: { id: request.model }, local: { cwd: request.workingDirectory, settingSources: [] } });
+  const run = await agent.send(jsonReplyPrompt(request));
+  const result = await withTimeout(run.wait(), request.timeoutSeconds * 1e3, "Cursor run timed out");
+  if (result.status !== "finished" || !result.result) throw new Error(result.error?.message ?? `Cursor run ${result.status}`);
+  return {
+    output: parseJsonReply(result.result),
+    usage: result.usage ? { inputTokens: result.usage.inputTokens + result.usage.cacheReadTokens + result.usage.cacheWriteTokens, outputTokens: result.usage.outputTokens } : null
+  };
+}
+async function runMuse(request) {
+  const { child, client } = spawnMuseMsp(request.workingDirectory);
+  let stderr = "";
+  child.stderr.on("data", (chunk) => {
+    stderr = `${stderr}${chunk}`.slice(-2e3);
+  });
+  child.on("exit", (code, signal) => client.dispose(new Error(`Muse exited with ${code ?? signal}: ${stderr.trim()}`)));
+  client.on("serverRequest", (serverRequest) => client.reject(serverRequest.id, -32601, "Headless agents do not accept server requests"));
+  try {
+    await initializeMuse(client, "replicas_headless_agent");
+    const sessionId = await startMuseSession(client, { approvalMode: "denyUnmatched", modelId: request.model, workspaceRoot: request.workingDirectory });
+    let message = null;
+    let usage = null;
+    const completed = new Promise((resolve, reject) => {
+      client.on("dispose", reject);
+      client.on("notification", (frame) => {
+        if (!isRecord(frame) || !isRecord(frame.params) || frame.params.sessionId !== sessionId) return;
+        const { method, params } = frame;
+        if (method === "item/completed" && isRecord(params.item) && params.item.kind === "agentMessage" && typeof params.item.text === "string") {
+          message = params.item.text;
+        } else if (method === "session/tokenUsage" && isRecord(params.cumulative) && typeof params.cumulative.promptTokens === "number" && typeof params.cumulative.outputTokens === "number") {
+          usage = { inputTokens: params.cumulative.promptTokens, outputTokens: params.cumulative.outputTokens };
+        } else if (method === "turn/completed") {
+          if (isRecord(params.error)) reject(new Error(typeof params.error.message === "string" ? params.error.message : "Muse turn failed"));
+          else resolve();
+        }
+      });
+    });
+    await Promise.all([
+      client.request("turn/start", museTurnStartParams(sessionId, [{ type: "text", text: jsonReplyPrompt(request) }], request.thinkingLevel)),
+      withTimeout(completed, request.timeoutSeconds * 1e3, "Muse turn timed out")
+    ]);
+    if (!message) throw new Error("Muse returned no final message");
+    return { output: parseJsonReply(message), usage };
+  } finally {
+    client.dispose();
+    child.kill("SIGTERM");
+  }
+}
 async function main() {
   const [requestPath, outputPath] = process.argv.slice(2);
   if (!requestPath || !outputPath) throw new Error("Usage: replicas-headless-agent <request.json> <output.json>");
@@ -148,13 +275,26 @@ async function main() {
     case AGENT.CODEX:
       result = await runCodex(request);
       break;
-    default:
-      throw new Error(`Unsupported headless agent: ${request.agent}`);
+    case AGENT.OPENCODE:
+      result = await runOpencode(request);
+      break;
+    case AGENT.CURSOR:
+      result = await runCursor(request);
+      break;
+    case AGENT.MUSE:
+      result = await runMuse(request);
+      break;
+    case AGENT.PI:
+      throw new Error("Send Pi credentials as an Opencode request, which reads the same stored secrets");
+    default: {
+      const unsupported = request.agent;
+      throw new Error(`Unsupported headless agent: ${String(unsupported)}`);
+    }
   }
-  await writeFile(outputPath, JSON.stringify(result), { mode: 384 });
+  await writeFile(outputPath, JSON.stringify(result.output), { mode: 384 });
+  if (result.usage) await writeFile(headlessAgentUsagePath(outputPath), JSON.stringify(result.usage), { mode: 384 });
 }
-main().catch((error) => {
-  process.exitCode = 1;
+main().then(() => process.exit(0), (error) => {
   process.stderr.write(`${error instanceof Error ? error.message : String(error)}
-`);
+`, () => process.exit(1));
 });