@pi-ohm/subagents 0.6.4-dev.22132543465.1.e4e3071 → 0.6.4-dev.22169815567.1.cdde4e8

package/src/runtime/backend.test.ts

@@ -3,11 +3,18 @@ import test from "node:test";
 import type { OhmRuntimeConfig, OhmSubagentBackend } from "@pi-ohm/config";
 import { Result } from "better-result";
 import type { OhmSubagentDefinition } from "../catalog";
+import { SubagentRuntimeError } from "../errors";
 import {
+  applyPiSdkSessionEvent,
   createDefaultTaskExecutionBackend,
+  createPiSdkStreamCaptureState,
+  finalizePiSdkStreamCapture,
   PiCliTaskExecutionBackend,
+  PiSdkTaskExecutionBackend,
   ScaffoldTaskExecutionBackend,
   type PiCliRunner,
+  type PiSdkRunner,
+  type TaskExecutionBackend,
 } from "./backend";
 
 function defineTest(name: string, run: () => void | Promise<void>): void {
@@ -197,7 +204,11 @@ defineTest(
     assert.equal(prompts.length, 1);
     assert.match(prompts[0] ?? "", /You are the Finder subagent in Pi OHM/);
     assert.equal(result.value.output, "finder online");
-    assert.match(result.value.summary, /Finder: finder online/);
+    assert.match(result.value.summary, /Finder: Auth flow scan/);
+    assert.equal(result.value.runtime, "pi-cli");
+    assert.equal(result.value.route, "interactive-shell");
+    assert.equal(result.value.provider, "unavailable");
+    assert.equal(result.value.model, "unavailable");
   },
 );
 
@@ -238,6 +249,442 @@ defineTest(
   },
 );
 
+defineTest(
+  "PiCliTaskExecutionBackend strips backend/provider/model metadata lines from nested output",
+  async () => {
+    const runner: PiCliRunner = async () => ({
+      exitCode: 0,
+      stdout: [
+        "backend: pi-coding-agent",
+        "provider: openai-codex",
+        "model: gpt-5.3-codex",
+        "",
+        "actual line one",
+        "actual line two",
+      ].join("\n"),
+      stderr: "",
+      timedOut: false,
+      aborted: false,
+    });
+
+    const backend = new PiCliTaskExecutionBackend(runner, 1_000);
+    const result = await backend.executeStart({
+      taskId: "task_9",
+      subagent: subagentFixture,
+      description: "Auth flow scan",
+      prompt: "Find auth validation path and refresh flow",
+      cwd: "/tmp/project",
+      config: makeConfig("interactive-shell"),
+      signal: undefined,
+    });
+
+    assert.equal(Result.isOk(result), true);
+    if (Result.isError(result)) {
+      assert.fail("Expected sanitized output success");
+    }
+
+    assert.doesNotMatch(result.value.output, /^backend:/m);
+    assert.doesNotMatch(result.value.output, /^provider:/m);
+    assert.doesNotMatch(result.value.output, /^model:/m);
+    assert.match(result.value.output, /actual line one/);
+    assert.match(result.value.output, /actual line two/);
+    assert.equal(result.value.provider, "openai-codex");
+    assert.equal(result.value.model, "gpt-5.3-codex");
+    assert.equal(result.value.runtime, "pi-coding-agent");
+    assert.equal(result.value.route, "interactive-shell");
+  },
+);
+
+defineTest("PiSdkTaskExecutionBackend executes sdk runner for interactive-sdk", async () => {
+  const prompts: string[] = [];
+
+  const runner: PiSdkRunner = async (input) => {
+    prompts.push(input.prompt);
+    return {
+      output: "sdk online",
+      events: [],
+      provider: "sdk-provider",
+      model: "sdk-model",
+      runtime: "pi-sdk",
+      timedOut: false,
+      aborted: false,
+    };
+  };
+
+  const backend = new PiSdkTaskExecutionBackend(runner, 1_000);
+  const result = await backend.executeStart({
+    taskId: "task_sdk_1",
+    subagent: subagentFixture,
+    description: "Auth flow scan",
+    prompt: "Trace auth validation path",
+    cwd: "/tmp/project",
+    config: makeConfig("interactive-sdk"),
+    signal: undefined,
+  });
+
+  assert.equal(Result.isOk(result), true);
+  if (Result.isError(result)) {
+    assert.fail("Expected interactive-sdk backend execution to succeed");
+  }
+
+  assert.equal(prompts.length, 1);
+  assert.match(prompts[0] ?? "", /You are the Finder subagent in Pi OHM/);
+  assert.equal(result.value.output, "sdk online");
+  assert.equal(result.value.provider, "sdk-provider");
+  assert.equal(result.value.model, "sdk-model");
+  assert.equal(result.value.runtime, "pi-sdk");
+  assert.equal(result.value.route, "interactive-sdk");
+});
+
+defineTest("Pi SDK stream capture records tool lifecycle and assistant deltas", () => {
+  const capture = createPiSdkStreamCaptureState();
+
+  applyPiSdkSessionEvent(capture, {
+    type: "tool_execution_start",
+    toolCallId: "tool_1",
+    toolName: "read",
+    args: { path: "src/index.ts" },
+  });
+  applyPiSdkSessionEvent(capture, {
+    type: "tool_execution_update",
+    toolCallId: "tool_1",
+    toolName: "read",
+    partialResult: { progress: "50%" },
+  });
+  applyPiSdkSessionEvent(capture, {
+    type: "tool_execution_end",
+    toolCallId: "tool_1",
+    toolName: "read",
+    result: { ok: true },
+    isError: false,
+  });
+  applyPiSdkSessionEvent(capture, {
+    type: "message_update",
+    assistantMessageEvent: { type: "text_delta", delta: "Found auth flow." },
+  });
+  applyPiSdkSessionEvent(capture, {
+    type: "agent_end",
+  });
+
+  const finalized = finalizePiSdkStreamCapture(capture);
+  assert.equal(finalized.sawAgentEnd, true);
+  assert.equal(finalized.capturedEventCount, 5);
+  assert.match(finalized.output, /tool_call: read start/);
+  assert.match(finalized.output, /tool_call: read update/);
+  assert.match(finalized.output, /tool_call: read end success/);
+  assert.match(finalized.output, /Found auth flow\./);
+});
+
+defineTest("Pi SDK stream capture ignores unsupported events", () => {
+  const capture = createPiSdkStreamCaptureState();
+
+  applyPiSdkSessionEvent(capture, { type: "turn_start", turnIndex: 1 });
+  applyPiSdkSessionEvent(capture, {
+    type: "message_update",
+    assistantMessageEvent: { type: "thinking_delta", delta: "..." },
+  });
+  applyPiSdkSessionEvent(capture, {
+    type: "tool_execution_start",
+    toolCallId: "tool_1",
+    toolName: "bash",
+    args: undefined,
+  });
+
+  const finalized = finalizePiSdkStreamCapture(capture);
+  assert.equal(finalized.capturedEventCount, 1);
+  assert.equal(finalized.sawAgentEnd, false);
+  assert.match(finalized.output, /tool_call: bash start/);
+});
+
+defineTest("PiSdkTaskExecutionBackend maps timeout/abort/execution failures", async () => {
+  const timeoutBackend = new PiSdkTaskExecutionBackend(async () => ({
+    output: "",
+    events: [],
+    timedOut: true,
+    aborted: false,
+  }));
+
+  const timedOut = await timeoutBackend.executeStart({
+    taskId: "task_sdk_timeout",
+    subagent: subagentFixture,
+    description: "timeout",
+    prompt: "timeout",
+    cwd: "/tmp/project",
+    config: makeConfig("interactive-sdk"),
+    signal: undefined,
+  });
+
+  assert.equal(Result.isError(timedOut), true);
+  if (Result.isOk(timedOut)) {
+    assert.fail("Expected timeout error");
+  }
+  assert.equal(timedOut.error.code, "task_backend_timeout");
+
+  const abortedBackend = new PiSdkTaskExecutionBackend(async () => ({
+    output: "",
+    events: [],
+    timedOut: false,
+    aborted: true,
+  }));
+
+  const aborted = await abortedBackend.executeStart({
+    taskId: "task_sdk_abort",
+    subagent: subagentFixture,
+    description: "abort",
+    prompt: "abort",
+    cwd: "/tmp/project",
+    config: makeConfig("interactive-sdk"),
+    signal: undefined,
+  });
+
+  assert.equal(Result.isError(aborted), true);
+  if (Result.isOk(aborted)) {
+    assert.fail("Expected aborted error");
+  }
+  assert.equal(aborted.error.code, "task_aborted");
+
+  const failedBackend = new PiSdkTaskExecutionBackend(async () => ({
+    output: "",
+    events: [],
+    timedOut: false,
+    aborted: false,
+    error: "sdk failed",
+  }));
+
+  const failed = await failedBackend.executeSend({
+    taskId: "task_sdk_fail",
+    subagent: subagentFixture,
+    description: "failure",
+    initialPrompt: "initial",
+    followUpPrompts: [],
+    prompt: "follow-up",
+    cwd: "/tmp/project",
+    config: makeConfig("interactive-sdk"),
+    signal: undefined,
+  });
+
+  assert.equal(Result.isError(failed), true);
+  if (Result.isOk(failed)) {
+    assert.fail("Expected execution failure");
+  }
+  assert.equal(failed.error.code, "task_backend_execution_failed");
+});
+
+defineTest("PiCliTaskExecutionBackend delegates to sdk backend when configured", async () => {
+  let cliCalled = false;
+
+  const cliRunner: PiCliRunner = async () => {
+    cliCalled = true;
+    return {
+      exitCode: 0,
+      stdout: "cli output",
+      stderr: "",
+      timedOut: false,
+      aborted: false,
+    };
+  };
+
+  const sdkBackend: TaskExecutionBackend = {
+    id: "interactive-sdk",
+    async executeStart() {
+      return Result.ok({
+        summary: "Finder: via sdk",
+        output: "sdk output",
+        provider: "sdk-provider",
+        model: "sdk-model",
+        runtime: "pi-sdk",
+        route: "interactive-sdk",
+      });
+    },
+    async executeSend() {
+      return Result.ok({
+        summary: "Finder follow-up: via sdk",
+        output: "sdk follow-up output",
+        provider: "sdk-provider",
+        model: "sdk-model",
+        runtime: "pi-sdk",
+        route: "interactive-sdk",
+      });
+    },
+  };
+
+  const backend = new PiCliTaskExecutionBackend(cliRunner, 1_000, sdkBackend);
+  const result = await backend.executeStart({
+    taskId: "task_sdk_2",
+    subagent: subagentFixture,
+    description: "Auth flow scan",
+    prompt: "Trace auth validation path",
+    cwd: "/tmp/project",
+    config: makeConfig("interactive-sdk"),
+    signal: undefined,
+  });
+
+  assert.equal(cliCalled, false);
+  assert.equal(Result.isOk(result), true);
+  if (Result.isError(result)) {
+    assert.fail("Expected sdk delegation to succeed");
+  }
+
+  assert.equal(result.value.output, "sdk output");
+  assert.equal(result.value.route, "interactive-sdk");
+});
+
+defineTest(
+  "PiCliTaskExecutionBackend falls back to cli when sdk fails and fallback is enabled",
+  async () => {
+    const previous = process.env.OHM_SUBAGENTS_SDK_FALLBACK_TO_CLI;
+    process.env.OHM_SUBAGENTS_SDK_FALLBACK_TO_CLI = "true";
+
+    try {
+      let cliCalls = 0;
+      const cliRunner: PiCliRunner = async () => {
+        cliCalls += 1;
+        return {
+          exitCode: 0,
+          stdout: "cli fallback output",
+          stderr: "",
+          timedOut: false,
+          aborted: false,
+        };
+      };
+
+      const sdkBackend: TaskExecutionBackend = {
+        id: "interactive-sdk",
+        async executeStart() {
+          return Result.err(
+            new SubagentRuntimeError({
+              code: "task_backend_execution_failed",
+              stage: "execute_start",
+              message: "sdk bootstrap failed",
+            }),
+          );
+        },
+        async executeSend() {
+          return Result.err(
+            new SubagentRuntimeError({
+              code: "task_backend_execution_failed",
+              stage: "execute_send",
+              message: "sdk bootstrap failed",
+            }),
+          );
+        },
+      };
+
+      const backend = new PiCliTaskExecutionBackend(cliRunner, 1_000, sdkBackend);
+      const result = await backend.executeStart({
+        taskId: "task_sdk_fallback",
+        subagent: subagentFixture,
+        description: "Fallback run",
+        prompt: "Use cli fallback",
+        cwd: "/tmp/project",
+        config: makeConfig("interactive-sdk"),
+        signal: undefined,
+      });
+
+      assert.equal(Result.isOk(result), true);
+      if (Result.isError(result)) {
+        assert.fail("Expected sdk->cli fallback success");
+      }
+
+      assert.equal(cliCalls, 1);
+      assert.equal(result.value.output, "cli fallback output");
+      assert.equal(result.value.route, "interactive-shell");
+    } finally {
+      if (previous === undefined) {
+        delete process.env.OHM_SUBAGENTS_SDK_FALLBACK_TO_CLI;
+      } else {
+        process.env.OHM_SUBAGENTS_SDK_FALLBACK_TO_CLI = previous;
+      }
+    }
+  },
+);
+
+defineTest(
+  "PiCliTaskExecutionBackend keeps sdk error taxonomy when fallback is disabled",
+  async () => {
+    const previous = process.env.OHM_SUBAGENTS_SDK_FALLBACK_TO_CLI;
+    delete process.env.OHM_SUBAGENTS_SDK_FALLBACK_TO_CLI;
+
+    try {
+      let cliCalls = 0;
+      const cliRunner: PiCliRunner = async () => {
+        cliCalls += 1;
+        return {
+          exitCode: 0,
+          stdout: "cli output",
+          stderr: "",
+          timedOut: false,
+          aborted: false,
+        };
+      };
+
+      const sdkBackend: TaskExecutionBackend = {
+        id: "interactive-sdk",
+        async executeStart() {
+          return Result.err(
+            new SubagentRuntimeError({
+              code: "task_backend_timeout",
+              stage: "execute_start",
+              message: "sdk timed out",
+            }),
+          );
+        },
+        async executeSend() {
+          return Result.err(
+            new SubagentRuntimeError({
+              code: "task_aborted",
+              stage: "execute_send",
+              message: "sdk aborted",
+            }),
+          );
+        },
+      };
+
+      const backend = new PiCliTaskExecutionBackend(cliRunner, 1_000, sdkBackend);
+      const started = await backend.executeStart({
+        taskId: "task_sdk_no_fallback",
+        subagent: subagentFixture,
+        description: "No fallback start",
+        prompt: "start",
+        cwd: "/tmp/project",
+        config: makeConfig("interactive-sdk"),
+        signal: undefined,
+      });
+
+      assert.equal(Result.isError(started), true);
+      if (Result.isOk(started)) {
+        assert.fail("Expected sdk start failure without fallback");
+      }
+      assert.equal(started.error.code, "task_backend_timeout");
+
+      const sent = await backend.executeSend({
+        taskId: "task_sdk_no_fallback",
+        subagent: subagentFixture,
+        description: "No fallback send",
+        initialPrompt: "initial",
+        followUpPrompts: [],
+        prompt: "send",
+        cwd: "/tmp/project",
+        config: makeConfig("interactive-sdk"),
+        signal: undefined,
+      });
+
+      assert.equal(Result.isError(sent), true);
+      if (Result.isOk(sent)) {
+        assert.fail("Expected sdk send failure without fallback");
+      }
+      assert.equal(sent.error.code, "task_aborted");
+      assert.equal(cliCalls, 0);
+    } finally {
+      if (previous === undefined) {
+        delete process.env.OHM_SUBAGENTS_SDK_FALLBACK_TO_CLI;
+      } else {
+        process.env.OHM_SUBAGENTS_SDK_FALLBACK_TO_CLI = previous;
+      }
+    }
+  },
+);
+
 defineTest("PiCliTaskExecutionBackend reports timeout and backend execution failures", async () => {
   const timeoutRunner: PiCliRunner = async () => ({
     exitCode: 124,
@@ -290,6 +737,58 @@ defineTest("PiCliTaskExecutionBackend reports timeout and backend execution fail
   assert.equal(failed.error.code, "task_backend_execution_failed");
 });
 
+defineTest("PiSdkTaskExecutionBackend maps send timeout and abort", async () => {
+  const timeoutBackend = new PiSdkTaskExecutionBackend(async () => ({
+    output: "",
+    events: [],
+    timedOut: true,
+    aborted: false,
+  }));
+
+  const timedOut = await timeoutBackend.executeSend({
+    taskId: "task_sdk_send_timeout",
+    subagent: subagentFixture,
+    description: "send timeout",
+    initialPrompt: "initial",
+    followUpPrompts: [],
+    prompt: "follow-up",
+    cwd: "/tmp/project",
+    config: makeConfig("interactive-sdk"),
+    signal: undefined,
+  });
+
+  assert.equal(Result.isError(timedOut), true);
+  if (Result.isOk(timedOut)) {
+    assert.fail("Expected send timeout error");
+  }
+  assert.equal(timedOut.error.code, "task_backend_timeout");
+
+  const abortedBackend = new PiSdkTaskExecutionBackend(async () => ({
+    output: "",
+    events: [],
+    timedOut: false,
+    aborted: true,
+  }));
+
+  const aborted = await abortedBackend.executeSend({
+    taskId: "task_sdk_send_abort",
+    subagent: subagentFixture,
+    description: "send abort",
+    initialPrompt: "initial",
+    followUpPrompts: [],
+    prompt: "follow-up",
+    cwd: "/tmp/project",
+    config: makeConfig("interactive-sdk"),
+    signal: undefined,
+  });
+
+  assert.equal(Result.isError(aborted), true);
+  if (Result.isOk(aborted)) {
+    assert.fail("Expected send aborted error");
+  }
+  assert.equal(aborted.error.code, "task_aborted");
+});
+
 defineTest("PiCliTaskExecutionBackend resolves backend IDs from runtime config", () => {
   const backend = new PiCliTaskExecutionBackend(async () => ({
     exitCode: 0,
@@ -300,6 +799,7 @@ defineTest("PiCliTaskExecutionBackend resolves backend IDs from runtime config",
   }));
 
   assert.equal(backend.resolveBackendId(makeConfig("interactive-shell")), "interactive-shell");
+  assert.equal(backend.resolveBackendId(makeConfig("interactive-sdk")), "interactive-sdk");
   assert.equal(backend.resolveBackendId(makeConfig("none")), "scaffold");
   assert.equal(backend.resolveBackendId(makeConfig("custom-plugin")), "custom-plugin");
 });