@evandu/super-pi 0.1.46 → 0.1.47

package/agents/super-pi-task/core.ts

@@ -38,6 +38,7 @@
  */
 export const TASK_TOOL_NAME = "task";
 export const TASK_ENDPOINT_ENV = "SUPER_PI_TASK_ENDPOINT";
+export const TASK_EXEC_ENDPOINT_ENV = "SUPER_PI_EXEC_ENDPOINT";
 export const TASK_ROSTER_ENV = "SUPER_PI_TASK_ROSTER";
 export const TASK_CONVERSATION_ENV = "SUPER_PI_TASK_CONVERSATION";
 export const TASK_DEPTH_ENV = "SUPER_PI_TASK_DEPTH";
@@ -200,6 +201,8 @@ export function renderTaskResult(input: { id: string; state: "completed" | "erro
 /** What the extension learns from its own environment before it can dispatch anything. */
 export type TaskToolConfig = {
   endpoint: string;
+  /** The exec endpoint for background shell commands. Opaque to the caller. */
+  execEndpoint: string;
   conversationId: string;
   depth: number;
   roster: RosterEntry[];
@@ -223,6 +226,7 @@ export function readTaskConfig(env: Record<string, string | undefined>): TaskToo
   const capability = env[TASK_CAPABILITY_ENV];
   return {
     endpoint: env[TASK_ENDPOINT_ENV] ?? "",
+    execEndpoint: env[TASK_EXEC_ENDPOINT_ENV] ?? "",
     conversationId: env[TASK_CONVERSATION_ENV] ?? "",
     // An unreadable depth is 0, the primary agent's own value, rather than a number that would claim to
     // be nested and trip the server's refusal for a reason that has nothing to do with this call.
@@ -258,6 +262,7 @@ export function refuseTask(config: TaskToolConfig, params: TaskParams): string |
   if (!params.subagent_type.trim()) return `subagent_type is required. Available: ${config.roster.map((entry) => entry.id).join(", ")}.`;
   if (!config.roster.some((entry) => entry.id === params.subagent_type)) return `${JSON.stringify(params.subagent_type)} is not a dispatchable subagent_type. Available: ${config.roster.map((entry) => entry.id).join(", ")}. Pick one of those, or do the work yourself.`;
   if (!params.prompt.trim()) return "prompt is required and must not be empty: the sub-agent starts with a fresh context and your prompt is everything it will know.";
+  if (params.background === true && !config.execEndpoint) return `Background tasks are not available: ${TASK_EXEC_ENDPOINT_ENV} is not set. Do the work yourself with your other tools.`;
   return undefined;
 }
 
@@ -284,6 +289,36 @@ export async function executeTask(
   const refusal = refuseTask(config, params);
   if (refusal) return text(renderTaskResult({ id: "refused", state: "error", text: refusal }), true);
 
+  // Background: true uses the lightweight exec endpoint instead of the subagent dispatcher.
+  // This avoids spawning a full Pi agent process for a plain shell command.
+  if (params.background === true && config.execEndpoint) {
+    const send = deps.fetch ?? globalFetch;
+    let response: Awaited<ReturnType<TaskFetch>>;
+    try {
+      response = await send(config.execEndpoint, {
+        method: "POST",
+        headers: { "content-type": "application/json", ...(config.token ? { authorization: `Bearer ${config.token}` } : {}) },
+        body: JSON.stringify({
+          cmd: params.prompt,
+          cwd: context.cwd,
+          conversationId: config.conversationId,
+          capability: config.capability,
+        }),
+        ...(deps.signal ? { signal: deps.signal } : {}),
+      });
+    } catch (error) {
+      return text(renderTaskResult({ id: "unreachable", state: "error", text: `Could not reach the Super Pi server at ${config.execEndpoint}: ${error instanceof Error ? error.message : "unknown error"}` }), true);
+    }
+    let payload: { sessionId?: string; status?: string; error?: string };
+    try { payload = JSON.parse(await response.text()) as typeof payload; }
+    catch { return text(renderTaskResult({ id: "unreadable", state: "error", text: `The exec endpoint answered ${response.status} with something that is not JSON.` }), true); }
+    const id = payload.sessionId ?? "refused";
+    if (payload.status === "running") {
+      return text(`<task id="${id}" state="running">\n<summary>${params.description.trim() || params.prompt.slice(0, 60)}</summary>\n<task_result>The command is running in the background. You will be notified automatically when it finishes. Do not sleep, poll for progress, or duplicate this work. Continue with non-overlapping work.</task_result>\n</task>`);
+    }
+    return text(renderTaskResult({ id, state: "error", text: payload.error ?? `Exec endpoint returned status ${payload.status}` }), true);
+  }
+
   const send = deps.fetch ?? globalFetch;
   let response: Awaited<ReturnType<TaskFetch>>;
   try {
@@ -298,7 +333,7 @@ export async function executeTask(
         prompt: params.prompt,
         description: params.description,
         depth: config.depth,
-        background: params.background === true,
+        background: false,
         // Always sent, even when undefined, so a body that omits the field is unambiguously a caller that
         // did not have one - which the server treats as a refusal, not as a legacy request to let through.
         capability: config.capability,