@stigmer/runner 3.0.1

package/src/activities/__tests__/call-agent.test.ts

@@ -0,0 +1,263 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { ApiResourceKind } from "@stigmer/protos/ai/stigmer/commons/apiresource/apiresourcekind/api_resource_kind_pb";
+
+let mockGetAgentByReference: ReturnType<typeof vi.fn>;
+let mockCreateSession: ReturnType<typeof vi.fn>;
+let mockCreateAgentExecution: ReturnType<typeof vi.fn>;
+
+vi.mock("@temporalio/activity", () => ({
+  Context: {
+    current: () => ({
+      info: {
+        taskToken: new Uint8Array([1, 2, 3]),
+      },
+    }),
+  },
+  CompleteAsyncError: class CompleteAsyncError extends Error {
+    constructor() {
+      super("CompleteAsyncError");
+      this.name = "CompleteAsyncError";
+    }
+  },
+}));
+
+vi.mock("../../client/stigmer-client.js", () => ({
+  StigmerClient: vi.fn().mockImplementation(() => ({
+    getAgentByReference: (...args: unknown[]) => mockGetAgentByReference(...args),
+    applySession: (...args: unknown[]) => mockCreateSession(...args),
+    createAgentExecution: (...args: unknown[]) => mockCreateAgentExecution(...args),
+  })),
+}));
+
+vi.mock("../../config.js", () => ({
+  loadConfig: () => ({
+    stigmerBackendEndpoint: "http://localhost:7234",
+    stigmerToken: "test-token",
+  }),
+}));
+
+vi.mock("../../shared/heartbeat.js", () => ({
+  startHeartbeat: () => ({ stop: vi.fn() }),
+}));
+
+import { callAgentAction } from "../call-agent.js";
+
+describe("callAgentAction", () => {
+  beforeEach(() => {
+    mockGetAgentByReference = vi.fn().mockResolvedValue({
+      metadata: { id: "agt_test123" },
+      status: { defaultInstanceId: "ain_default456" },
+    });
+    mockCreateSession = vi.fn().mockResolvedValue({
+      metadata: { id: "ses_test789" },
+    });
+    mockCreateAgentExecution = vi.fn().mockResolvedValue({
+      metadata: { id: "aex_test000" },
+    });
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe("ApiResourceReference construction", () => {
+    it("sets kind to ApiResourceKind.agent for org-relative slug", async () => {
+      await expect(
+        callAgentAction(
+          { agent: "notification-analyst", message: "Analyze data" },
+          { __stigmer_org_id: "tt-demo" },
+          "wfl_parent123",
+        ),
+      ).rejects.toThrow("CompleteAsyncError");
+
+      expect(mockGetAgentByReference).toHaveBeenCalledOnce();
+      const ref = mockGetAgentByReference.mock.calls[0][0];
+      expect(ref.kind).toBe(ApiResourceKind.agent);
+      expect(ref.org).toBe("tt-demo");
+      expect(ref.slug).toBe("notification-analyst");
+    });
+
+    it("sets kind to ApiResourceKind.agent for org-prefixed slug", async () => {
+      await expect(
+        callAgentAction(
+          { agent: "acme/my-agent", message: "Do something" },
+          { __stigmer_org_id: "default-org" },
+          "wfl_parent456",
+        ),
+      ).rejects.toThrow("CompleteAsyncError");
+
+      expect(mockGetAgentByReference).toHaveBeenCalledOnce();
+      const ref = mockGetAgentByReference.mock.calls[0][0];
+      expect(ref.kind).toBe(ApiResourceKind.agent);
+      expect(ref.org).toBe("acme");
+      expect(ref.slug).toBe("my-agent");
+    });
+
+    it("uses config.org over __stigmer_org_id when both are present", async () => {
+      await expect(
+        callAgentAction(
+          { agent: "my-agent", message: "Hello", org: "explicit-org" },
+          { __stigmer_org_id: "fallback-org" },
+          "wfl_parent789",
+        ),
+      ).rejects.toThrow("CompleteAsyncError");
+
+      const ref = mockGetAgentByReference.mock.calls[0][0];
+      expect(ref.org).toBe("explicit-org");
+      expect(ref.slug).toBe("my-agent");
+      expect(ref.kind).toBe(ApiResourceKind.agent);
+    });
+  });
+
+  describe("org resolution", () => {
+    it("throws when no org is available", async () => {
+      await expect(
+        callAgentAction(
+          { agent: "my-agent", message: "Hello" },
+          {},
+          "wfl_parent",
+        ),
+      ).rejects.toThrow("call:agent requires an organization context");
+    });
+
+    it("falls back to __stigmer_org_id from runtime env", async () => {
+      await expect(
+        callAgentAction(
+          { agent: "my-agent", message: "Hello" },
+          { __stigmer_org_id: "env-org" },
+          "wfl_parent",
+        ),
+      ).rejects.toThrow("CompleteAsyncError");
+
+      const ref = mockGetAgentByReference.mock.calls[0][0];
+      expect(ref.org).toBe("env-org");
+    });
+  });
+
+  describe("agent resolution failure", () => {
+    it("throws when resolved agent has no metadata.id", async () => {
+      mockGetAgentByReference.mockResolvedValue({
+        metadata: {},
+        status: { defaultInstanceId: "ain_123" },
+      });
+
+      await expect(
+        callAgentAction(
+          { agent: "ghost-agent", message: "Hello" },
+          { __stigmer_org_id: "test-org" },
+          "wfl_parent",
+        ),
+      ).rejects.toThrow("resolved but has no metadata.id");
+    });
+  });
+
+  describe("post-resolution validation", () => {
+    it("throws when agent field resolves to empty string", async () => {
+      await expect(
+        callAgentAction(
+          { agent: "", message: "Hello" },
+          { __stigmer_org_id: "test-org" },
+          "wfl_parent",
+        ),
+      ).rejects.toThrow("'agent' resolved to empty");
+    });
+
+    it("throws when message field resolves to empty string", async () => {
+      await expect(
+        callAgentAction(
+          { agent: "my-agent", message: "" },
+          { __stigmer_org_id: "test-org" },
+          "wfl_parent",
+        ),
+      ).rejects.toThrow("'message' resolved to empty");
+    });
+  });
+
+  describe("downstream calls", () => {
+    it("creates session with correct envelope, metadata, and spec", async () => {
+      await expect(
+        callAgentAction(
+          { agent: "my-agent", message: "Hello", harness: "CURSOR" },
+          { __stigmer_org_id: "test-org" },
+          "wfl_parent",
+        ),
+      ).rejects.toThrow("CompleteAsyncError");
+
+      expect(mockCreateSession).toHaveBeenCalledOnce();
+      const session = mockCreateSession.mock.calls[0][0];
+      expect(session.apiVersion).toBe("agentic.stigmer.ai/v1");
+      expect(session.kind).toBe("Session");
+      expect(session.metadata.org).toBe("test-org");
+      expect(session.metadata.name).toMatch(/^wf-my-agent-\d+$/);
+      expect(session.spec.agentInstanceId).toBe("ain_default456");
+    });
+
+    it("creates session with 'Auto-created session' sentinel subject", async () => {
+      await expect(
+        callAgentAction(
+          { agent: "my-agent", message: "Hello" },
+          { __stigmer_org_id: "test-org" },
+          "wfl_parent",
+        ),
+      ).rejects.toThrow("CompleteAsyncError");
+
+      expect(mockCreateSession).toHaveBeenCalledOnce();
+      const session = mockCreateSession.mock.calls[0][0];
+      expect(session.spec.subject).toBe("Auto-created session");
+    });
+
+    it("creates agent execution with correct envelope and spec", async () => {
+      await expect(
+        callAgentAction(
+          { agent: "my-agent", message: "Review this" },
+          { __stigmer_org_id: "test-org" },
+          "wfl_parent_id",
+        ),
+      ).rejects.toThrow("CompleteAsyncError");
+
+      expect(mockCreateAgentExecution).toHaveBeenCalledOnce();
+      const execution = mockCreateAgentExecution.mock.calls[0][0];
+      expect(execution.apiVersion).toBe("agentic.stigmer.ai/v1");
+      expect(execution.kind).toBe("AgentExecution");
+      expect(execution.metadata.org).toBe("test-org");
+      expect(execution.metadata.name).toMatch(/^aex-wf-my-agent-\d+$/);
+      expect(execution.spec.agentId).toBe("agt_test123");
+      expect(execution.spec.sessionId).toBe("ses_test789");
+      expect(execution.spec.message).toBe("Review this");
+      expect(execution.spec.parentWorkflowId).toBe("wfl_parent_id");
+      expect(execution.spec.callbackToken).toEqual(new Uint8Array([1, 2, 3]));
+    });
+
+    it("propagates sandbox queue affinity from parent", async () => {
+      await expect(
+        callAgentAction(
+          { agent: "my-agent", message: "Hello" },
+          {
+            __stigmer_org_id: "test-org",
+            __stigmer_activity_task_queue: "wfexec:wex_abc123",
+          },
+          "wfl_parent",
+        ),
+      ).rejects.toThrow("CompleteAsyncError");
+
+      const execution = mockCreateAgentExecution.mock.calls[0][0];
+      expect(execution.spec.activityTaskQueue).toBe("wfexec:wex_abc123");
+    });
+
+    it("does not propagate non-wfexec queue", async () => {
+      await expect(
+        callAgentAction(
+          { agent: "my-agent", message: "Hello" },
+          {
+            __stigmer_org_id: "test-org",
+            __stigmer_activity_task_queue: "stigmer_runner",
+          },
+          "wfl_parent",
+        ),
+      ).rejects.toThrow("CompleteAsyncError");
+
+      const execution = mockCreateAgentExecution.mock.calls[0][0];
+      expect(execution.spec.activityTaskQueue).toBe("");
+    });
+  });
+});

package/src/activities/__tests__/call-function.test.ts

@@ -0,0 +1,47 @@
+import { describe, it, expect } from "vitest";
+import { createCallFunctionActivities } from "../call-function.js";
+
+describe("createCallFunctionActivities", () => {
+  it("creates activities object with CallFunction method", () => {
+    const activities = createCallFunctionActivities();
+    expect(typeof activities.CallFunction).toBe("function");
+  });
+
+  it("throws non-retryable error for unknown call type", async () => {
+    const activities = createCallFunctionActivities();
+
+    try {
+      await activities.CallFunction("unknown_function", {}, {}, "exec-1");
+      expect.fail("Should have thrown");
+    } catch (err: any) {
+      expect(err.message).toContain("Unknown custom call function");
+      expect(err.message).toContain("unknown_function");
+    }
+  });
+
+  it("throws non-retryable error for call:agent (not yet implemented)", async () => {
+    const activities = createCallFunctionActivities();
+
+    try {
+      await activities.CallFunction("agent", { agent: "code-reviewer" }, {}, "exec-1");
+      expect.fail("Should have thrown");
+    } catch (err: any) {
+      expect(err.message).toContain("not yet implemented");
+    }
+  });
+
+  it("resolves runtime placeholders in config before dispatching", async () => {
+    const activities = createCallFunctionActivities();
+
+    try {
+      await activities.CallFunction(
+        "llm",
+        { model: "gpt-4o", prompt: "hi" },
+        {},
+        "exec-1",
+      );
+    } catch {
+      // LLM will fail without API key — we just verify it dispatches
+    }
+  });
+});

package/src/activities/__tests__/call-grpc.test.ts

@@ -0,0 +1,39 @@
+import { describe, it, expect } from "vitest";
+import { createCallGrpcActivities } from "../call-grpc.js";
+
+describe("createCallGrpcActivities", () => {
+  it("creates activities object with CallGrpc method", () => {
+    const activities = createCallGrpcActivities();
+    expect(typeof activities.CallGrpc).toBe("function");
+  });
+
+  it("rejects with non-retryable error for missing proto file", async () => {
+    const activities = createCallGrpcActivities();
+
+    await expect(
+      activities.CallGrpc(
+        {
+          proto: "/nonexistent/path/to/service.proto",
+          service: { name: "test.Service", host: "localhost", port: 50051 },
+          method: "Call",
+        },
+        {},
+      ),
+    ).rejects.toThrow("proto");
+  });
+
+  it("resolves runtime placeholders in service host", async () => {
+    const activities = createCallGrpcActivities();
+
+    await expect(
+      activities.CallGrpc(
+        {
+          proto: "/nonexistent/service.proto",
+          service: { name: "test.Service", host: "${.secrets.HOST}" },
+          method: "Call",
+        },
+        { HOST: "resolved-host" },
+      ),
+    ).rejects.toThrow("proto");
+  });
+});

package/src/activities/__tests__/call-http.test.ts

@@ -0,0 +1,288 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { callHttpAction, createCallHttpActivities } from "../call-http.js";
+
+const originalFetch = globalThis.fetch;
+
+describe("callHttpAction", () => {
+  let mockFetch: ReturnType<typeof vi.fn>;
+
+  beforeEach(() => {
+    mockFetch = vi.fn();
+    globalThis.fetch = mockFetch;
+  });
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch;
+  });
+
+  function jsonResponse(body: unknown, status = 200, headers: Record<string, string> = {}) {
+    const headersObj = new Headers({ "content-type": "application/json", ...headers });
+    return new Response(JSON.stringify(body), { status, headers: headersObj });
+  }
+
+  function textResponse(body: string, status = 200) {
+    return new Response(body, { status, headers: { "content-type": "text/plain" } });
+  }
+
+  describe("successful requests", () => {
+    it("performs a GET and returns parsed JSON content", async () => {
+      mockFetch.mockResolvedValue(jsonResponse({ id: 1, title: "Hello" }));
+
+      const result = await callHttpAction(
+        { method: "GET", endpoint: { uri: "https://api.example.com/posts/1" } },
+        {},
+      );
+
+      expect(result).toEqual({ id: 1, title: "Hello" });
+      expect(mockFetch).toHaveBeenCalledWith(
+        "https://api.example.com/posts/1",
+        expect.objectContaining({ method: "GET" }),
+      );
+    });
+
+    it("performs a POST with JSON body", async () => {
+      mockFetch.mockResolvedValue(jsonResponse({ id: 101 }, 201));
+
+      const result = await callHttpAction(
+        {
+          method: "POST",
+          endpoint: "https://api.example.com/posts",
+          body: { title: "New Post", userId: 1 },
+        },
+        {},
+      );
+
+      expect(result).toEqual({ id: 101 });
+      const callArgs = mockFetch.mock.calls[0];
+      expect(callArgs[1].method).toBe("POST");
+      expect(callArgs[1].body).toBe(JSON.stringify({ title: "New Post", userId: 1 }));
+      expect(callArgs[1].headers["Content-Type"]).toBe("application/json");
+    });
+
+    it("returns plain text when response is not JSON", async () => {
+      mockFetch.mockResolvedValue(textResponse("OK"));
+
+      const result = await callHttpAction(
+        { method: "GET", endpoint: "https://example.com/health" },
+        {},
+      );
+
+      expect(result).toBe("OK");
+    });
+
+    it("appends query parameters to the URI", async () => {
+      mockFetch.mockResolvedValue(jsonResponse([]));
+
+      await callHttpAction(
+        {
+          method: "GET",
+          endpoint: "https://api.example.com/search",
+          query: { q: "test", page: "1" },
+        },
+        {},
+      );
+
+      expect(mockFetch).toHaveBeenCalledWith(
+        "https://api.example.com/search?q=test&page=1",
+        expect.anything(),
+      );
+    });
+
+    it("passes custom headers", async () => {
+      mockFetch.mockResolvedValue(jsonResponse({}));
+
+      await callHttpAction(
+        {
+          method: "GET",
+          endpoint: "https://api.example.com/data",
+          headers: { Authorization: "Bearer tok123" },
+        },
+        {},
+      );
+
+      const callArgs = mockFetch.mock.calls[0];
+      expect(callArgs[1].headers.Authorization).toBe("Bearer tok123");
+    });
+
+    it("uppercases the HTTP method", async () => {
+      mockFetch.mockResolvedValue(jsonResponse({}));
+
+      await callHttpAction(
+        { method: "post", endpoint: "https://example.com" },
+        {},
+      );
+
+      expect(mockFetch.mock.calls[0][1].method).toBe("POST");
+    });
+  });
+
+  describe("output modes", () => {
+    it("returns full response object with output=response", async () => {
+      mockFetch.mockResolvedValue(jsonResponse({ data: "yes" }, 200, { "x-custom": "val" }));
+
+      const result = await callHttpAction(
+        {
+          method: "GET",
+          endpoint: "https://example.com",
+          output: "response",
+        },
+        {},
+      ) as Record<string, unknown>;
+
+      expect(result).toHaveProperty("statusCode", 200);
+      expect(result).toHaveProperty("content", { data: "yes" });
+      expect(result).toHaveProperty("request");
+      expect(result).toHaveProperty("headers");
+    });
+
+    it("returns base64 content with output=raw", async () => {
+      const body = "Hello, World!";
+      mockFetch.mockResolvedValue(new Response(body, { status: 200 }));
+
+      const result = await callHttpAction(
+        {
+          method: "GET",
+          endpoint: "https://example.com/file",
+          output: "raw",
+        },
+        {},
+      );
+
+      expect(result).toBe(Buffer.from(body).toString("base64"));
+    });
+  });
+
+  describe("error classification", () => {
+    it("throws non-retryable ApplicationFailure for 4xx", async () => {
+      mockFetch.mockResolvedValue(new Response("Not Found", { status: 404 }));
+
+      await expect(
+        callHttpAction(
+          { method: "GET", endpoint: "https://example.com/missing" },
+          {},
+        ),
+      ).rejects.toThrow("404");
+    });
+
+    it("throws non-retryable ApplicationFailure for 400", async () => {
+      mockFetch.mockResolvedValue(new Response("Bad Request", { status: 400 }));
+
+      try {
+        await callHttpAction(
+          { method: "POST", endpoint: "https://example.com/bad" },
+          {},
+        );
+        expect.fail("Should have thrown");
+      } catch (err: any) {
+        expect(err.message).toContain("400");
+        expect(err.type).toBe("HTTP_CLIENT_ERROR");
+      }
+    });
+
+    it("throws retryable error for 5xx", async () => {
+      mockFetch.mockResolvedValue(new Response("Internal Error", { status: 500 }));
+
+      await expect(
+        callHttpAction(
+          { method: "GET", endpoint: "https://example.com/error" },
+          {},
+        ),
+      ).rejects.toThrow("500");
+    });
+
+    it("throws non-retryable for 3xx redirects", async () => {
+      mockFetch.mockResolvedValue(new Response("", { status: 301, headers: { Location: "/new" } }));
+
+      try {
+        await callHttpAction(
+          { method: "GET", endpoint: "https://example.com/old" },
+          {},
+        );
+        expect.fail("Should have thrown");
+      } catch (err: any) {
+        expect(err.message).toContain("redirect");
+        expect(err.message).toContain("301");
+      }
+    });
+
+    it("throws retryable error for network failures", async () => {
+      mockFetch.mockRejectedValue(new Error("ECONNREFUSED"));
+
+      await expect(
+        callHttpAction(
+          { method: "GET", endpoint: "https://example.com" },
+          {},
+        ),
+      ).rejects.toThrow("ECONNREFUSED");
+    });
+  });
+
+  describe("runtime placeholder resolution", () => {
+    it("resolves ${.secrets.KEY} in headers", async () => {
+      mockFetch.mockResolvedValue(jsonResponse({ ok: true }));
+
+      await callHttpAction(
+        {
+          method: "GET",
+          endpoint: "https://example.com",
+          headers: { Authorization: "Bearer ${.secrets.API_TOKEN}" },
+        },
+        { API_TOKEN: "my-secret-token" },
+      );
+
+      const callArgs = mockFetch.mock.calls[0];
+      expect(callArgs[1].headers.Authorization).toBe("Bearer my-secret-token");
+    });
+
+    it("resolves ${.secrets.KEY} in endpoint URI", async () => {
+      mockFetch.mockResolvedValue(jsonResponse({}));
+
+      await callHttpAction(
+        {
+          method: "GET",
+          endpoint: { uri: "https://${.secrets.HOST}/api" },
+        },
+        { HOST: "secure.example.com" },
+      );
+
+      expect(mockFetch.mock.calls[0][0]).toBe("https://secure.example.com/api");
+    });
+  });
+
+  describe("edge cases", () => {
+    it("handles string endpoint shorthand", async () => {
+      mockFetch.mockResolvedValue(jsonResponse({}));
+
+      await callHttpAction(
+        { method: "GET", endpoint: "https://example.com/simple" },
+        {},
+      );
+
+      expect(mockFetch.mock.calls[0][0]).toBe("https://example.com/simple");
+    });
+
+    it("sends string body without JSON content-type", async () => {
+      mockFetch.mockResolvedValue(jsonResponse({}));
+
+      await callHttpAction(
+        {
+          method: "POST",
+          endpoint: "https://example.com",
+          body: "plain text body" as any,
+        },
+        {},
+      );
+
+      const callArgs = mockFetch.mock.calls[0];
+      expect(callArgs[1].body).toBe("plain text body");
+      expect(callArgs[1].headers["Content-Type"]).toBeUndefined();
+    });
+  });
+
+  describe("factory", () => {
+    it("creates activities object with CallHttp method", () => {
+      const activities = createCallHttpActivities();
+      expect(typeof activities.CallHttp).toBe("function");
+    });
+  });
+});