@stigmer/runner 3.0.1

package/src/activities/execute-deep-agent/__tests__/auto-publish.test.ts

@@ -0,0 +1,146 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { create, type JsonObject } 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 { MessageType, ToolCallStatus } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+import { autoPublishWrittenFiles } from "../auto-publish.js";
+import type { InlinePublisher } from "../inline-publisher.js";
+
+function makeStatus(toolCalls: { name: string; args?: Record<string, unknown> }[]): AgentExecutionStatus {
+  const status = create(AgentExecutionStatusSchema, {});
+  const msg = create(AgentMessageSchema, {
+    type: MessageType.MESSAGE_AI,
+    content: "test",
+    timestamp: "2026-01-01T00:00:00Z",
+  });
+
+  for (const tc of toolCalls) {
+    const toolCall = create(ToolCallSchema, {
+      id: `tc-${tc.name}`,
+      name: tc.name,
+      status: ToolCallStatus.TOOL_CALL_COMPLETED,
+    });
+    if (tc.args) {
+      toolCall.args = tc.args as JsonObject;
+    }
+    msg.toolCalls.push(toolCall);
+  }
+
+  status.messages.push(msg);
+  return status;
+}
+
+function mockInlinePublisher(alreadyPublished: string[] = []): InlinePublisher & {
+  publishCalls: string[];
+} {
+  const publishCalls: string[] = [];
+  return {
+    publishCalls,
+    publishedPaths: new Set(alreadyPublished),
+    publish: vi.fn(async (path: string) => {
+      publishCalls.push(path);
+    }),
+  } as any;
+}
+
+describe("autoPublishWrittenFiles", () => {
+  it("publishes files from write_file tool calls", async () => {
+    const status = makeStatus([
+      { name: "write_file", args: { path: "src/main.ts" } },
+    ]);
+    const publisher = mockInlinePublisher();
+
+    const count = await autoPublishWrittenFiles(status, publisher);
+
+    expect(count).toBe(1);
+    expect(publisher.publishCalls).toEqual(["src/main.ts"]);
+  });
+
+  it("publishes files from edit_file tool calls", async () => {
+    const status = makeStatus([
+      { name: "edit_file", args: { file_path: "/src/app.tsx" } },
+    ]);
+    const publisher = mockInlinePublisher();
+
+    const count = await autoPublishWrittenFiles(status, publisher);
+
+    expect(count).toBe(1);
+    expect(publisher.publishCalls).toEqual(["src/app.tsx"]);
+  });
+
+  it("skips already-published paths", async () => {
+    const status = makeStatus([
+      { name: "write_file", args: { path: "src/main.ts" } },
+    ]);
+    const publisher = mockInlinePublisher(["src/main.ts"]);
+
+    const count = await autoPublishWrittenFiles(status, publisher);
+
+    expect(count).toBe(0);
+    expect(publisher.publishCalls).toHaveLength(0);
+  });
+
+  it("skips non-file-modifying tools", async () => {
+    const status = makeStatus([
+      { name: "read_file", args: { path: "src/main.ts" } },
+      { name: "search", args: { query: "test" } },
+    ]);
+    const publisher = mockInlinePublisher();
+
+    const count = await autoPublishWrittenFiles(status, publisher);
+
+    expect(count).toBe(0);
+  });
+
+  it("deduplicates paths within the same scan", async () => {
+    const status = makeStatus([
+      { name: "write_file", args: { path: "src/main.ts" } },
+      { name: "edit_file", args: { path: "src/main.ts" } },
+    ]);
+    const publisher = mockInlinePublisher();
+
+    const count = await autoPublishWrittenFiles(status, publisher);
+
+    expect(count).toBe(1);
+    expect(publisher.publishCalls).toEqual(["src/main.ts"]);
+  });
+
+  it("handles tool calls without args gracefully", async () => {
+    const status = makeStatus([
+      { name: "write_file" },
+    ]);
+    const publisher = mockInlinePublisher();
+
+    const count = await autoPublishWrittenFiles(status, publisher);
+
+    expect(count).toBe(0);
+  });
+
+  it("handles empty tool calls", async () => {
+    const status = create(AgentExecutionStatusSchema, {});
+    const publisher = mockInlinePublisher();
+
+    const count = await autoPublishWrittenFiles(status, publisher);
+
+    expect(count).toBe(0);
+  });
+
+  it("continues on publish failure", async () => {
+    const status = makeStatus([
+      { name: "write_file", args: { path: "fail.ts" } },
+      { name: "write_file", args: { path: "success.ts" } },
+    ]);
+    const publisher = mockInlinePublisher();
+    let callCount = 0;
+    (publisher as any).publish = vi.fn(async (path: string) => {
+      callCount++;
+      if (callCount === 1) throw new Error("boom");
+      publisher.publishCalls.push(path);
+    });
+
+    const count = await autoPublishWrittenFiles(status, publisher);
+
+    expect(count).toBe(1);
+  });
+});

package/src/activities/execute-deep-agent/__tests__/environment.test.ts

@@ -0,0 +1,103 @@
+import { describe, it, expect, vi } from "vitest";
+import { resolveEnvironment } from "../environment.js";
+
+function createMockClient(execContext: any) {
+  return {
+    getExecutionContextByExecutionId: vi.fn().mockResolvedValue(execContext),
+  } as any;
+}
+
+function createNotFoundClient() {
+  return {
+    getExecutionContextByExecutionId: vi.fn().mockRejectedValue(
+      Object.assign(new Error("not found"), { code: 5 }),
+    ),
+  } as any;
+}
+
+describe("resolveEnvironment", () => {
+  it("extracts plaintext environment variables", async () => {
+    const client = createMockClient({
+      spec: {
+        data: {
+          API_URL: { value: "https://api.example.com", isSecret: false },
+          REGION: { value: "us-east-1", isSecret: false },
+        },
+      },
+    });
+
+    const result = await resolveEnvironment(client, "exec-1");
+
+    expect(result.mergedEnvVars).toEqual({
+      API_URL: "https://api.example.com",
+      REGION: "us-east-1",
+    });
+    expect(result.secretKeys.size).toBe(0);
+  });
+
+  it("tracks secret keys separately", async () => {
+    const client = createMockClient({
+      spec: {
+        data: {
+          PUBLIC_KEY: { value: "pk_123", isSecret: false },
+          SECRET_KEY: { value: "sk_456", isSecret: true },
+          API_TOKEN: { value: "tok_789", isSecret: true },
+        },
+      },
+    });
+
+    const result = await resolveEnvironment(client, "exec-2");
+
+    expect(Object.keys(result.mergedEnvVars)).toHaveLength(3);
+    expect(result.secretKeys).toEqual(new Set(["SECRET_KEY", "API_TOKEN"]));
+  });
+
+  it("returns empty result when execution context not found", async () => {
+    const client = createNotFoundClient();
+
+    const result = await resolveEnvironment(client, "exec-no-ctx");
+
+    expect(result.mergedEnvVars).toEqual({});
+    expect(result.secretKeys.size).toBe(0);
+  });
+
+  it("returns empty result when spec.data is empty", async () => {
+    const client = createMockClient({ spec: { data: {} } });
+
+    const result = await resolveEnvironment(client, "exec-empty");
+
+    expect(result.mergedEnvVars).toEqual({});
+    expect(result.secretKeys.size).toBe(0);
+  });
+
+  it("returns empty result when spec.data is undefined", async () => {
+    const client = createMockClient({ spec: {} });
+
+    const result = await resolveEnvironment(client, "exec-no-data");
+
+    expect(result.mergedEnvVars).toEqual({});
+    expect(result.secretKeys.size).toBe(0);
+  });
+
+  it("propagates non-NOT_FOUND errors", async () => {
+    const client = {
+      getExecutionContextByExecutionId: vi.fn().mockRejectedValue(
+        new Error("connection refused"),
+      ),
+    } as any;
+
+    await expect(resolveEnvironment(client, "exec-err"))
+      .rejects.toThrow("connection refused");
+  });
+
+  it("handles NOT_FOUND with lowercase code", async () => {
+    const client = {
+      getExecutionContextByExecutionId: vi.fn().mockRejectedValue(
+        Object.assign(new Error("not found"), { code: "not_found" }),
+      ),
+    } as any;
+
+    const result = await resolveEnvironment(client, "exec-lc");
+    expect(result.mergedEnvVars).toEqual({});
+  });
+});

package/src/activities/execute-deep-agent/__tests__/event-recorder.test.ts

@@ -0,0 +1,150 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { readFile, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { mkdtemp } from "node:fs/promises";
+import { createV2EventRecorder } from "../event-recorder.js";
+import type { StreamEvent } from "../status-builder.js";
+
+function makeEvent(eventType: string, runId: string, data: Record<string, unknown> = {}): StreamEvent {
+  return { event: eventType, run_id: runId, data };
+}
+
+describe("createV2EventRecorder", () => {
+  it("returns undefined when recordDir is undefined", () => {
+    expect(createV2EventRecorder("exec-1", undefined)).toBeUndefined();
+  });
+
+  it("returns undefined when recordDir is empty string", () => {
+    expect(createV2EventRecorder("exec-1", "")).toBeUndefined();
+  });
+
+  it("returns a recorder when recordDir is provided", () => {
+    const recorder = createV2EventRecorder("exec-1", "/tmp/test");
+    expect(recorder).toBeDefined();
+    expect(recorder!.record).toBeInstanceOf(Function);
+    expect(recorder!.flush).toBeInstanceOf(Function);
+  });
+});
+
+describe("V2EventRecorder", () => {
+  let testDir: string;
+
+  beforeEach(async () => {
+    testDir = await mkdtemp(join(tmpdir(), "v2-recorder-test-"));
+  });
+
+  it("flush is a no-op when no events are recorded", async () => {
+    const recorder = createV2EventRecorder("exec-empty", testDir)!;
+    await recorder.flush();
+
+    const files = await import("node:fs/promises").then(fs => fs.readdir(testDir));
+    expect(files).toHaveLength(0);
+  });
+
+  it("writes events to a JSON file named by execution ID", async () => {
+    const recorder = createV2EventRecorder("exec-abc", testDir)!;
+
+    recorder.record(
+      makeEvent("on_chat_model_stream", "run-1", { chunk: { content: "hello" } }),
+      0,
+    );
+    recorder.record(
+      makeEvent("on_chat_model_end", "run-1", { output: { content: "done" } }),
+      1,
+    );
+
+    await recorder.flush();
+
+    const filePath = join(testDir, "exec-abc.v2-events.json");
+    const content = JSON.parse(await readFile(filePath, "utf-8"));
+
+    expect(content.executionId).toBe("exec-abc");
+    expect(content.eventCount).toBe(2);
+    expect(content.recordedAt).toBeTruthy();
+    expect(content.events).toHaveLength(2);
+
+    expect(content.events[0].seq).toBe(0);
+    expect(content.events[0].event).toBe("on_chat_model_stream");
+    expect(content.events[0].run_id).toBe("run-1");
+    expect(content.events[0].data.chunk.content).toBe("hello");
+    expect(content.events[0].timestamp).toBeTruthy();
+
+    expect(content.events[1].seq).toBe(1);
+    expect(content.events[1].event).toBe("on_chat_model_end");
+  });
+
+  it("preserves event metadata when present", async () => {
+    const recorder = createV2EventRecorder("exec-meta", testDir)!;
+
+    recorder.record(
+      {
+        event: "on_chat_model_stream",
+        run_id: "run-1",
+        data: { chunk: { content: "text" } },
+        metadata: { langgraph_checkpoint_ns: "tools:task-1|agent_node:inner" },
+      },
+      0,
+    );
+
+    await recorder.flush();
+
+    const content = JSON.parse(
+      await readFile(join(testDir, "exec-meta.v2-events.json"), "utf-8"),
+    );
+
+    expect(content.events[0].metadata.langgraph_checkpoint_ns).toBe(
+      "tools:task-1|agent_node:inner",
+    );
+  });
+
+  it("handles circular references in event data gracefully", async () => {
+    const recorder = createV2EventRecorder("exec-circular", testDir)!;
+
+    const circular: Record<string, unknown> = { a: 1 };
+    circular.self = circular;
+
+    recorder.record(
+      { event: "on_tool_end", run_id: "run-1", data: circular },
+      0,
+    );
+
+    await recorder.flush();
+
+    const content = JSON.parse(
+      await readFile(join(testDir, "exec-circular.v2-events.json"), "utf-8"),
+    );
+
+    expect(content.events[0].data._serializationError).toBe(true);
+    expect(content.events[0].data.keys).toContain("a");
+  });
+
+  it("creates output directory if it does not exist", async () => {
+    const nestedDir = join(testDir, "nested", "deep", "dir");
+    const recorder = createV2EventRecorder("exec-mkdir", nestedDir)!;
+
+    recorder.record(makeEvent("on_chat_model_stream", "run-1", { chunk: { content: "hi" } }), 0);
+    await recorder.flush();
+
+    const content = JSON.parse(
+      await readFile(join(nestedDir, "exec-mkdir.v2-events.json"), "utf-8"),
+    );
+    expect(content.eventCount).toBe(1);
+  });
+
+  it("preserves event name field", async () => {
+    const recorder = createV2EventRecorder("exec-name", testDir)!;
+
+    recorder.record(
+      { event: "on_tool_start", name: "read_file", run_id: "tool-1", data: { input: {} } },
+      0,
+    );
+
+    await recorder.flush();
+
+    const content = JSON.parse(
+      await readFile(join(testDir, "exec-name.v2-events.json"), "utf-8"),
+    );
+    expect(content.events[0].name).toBe("read_file");
+  });
+});

package/src/activities/execute-deep-agent/__tests__/execution-state-extended.test.ts

@@ -0,0 +1,150 @@
+/**
+ * Extended ExecutionState tests — ported from Python test_hitl_contracts.py
+ * and test_checkpoint_validator.py sections covering state rebuild/reset.
+ */
+
+import { describe, it, expect } from "vitest";
+import { create } from "@bufbuild/protobuf";
+import { AgentExecutionStatusSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/api_pb";
+import {
+  AgentMessageSchema,
+  ToolCallSchema,
+} from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/message_pb";
+import {
+  MessageType,
+  ToolCallStatus,
+} from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+import { ExecutionState } from "../execution-state.js";
+
+function makeStateWithMessages(): ExecutionState {
+  const status = create(AgentExecutionStatusSchema, {});
+  const msg = create(AgentMessageSchema, {
+    type: MessageType.MESSAGE_AI,
+    content: "test",
+    toolCalls: [
+      create(ToolCallSchema, {
+        id: "tc-1",
+        name: "read",
+        status: ToolCallStatus.TOOL_CALL_COMPLETED,
+      }),
+      create(ToolCallSchema, {
+        id: "tc-2",
+        name: "write",
+        status: ToolCallStatus.TOOL_CALL_RUNNING,
+      }),
+    ],
+  });
+  status.messages.push(msg);
+
+  const msg2 = create(AgentMessageSchema, {
+    type: MessageType.MESSAGE_AI,
+    content: "turn 2",
+    toolCalls: [
+      create(ToolCallSchema, {
+        id: "tc-3",
+        name: "search",
+        status: ToolCallStatus.TOOL_CALL_WAITING_APPROVAL,
+      }),
+    ],
+  });
+  status.messages.push(msg2);
+
+  return new ExecutionState(status);
+}
+
+describe("ExecutionState", () => {
+  describe("rebuildToolCallIndex", () => {
+    it("indexes all tool calls from proto messages", () => {
+      const state = makeStateWithMessages();
+      state.rebuildToolCallIndex();
+
+      expect(state.toolCalls.size).toBe(3);
+      expect(state.toolCalls.get("tc-1")!.name).toBe("read");
+      expect(state.toolCalls.get("tc-2")!.name).toBe("write");
+      expect(state.toolCalls.get("tc-3")!.name).toBe("search");
+    });
+
+    it("clears previous index before rebuilding", () => {
+      const state = makeStateWithMessages();
+      state.toolCalls.set("stale-id", create(ToolCallSchema, { id: "stale-id", name: "stale" }));
+
+      state.rebuildToolCallIndex();
+
+      expect(state.toolCalls.has("stale-id")).toBe(false);
+      expect(state.toolCalls.size).toBe(3);
+    });
+
+    it("skips tool calls without id", () => {
+      const status = create(AgentExecutionStatusSchema, {});
+      const msg = create(AgentMessageSchema, {
+        type: MessageType.MESSAGE_AI,
+        content: "test",
+        toolCalls: [
+          create(ToolCallSchema, { id: "", name: "no-id" }),
+          create(ToolCallSchema, { id: "has-id", name: "valid" }),
+        ],
+      });
+      status.messages.push(msg);
+
+      const state = new ExecutionState(status);
+      state.rebuildToolCallIndex();
+
+      expect(state.toolCalls.size).toBe(1);
+      expect(state.toolCalls.has("has-id")).toBe(true);
+    });
+
+    it("handles empty messages array", () => {
+      const state = new ExecutionState(create(AgentExecutionStatusSchema, {}));
+      state.rebuildToolCallIndex();
+      expect(state.toolCalls.size).toBe(0);
+    });
+
+    it("maintains reference identity with proto objects", () => {
+      const state = makeStateWithMessages();
+      state.rebuildToolCallIndex();
+
+      const tc = state.toolCalls.get("tc-1")!;
+      tc.status = ToolCallStatus.TOOL_CALL_FAILED;
+
+      expect(state.proto.messages[0].toolCalls[0].status).toBe(
+        ToolCallStatus.TOOL_CALL_FAILED,
+      );
+    });
+  });
+
+  describe("resetEphemeralState", () => {
+    it("clears all runtime maps", () => {
+      const state = makeStateWithMessages();
+      state.messagesByRun.set("run-1", state.proto.messages[0]);
+      state.currentAiMessage.set("", state.proto.messages[0]);
+      state.lastLlmRunId.set("", "run-1");
+      state.toolStartTimes.set("tc-1", 12345);
+
+      state.resetEphemeralState();
+
+      expect(state.messagesByRun.size).toBe(0);
+      expect(state.currentAiMessage.size).toBe(0);
+      expect(state.lastLlmRunId.size).toBe(0);
+      expect(state.toolStartTimes.size).toBe(0);
+    });
+
+    it("does not clear proto or toolCalls index", () => {
+      const state = makeStateWithMessages();
+      state.rebuildToolCallIndex();
+      state.messagesByRun.set("run-1", state.proto.messages[0]);
+
+      state.resetEphemeralState();
+
+      expect(state.proto.messages).toHaveLength(2);
+      expect(state.toolCalls.size).toBe(3);
+    });
+  });
+
+  describe("proto reference", () => {
+    it("exposes the original proto object", () => {
+      const status = create(AgentExecutionStatusSchema, {});
+      const state = new ExecutionState(status);
+      expect(state.proto).toBe(status);
+    });
+  });
+});