@stigmer/runner 3.0.9-dev.20260615153829 → 3.1.0

package/src/shared/__tests__/model-client.test.ts

@@ -0,0 +1,162 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+
+// Capture constructor args without pulling in the real SDKs. vi.hoisted lets the
+// hoisted vi.mock factories reference these spies safely.
+const { mockAnthropicCtor, mockOpenAICtor } = vi.hoisted(() => ({
+  mockAnthropicCtor: vi.fn(),
+  mockOpenAICtor: vi.fn(),
+}));
+
+vi.mock("@langchain/anthropic", () => ({
+  ChatAnthropic: vi.fn((args: unknown) => {
+    mockAnthropicCtor(args);
+    return { provider: "anthropic", args };
+  }),
+}));
+
+vi.mock("@langchain/openai", () => ({
+  ChatOpenAI: vi.fn((args: unknown) => {
+    mockOpenAICtor(args);
+    return { provider: "openai", args };
+  }),
+}));
+
+import { buildChatModel } from "../model-client.js";
+import { _resetRegistryCache } from "../model-registry.js";
+
+interface MockModel {
+  id: string;
+  apiModelId?: string;
+  provider: string;
+  costTier?: string;
+  harness?: string;
+}
+
+function mockRegistryResponse(models: MockModel[]) {
+  return vi.spyOn(globalThis, "fetch").mockResolvedValueOnce(
+    new Response(JSON.stringify({ models }), {
+      status: 200,
+      headers: { "Content-Type": "application/json" },
+    }),
+  );
+}
+
+function lastAnthropicArgs(): Record<string, unknown> {
+  return mockAnthropicCtor.mock.calls.at(-1)?.[0] as Record<string, unknown>;
+}
+
+describe("buildChatModel", () => {
+  const savedEnv = { ...process.env };
+
+  beforeEach(() => {
+    _resetRegistryCache();
+    vi.clearAllMocks();
+    delete process.env.ANTHROPIC_API_KEY;
+    delete process.env.OPENAI_API_KEY;
+  });
+
+  afterEach(() => {
+    _resetRegistryCache();
+    vi.restoreAllMocks();
+    process.env = { ...savedEnv };
+  });
+
+  it("resolves a registry id to the provider apiModelId before construction", async () => {
+    mockRegistryResponse([
+      { id: "claude-haiku-4.5", apiModelId: "claude-haiku-4-5-20251001", provider: "anthropic" },
+    ]);
+
+    const { provider, apiModelId } = await buildChatModel({ modelName: "claude-haiku-4.5" });
+
+    expect(provider).toBe("anthropic");
+    expect(apiModelId).toBe("claude-haiku-4-5-20251001");
+    expect(lastAnthropicArgs()).toMatchObject({ model: "claude-haiku-4-5-20251001" });
+  });
+
+  it("infers the OpenAI provider and routes to ChatOpenAI", async () => {
+    mockRegistryResponse([
+      { id: "gpt-4.1", apiModelId: "gpt-4.1", provider: "openai" },
+    ]);
+
+    const { provider } = await buildChatModel({ modelName: "gpt-4.1" });
+
+    expect(provider).toBe("openai");
+    expect(mockOpenAICtor).toHaveBeenCalledTimes(1);
+    expect(mockAnthropicCtor).not.toHaveBeenCalled();
+  });
+
+  it("wires the Anthropic proxy base URL, headers, and token in proxy mode", async () => {
+    mockRegistryResponse([
+      { id: "claude-haiku-4.5", apiModelId: "claude-haiku-4-5-20251001", provider: "anthropic" },
+    ]);
+
+    await buildChatModel({
+      modelName: "claude-haiku-4.5",
+      proxyEndpoint: "https://api.stigmer.ai",
+      stigmerToken: "tok-123",
+      headerScope: { executionId: "ex-1" },
+    });
+
+    expect(lastAnthropicArgs()).toMatchObject({
+      apiKey: "tok-123",
+      clientOptions: {
+        baseURL: "https://api.stigmer.ai/v1/proxy/llm/anthropic",
+        defaultHeaders: {
+          Authorization: "Bearer tok-123",
+          "X-Stigmer-Execution-Id": "ex-1",
+        },
+      },
+    });
+  });
+
+  it("wires the OpenAI proxy path under `configuration` (not `clientOptions`)", async () => {
+    mockRegistryResponse([
+      { id: "gpt-4.1", apiModelId: "gpt-4.1", provider: "openai" },
+    ]);
+
+    await buildChatModel({
+      modelName: "gpt-4.1",
+      proxyEndpoint: "https://api.stigmer.ai",
+      stigmerToken: "tok",
+    });
+
+    const args = mockOpenAICtor.mock.calls.at(-1)?.[0] as Record<string, unknown>;
+    expect(args).toMatchObject({
+      configuration: { baseURL: "https://api.stigmer.ai/v1/proxy/llm/openai/v1" },
+    });
+  });
+
+  it("uses the provider env var key in direct mode (no proxy)", async () => {
+    process.env.ANTHROPIC_API_KEY = "sk-direct";
+    mockRegistryResponse([
+      { id: "claude-haiku-4.5", apiModelId: "claude-haiku-4-5-20251001", provider: "anthropic" },
+    ]);
+
+    await buildChatModel({ modelName: "claude-haiku-4.5" });
+
+    const args = lastAnthropicArgs();
+    expect(args.apiKey).toBe("sk-direct");
+    expect(args).not.toHaveProperty("clientOptions");
+  });
+
+  it("omits maxTokens unless explicitly provided", async () => {
+    mockRegistryResponse([
+      { id: "claude-haiku-4.5", apiModelId: "claude-haiku-4-5-20251001", provider: "anthropic" },
+    ]);
+
+    await buildChatModel({ modelName: "claude-haiku-4.5" });
+    expect(lastAnthropicArgs()).not.toHaveProperty("maxTokens");
+
+    await buildChatModel({ modelName: "claude-haiku-4.5", maxTokens: 4096 });
+    expect(lastAnthropicArgs()).toMatchObject({ maxTokens: 4096 });
+  });
+
+  it("passes the model id through unchanged when the registry is unavailable", async () => {
+    vi.spyOn(globalThis, "fetch").mockRejectedValueOnce(new Error("network down"));
+
+    const { provider, apiModelId } = await buildChatModel({ modelName: "claude-haiku-4.5" });
+
+    expect(provider).toBe("anthropic");
+    expect(apiModelId).toBe("claude-haiku-4.5");
+  });
+});

package/src/shared/__tests__/plan-artifact.test.ts

@@ -7,6 +7,7 @@ import {
   MessageType,
 } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
 import type { ArtifactStorage } from "../artifact-storage.js";
+import { makeInMemoryArtifactStorage } from "../../__test-utils__/fake-artifact-storage.js";
 import {
   extractFinalPlanText,
   publishPlanArtifact,
@@ -14,22 +15,16 @@ import {
   PLAN_ARTIFACT_SANDBOX_PATH,
 } from "../plan-artifact.js";
 
-/** Records uploads and returns deterministic download URLs. */
+/** Records uploads and returns deterministic download URLs (canonical double + shim). */
 function fakeStorage(): ArtifactStorage & { uploads: { key: string; content: Buffer; contentType?: string }[] } {
+  const { storage, blobs } = makeInMemoryArtifactStorage({ urlBase: "https://example.test/download/" });
   const uploads: { key: string; content: Buffer; contentType?: string }[] = [];
-  return {
-    uploads,
-    async upload(key, content, contentType) {
-      uploads.push({ key, content, contentType });
-      return key;
-    },
-    async getDownloadUrl(key) {
-      return `https://example.test/download/${key}`;
-    },
-    async exists() {
-      return true;
-    },
-  };
+  storage.upload.mockImplementation(async (key: string, content: Buffer, contentType?: string) => {
+    uploads.push({ key, content, contentType });
+    blobs.set(key, Buffer.from(content));
+    return key;
+  });
+  return Object.assign(storage, { uploads });
 }
 
 function statusWith(...messages: { type: MessageType; content: string }[]) {
@@ -86,7 +81,6 @@ describe("publishPlanArtifact", () => {
     expect(artifact.sandboxPath).toBe(PLAN_ARTIFACT_SANDBOX_PATH);
     expect(artifact.kind).toBe(ExecutionArtifactKind.FILE);
     expect(artifact.storageKey).toBe("artifacts/aex_123/plan.md");
-    expect(artifact.downloadUrl).toBe("https://example.test/download/artifacts/aex_123/plan.md");
     expect(artifact.sizeBytes).toBeGreaterThan(0n);
     expect(artifact.contentHash).toHaveLength(64);
   });
@@ -122,17 +116,8 @@ describe("publishPlanArtifact", () => {
 
   it("never throws when the upload fails (publish is non-fatal)", async () => {
     const status = create(AgentExecutionStatusSchema, {});
-    const failing: ArtifactStorage = {
-      async upload() {
-        throw new Error("network down");
-      },
-      async getDownloadUrl() {
-        return "";
-      },
-      async exists() {
-        return false;
-      },
-    };
+    const { storage: failing } = makeInMemoryArtifactStorage();
+    failing.upload.mockImplementation(async () => { throw new Error("network down"); });
 
     await expect(
       publishPlanArtifact({ status, executionId: "aex_fail", planText: "plan", artifactStorage: failing }),

package/src/shared/__tests__/policy-source-corpus.test.ts

@@ -0,0 +1,58 @@
+/**
+ * Cross-edition authorization-provenance parity.
+ *
+ * Loads the shared corpus (apis/testdata/hitl/policy-source/vectors.json) and
+ * asserts the runner's {@link toProtoPolicySource} maps each PolicySource onto
+ * the proto enum number the backends consume. The Go (policy_source_corpus_test.go)
+ * and Java (PolicySourceFixtureTest) editions load the same file and assert the
+ * generated enum resolves the same name to the same number, so a drift in the
+ * runner mapping or a renumbering of the enum in any edition fails one of the
+ * three suites — the guarantee that a persisted approval_policy_source means the
+ * same thing everywhere.
+ */
+
+import { describe, it, expect } from "vitest";
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { ApprovalPolicySource } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+import { toProtoPolicySource, type PolicySource } from "../approval-policy.js";
+
+interface PolicySourceVector {
+  name: string;
+  policySource: PolicySource | null;
+  name_proto: string;
+  number: number;
+}
+
+const vectorsPath = fileURLToPath(
+  new URL(
+    "../../../../../../apis/testdata/hitl/policy-source/vectors.json",
+    import.meta.url,
+  ),
+);
+const corpus = JSON.parse(readFileSync(vectorsPath, "utf-8")) as {
+  vectors: PolicySourceVector[];
+};
+
+describe("policy-source mapping vector corpus", () => {
+  it("loads the full enum corpus", () => {
+    // One vector per ApprovalPolicySource value (incl. UNSPECIFIED).
+    const enumValueCount = Object.values(ApprovalPolicySource).filter(
+      (v) => typeof v === "number",
+    ).length;
+    expect(corpus.vectors.length).toBe(enumValueCount);
+  });
+
+  for (const v of corpus.vectors) {
+    it(`vector: ${v.name}`, () => {
+      // The runner maps undefined (no governing layer) -> UNSPECIFIED; the corpus
+      // encodes that case as policySource: null.
+      const source = v.policySource ?? undefined;
+      expect(toProtoPolicySource(source)).toBe(v.number);
+      // The generated enum's reverse lookup must name the same value, with the
+      // proto prefix the backends use stripped to the runner's short member name.
+      const shortName = v.name_proto.replace("APPROVAL_POLICY_SOURCE_", "");
+      expect(ApprovalPolicySource[v.number]).toBe(shortName);
+    });
+  }
+});