@stigmer/runner 3.0.1

package/src/__test-utils__/__tests__/replay-fetch.test.ts

@@ -0,0 +1,155 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { mkdtempSync, rmSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import {
+  ReplayFetchInterceptor,
+  writeFixture,
+  anthropicResponseBody,
+  openaiResponseBody,
+} from "../replay-fetch.js";
+
+const originalFetch = globalThis.fetch;
+
+function makeTempDir(): string {
+  return mkdtempSync(join(tmpdir(), "replay-fetch-test-"));
+}
+
+describe("ReplayFetchInterceptor", () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = makeTempDir();
+  });
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch;
+    rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  describe("replay mode", () => {
+    it("replays recorded responses in order", async () => {
+      writeFixture("test-replay", [
+        {
+          request: { url: "https://proxy/v1/proxy/llm/anthropic/v1/messages" },
+          response: { body: anthropicResponseBody("Hello from turn 1") },
+        },
+        {
+          request: { url: "https://proxy/v1/proxy/llm/anthropic/v1/messages" },
+          response: { body: anthropicResponseBody("Hello from turn 2") },
+        },
+      ], tempDir);
+
+      const interceptor = new ReplayFetchInterceptor("test-replay", { fixturesDir: tempDir });
+      interceptor.install();
+
+      const r1 = await fetch("https://proxy/v1/proxy/llm/anthropic/v1/messages", { method: "POST" });
+      const b1 = await r1.json() as Record<string, unknown>;
+      const content1 = (b1.content as Array<{ text: string }>);
+      expect(content1[0].text).toBe("Hello from turn 1");
+
+      const r2 = await fetch("https://proxy/v1/proxy/llm/anthropic/v1/messages", { method: "POST" });
+      const b2 = await r2.json() as Record<string, unknown>;
+      const content2 = (b2.content as Array<{ text: string }>);
+      expect(content2[0].text).toBe("Hello from turn 2");
+
+      expect(interceptor.allConsumed).toBe(true);
+      interceptor.uninstall();
+    });
+
+    it("throws when fixture file is missing", () => {
+      const interceptor = new ReplayFetchInterceptor("nonexistent", { fixturesDir: tempDir });
+      expect(() => interceptor.install()).toThrow("fixture not found");
+    });
+
+    it("throws when all entries are consumed", async () => {
+      writeFixture("one-entry", [
+        {
+          request: { url: "https://proxy/v1/proxy/llm/anthropic/v1/messages" },
+          response: { body: anthropicResponseBody("Only response") },
+        },
+      ], tempDir);
+
+      const interceptor = new ReplayFetchInterceptor("one-entry", { fixturesDir: tempDir });
+      interceptor.install();
+
+      await fetch("https://proxy/v1/proxy/llm/anthropic/v1/messages", { method: "POST" });
+
+      await expect(
+        fetch("https://proxy/v1/proxy/llm/anthropic/v1/messages", { method: "POST" }),
+      ).rejects.toThrow("no more recorded entries");
+
+      interceptor.uninstall();
+    });
+
+    it("passes through non-LLM URLs to original fetch", async () => {
+      writeFixture("passthrough", [
+        {
+          request: { url: "https://proxy/v1/proxy/llm/anthropic/v1/messages" },
+          response: { body: anthropicResponseBody("LLM response") },
+        },
+      ], tempDir);
+
+      const mockOriginal = async () => new Response('{"ok":true}', { status: 200 });
+      globalThis.fetch = mockOriginal as typeof globalThis.fetch;
+
+      const interceptor = new ReplayFetchInterceptor("passthrough", { fixturesDir: tempDir });
+      interceptor.install();
+
+      const nonLlm = await fetch("https://example.com/api/data");
+      const nonLlmBody = await nonLlm.json();
+      expect(nonLlmBody).toEqual({ ok: true });
+
+      expect(interceptor.consumedCount).toBe(0);
+      interceptor.uninstall();
+    });
+  });
+
+  describe("writeFixture", () => {
+    it("creates fixture file with correct structure", () => {
+      const path = writeFixture("structured", [
+        {
+          request: { method: "POST", url: "https://api/v1/messages" },
+          response: { status: 200, body: { test: true } },
+        },
+      ], tempDir);
+
+      expect(existsSync(path)).toBe(true);
+    });
+  });
+
+  describe("response builders", () => {
+    it("builds Anthropic response with text", () => {
+      const body = anthropicResponseBody("test text", { inputTokens: 50, outputTokens: 25 });
+      expect(body.content).toEqual([{ type: "text", text: "test text" }]);
+      expect((body.usage as Record<string, number>).input_tokens).toBe(50);
+      expect(body.stop_reason).toBe("end_turn");
+    });
+
+    it("builds Anthropic response with tool use", () => {
+      const body = anthropicResponseBody("thinking...", {
+        toolUse: [{ id: "tc_1", name: "echo", input: { text: "hello" } }],
+      });
+      const content = body.content as Array<Record<string, unknown>>;
+      expect(content[0].type).toBe("tool_use");
+      expect(content[0].name).toBe("echo");
+      expect(body.stop_reason).toBe("tool_use");
+    });
+
+    it("builds OpenAI response with text", () => {
+      const body = openaiResponseBody("hello", { promptTokens: 20, completionTokens: 10 });
+      const choices = body.choices as Array<Record<string, unknown>>;
+      const msg = choices[0].message as Record<string, unknown>;
+      expect(msg.content).toBe("hello");
+      expect(choices[0].finish_reason).toBe("stop");
+    });
+
+    it("builds OpenAI response with tool calls", () => {
+      const body = openaiResponseBody("", {
+        toolCalls: [{ id: "call_1", name: "search", arguments: '{"q":"test"}' }],
+      });
+      const choices = body.choices as Array<Record<string, unknown>>;
+      expect(choices[0].finish_reason).toBe("tool_calls");
+    });
+  });
+});

package/src/__test-utils__/mock-client.ts

@@ -0,0 +1,44 @@
+/**
+ * Shared mock factory for StigmerClient used across test suites.
+ *
+ * StigmerClient is a class (not an interface), so mocks use
+ * `as unknown as StigmerClient` — matching the established pattern
+ * in grpc-retry.test.ts and connect-backfill.test.ts.
+ */
+
+import { vi } from "vitest";
+import { ExecutionControlSignal } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+import type { StigmerClient } from "../client/stigmer-client.js";
+
+type MockMethods = {
+  [K in keyof StigmerClient]?: StigmerClient[K];
+};
+
+export function mockStigmerClient(overrides: MockMethods = {}): StigmerClient {
+  return {
+    updateStatus: vi.fn().mockResolvedValue({
+      signal: ExecutionControlSignal.UNSPECIFIED,
+    }),
+    getExecution: vi.fn().mockResolvedValue({}),
+    getExecutionContextByExecutionId: vi.fn().mockResolvedValue({}),
+    getSession: vi.fn().mockResolvedValue({}),
+    updateSession: vi.fn().mockResolvedValue({}),
+    getAgent: vi.fn().mockResolvedValue({}),
+    getAgentInstance: vi.fn().mockResolvedValue({}),
+    getMcpServer: vi.fn().mockResolvedValue({}),
+    getMcpServerByReference: vi.fn().mockResolvedValue({}),
+    connectMcpServer: vi.fn().mockResolvedValue({}),
+    getSkill: vi.fn().mockResolvedValue({}),
+    getSkillByReference: vi.fn().mockResolvedValue({}),
+    getSkillArtifact: vi.fn().mockResolvedValue({}),
+    recordLlmCallUsage: vi.fn().mockResolvedValue({}),
+    getWorkflowExecution: vi.fn().mockResolvedValue({}),
+    getWorkflow: vi.fn().mockResolvedValue({}),
+    getWorkflowInstance: vi.fn().mockResolvedValue({}),
+    updateWorkflowExecutionStatus: vi.fn().mockResolvedValue({}),
+    getAgentByReference: vi.fn().mockResolvedValue({}),
+    createSession: vi.fn().mockResolvedValue({}),
+    createAgentExecution: vi.fn().mockResolvedValue({}),
+    ...overrides,
+  } as unknown as StigmerClient;
+}

package/src/__test-utils__/mock-workspace.ts

@@ -0,0 +1,28 @@
+/**
+ * Shared mock factory for WorkspaceBackend used across test suites.
+ *
+ * Returns a typed mock that satisfies the WorkspaceBackend interface.
+ * Individual tests can override specific methods via the overrides param
+ * or by reassigning the mock after creation.
+ */
+
+import { vi } from "vitest";
+import type { WorkspaceBackend } from "../shared/workspace/types.js";
+
+type MockOverrides = {
+  [K in keyof Omit<WorkspaceBackend, "rootDir">]?: WorkspaceBackend[K];
+} & { rootDir?: string };
+
+export function mockWorkspaceBackend(overrides: MockOverrides = {}): WorkspaceBackend {
+  const { rootDir = "/tmp/test-workspace", ...methodOverrides } = overrides;
+
+  return {
+    rootDir,
+    execute: vi.fn().mockResolvedValue(""),
+    readFile: vi.fn().mockResolvedValue(""),
+    writeFile: vi.fn().mockResolvedValue(undefined),
+    writeFileBuffer: vi.fn().mockResolvedValue(undefined),
+    exists: vi.fn().mockResolvedValue(false),
+    ...methodOverrides,
+  };
+}

package/src/__test-utils__/proto-helpers.ts

@@ -0,0 +1,41 @@
+/**
+ * Shared protobuf message factories for tests.
+ *
+ * Centralizes the `create(Schema, {...})` patterns that appear across
+ * many test files. Reduces import boilerplate and ensures consistent
+ * proto construction.
+ */
+
+import { create } from "@bufbuild/protobuf";
+import {
+  AgentExecutionStatusSchema,
+} from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/api_pb";
+import type { AgentExecutionStatus } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/api_pb";
+import {
+  AgentMessageSchema,
+  ToolCallSchema,
+} from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/message_pb";
+import type { AgentMessage, ToolCall } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/message_pb";
+import {
+  MessageType,
+  ToolCallStatus,
+} from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+
+export function emptyStatus(): AgentExecutionStatus {
+  return create(AgentExecutionStatusSchema, {});
+}
+
+export function aiMessage(content: string): AgentMessage {
+  return create(AgentMessageSchema, {
+    type: MessageType.MESSAGE_AI,
+    content,
+  });
+}
+
+export function toolCall(
+  id: string,
+  name: string,
+  status: ToolCallStatus = ToolCallStatus.TOOL_CALL_RUNNING,
+): ToolCall {
+  return create(ToolCallSchema, { id, name, status });
+}