@stigmer/runner 3.0.1

package/src/shared/__tests__/grpc-retry.test.ts

@@ -0,0 +1,172 @@
+import { describe, it, expect, vi } from "vitest";
+import { ConnectError, Code } from "@connectrpc/connect";
+import { create } from "@bufbuild/protobuf";
+import { AgentExecutionStatusSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/api_pb";
+import { ExecutionControlSignal } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+import {
+  persistWithRetry,
+  isRetryableError,
+  isTerminalError,
+} from "../grpc-retry.js";
+import type { StigmerClient } from "../../client/stigmer-client.js";
+
+function makeStatus() {
+  return create(AgentExecutionStatusSchema, {});
+}
+
+function mockClient(
+  updateStatusImpl: (...args: unknown[]) => Promise<{ signal: ExecutionControlSignal }>,
+): StigmerClient {
+  return { updateStatus: updateStatusImpl } as unknown as StigmerClient;
+}
+
+const noDelay = async () => {};
+
+describe("isRetryableError", () => {
+  it("returns true for UNAVAILABLE", () => {
+    expect(isRetryableError(new ConnectError("down", Code.Unavailable))).toBe(true);
+  });
+
+  it("returns true for DEADLINE_EXCEEDED", () => {
+    expect(isRetryableError(new ConnectError("slow", Code.DeadlineExceeded))).toBe(true);
+  });
+
+  it("returns false for NOT_FOUND", () => {
+    expect(isRetryableError(new ConnectError("gone", Code.NotFound))).toBe(false);
+  });
+
+  it("returns false for non-ConnectError", () => {
+    expect(isRetryableError(new Error("random"))).toBe(false);
+  });
+});
+
+describe("isTerminalError", () => {
+  it("returns true for INVALID_ARGUMENT", () => {
+    expect(isTerminalError(new ConnectError("bad", Code.InvalidArgument))).toBe(true);
+  });
+
+  it("returns true for NOT_FOUND", () => {
+    expect(isTerminalError(new ConnectError("gone", Code.NotFound))).toBe(true);
+  });
+
+  it("returns true for PERMISSION_DENIED", () => {
+    expect(isTerminalError(new ConnectError("nope", Code.PermissionDenied))).toBe(true);
+  });
+
+  it("returns false for UNAVAILABLE", () => {
+    expect(isTerminalError(new ConnectError("down", Code.Unavailable))).toBe(false);
+  });
+});
+
+describe("persistWithRetry", () => {
+  it("returns signal on successful first attempt", async () => {
+    const client = mockClient(async () => ({
+      signal: ExecutionControlSignal.STOP,
+    }));
+
+    const signal = await persistWithRetry(client, "exec-1", makeStatus(), {
+      delayFn: noDelay,
+    });
+
+    expect(signal).toBe(ExecutionControlSignal.STOP);
+  });
+
+  it("retries on UNAVAILABLE and succeeds", async () => {
+    let attempt = 0;
+    const client = mockClient(async () => {
+      attempt++;
+      if (attempt === 1) throw new ConnectError("down", Code.Unavailable);
+      return { signal: ExecutionControlSignal.UNSPECIFIED };
+    });
+
+    const signal = await persistWithRetry(client, "exec-2", makeStatus(), {
+      delayFn: noDelay,
+    });
+
+    expect(signal).toBe(ExecutionControlSignal.UNSPECIFIED);
+    expect(attempt).toBe(2);
+  });
+
+  it("does not retry terminal errors (NOT_FOUND)", async () => {
+    let attempt = 0;
+    const client = mockClient(async () => {
+      attempt++;
+      throw new ConnectError("gone", Code.NotFound);
+    });
+
+    const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+    const signal = await persistWithRetry(client, "exec-3", makeStatus(), {
+      delayFn: noDelay,
+    });
+    errorSpy.mockRestore();
+
+    expect(signal).toBe(ExecutionControlSignal.UNSPECIFIED);
+    expect(attempt).toBe(1);
+  });
+
+  it("returns UNSPECIFIED after all retries exhausted", async () => {
+    const client = mockClient(async () => {
+      throw new ConnectError("down", Code.Unavailable);
+    });
+
+    const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+    const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+    const signal = await persistWithRetry(client, "exec-4", makeStatus(), {
+      maxRetries: 3,
+      delayFn: noDelay,
+    });
+    warnSpy.mockRestore();
+    errorSpy.mockRestore();
+
+    expect(signal).toBe(ExecutionControlSignal.UNSPECIFIED);
+  });
+
+  it("uses correct backoff delays", async () => {
+    const delays: number[] = [];
+    const client = mockClient(async () => {
+      throw new ConnectError("down", Code.Unavailable);
+    });
+
+    const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+    const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+    await persistWithRetry(client, "exec-5", makeStatus(), {
+      baseDelayMs: 100,
+      backoffFactor: 2,
+      maxRetries: 3,
+      delayFn: async (ms) => { delays.push(ms); },
+    });
+    warnSpy.mockRestore();
+    errorSpy.mockRestore();
+
+    expect(delays).toEqual([100, 200, 400]);
+  });
+
+  it("handles non-ConnectError by not retrying", async () => {
+    let attempt = 0;
+    const client = mockClient(async () => {
+      attempt++;
+      throw new Error("unexpected");
+    });
+
+    const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+    const signal = await persistWithRetry(client, "exec-6", makeStatus(), {
+      delayFn: noDelay,
+    });
+    errorSpy.mockRestore();
+
+    expect(signal).toBe(ExecutionControlSignal.UNSPECIFIED);
+    expect(attempt).toBe(1);
+  });
+
+  it("never throws regardless of error type", async () => {
+    const client = mockClient(async () => {
+      throw new ConnectError("server exploded", Code.Internal);
+    });
+
+    const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+    await expect(
+      persistWithRetry(client, "exec-7", makeStatus(), { delayFn: noDelay }),
+    ).resolves.toBe(ExecutionControlSignal.UNSPECIFIED);
+    errorSpy.mockRestore();
+  });
+});

package/src/shared/__tests__/json-schema-to-zod.test.ts

@@ -0,0 +1,227 @@
+import { describe, it, expect } from "vitest";
+import { z } from "zod";
+import { jsonSchemaToZod } from "../json-schema-to-zod.js";
+
+describe("jsonSchemaToZod", () => {
+  describe("basic type mapping", () => {
+    it("converts string type", () => {
+      const schema = { type: "string" };
+      const zod = jsonSchemaToZod(schema);
+      expect(zod.parse("hello")).toBe("hello");
+      expect(() => zod.parse(42)).toThrow();
+    });
+
+    it("converts number type", () => {
+      const zod = jsonSchemaToZod({ type: "number" });
+      expect(zod.parse(3.14)).toBe(3.14);
+    });
+
+    it("converts integer type as number", () => {
+      const zod = jsonSchemaToZod({ type: "integer" });
+      expect(zod.parse(42)).toBe(42);
+    });
+
+    it("converts boolean type", () => {
+      const zod = jsonSchemaToZod({ type: "boolean" });
+      expect(zod.parse(true)).toBe(true);
+    });
+
+    it("converts null type", () => {
+      const zod = jsonSchemaToZod({ type: "null" });
+      expect(zod.parse(null)).toBeNull();
+    });
+
+    it("converts string enum", () => {
+      const zod = jsonSchemaToZod({ type: "string", enum: ["warning", "critical"] });
+      expect(zod.parse("warning")).toBe("warning");
+      expect(() => zod.parse("info")).toThrow();
+    });
+
+    it("returns unknown for unrecognized type", () => {
+      const zod = jsonSchemaToZod({});
+      expect(zod.parse("anything")).toBe("anything");
+      expect(zod.parse(42)).toBe(42);
+    });
+  });
+
+  describe("object type", () => {
+    it("converts object with required fields", () => {
+      const schema = {
+        type: "object",
+        required: ["name", "age"],
+        properties: {
+          name: { type: "string" },
+          age: { type: "number" },
+        },
+      };
+      const zod = jsonSchemaToZod(schema);
+      const valid = { name: "Alice", age: 30 };
+      expect(zod.parse(valid)).toMatchObject(valid);
+    });
+
+    it("allows additional properties via passthrough", () => {
+      const schema = {
+        type: "object",
+        required: ["name"],
+        properties: { name: { type: "string" } },
+      };
+      const zod = jsonSchemaToZod(schema);
+      const result = zod.parse({ name: "Alice", extra: true });
+      expect(result).toMatchObject({ name: "Alice", extra: true });
+    });
+
+    it("handles empty properties", () => {
+      const zod = jsonSchemaToZod({ type: "object" });
+      expect(zod.parse({})).toEqual({});
+    });
+  });
+
+  describe("array type", () => {
+    it("converts array with item schema", () => {
+      const schema = {
+        type: "array",
+        items: { type: "string" },
+      };
+      const zod = jsonSchemaToZod(schema);
+      expect(zod.parse(["a", "b"])).toEqual(["a", "b"]);
+    });
+
+    it("converts array without item schema", () => {
+      const zod = jsonSchemaToZod({ type: "array" });
+      expect(zod.parse([1, "two", true])).toEqual([1, "two", true]);
+    });
+  });
+
+  describe("nested schemas", () => {
+    it("handles nested objects with arrays", () => {
+      const schema = {
+        type: "object",
+        required: ["cohorts"],
+        properties: {
+          cohorts: {
+            type: "array",
+            items: {
+              type: "object",
+              required: ["name", "size"],
+              properties: {
+                name: { type: "string" },
+                size: { type: "number" },
+                trend: { type: "string" },
+              },
+            },
+          },
+        },
+      };
+      const zod = jsonSchemaToZod(schema);
+      const data = {
+        cohorts: [
+          { name: "D1 New", size: 10, trend: "stable" },
+          { name: "D3 Drop", size: 3589, trend: null },
+        ],
+      };
+      expect(zod.parse(data)).toMatchObject(data);
+    });
+  });
+
+  // ─────────────────────────────────────────────────────────────────────
+  // BUG REPRODUCTION: OpenAI structured output compatibility
+  //
+  // OpenAI's structured output API requires ALL fields to be required.
+  // Optional semantics must use .nullable() (value can be null, key
+  // must be present), not .optional() (key may be absent).
+  //
+  // LangChain's withStructuredOutput rejects Zod schemas that use
+  // .optional() without .nullable() — this is the exact error from
+  // the production failure:
+  //
+  //   Zod field at `#/definitions/extract/properties/anomalies/items/
+  //   properties/metric` uses `.optional()` without `.nullable()`
+  //   which is not supported by the API.
+  //
+  // The schema below is the exact anomalies.items schema from the
+  // daily-notification-plan workflow that triggered the bug.
+  // ─────────────────────────────────────────────────────────────────────
+
+  describe("OpenAI structured output compatibility", () => {
+    const anomalyItemSchema = {
+      type: "object",
+      properties: {
+        metric: { type: "string" },
+        description: { type: "string" },
+        severity: { type: "string", enum: ["warning", "critical"] },
+      },
+    };
+
+    it("non-required fields use nullable (not optional) for OpenAI compatibility", () => {
+      const zod = jsonSchemaToZod(anomalyItemSchema);
+      const shape = (zod as z.ZodObject<z.ZodRawShape>).shape;
+
+      for (const key of ["metric", "description", "severity"]) {
+        const field = shape[key];
+        expect(
+          field instanceof z.ZodNullable,
+          `Field '${key}' should be z.ZodNullable but got ${field.constructor.name}`,
+        ).toBe(true);
+      }
+    });
+
+    it("nullable fields accept null values", () => {
+      const zod = jsonSchemaToZod(anomalyItemSchema);
+      const result = zod.parse({ metric: null, description: null, severity: null });
+      expect(result).toEqual({ metric: null, description: null, severity: null });
+    });
+
+    it("nullable fields accept their typed values", () => {
+      const zod = jsonSchemaToZod(anomalyItemSchema);
+      const data = { metric: "DAU", description: "DAU dropped", severity: "warning" };
+      expect(zod.parse(data)).toMatchObject(data);
+    });
+
+    it("full workflow schema produces nullable non-required fields at all nesting levels", () => {
+      const fullSchema = {
+        type: "object",
+        required: ["executive_summary", "cohorts", "anomalies"],
+        properties: {
+          executive_summary: { type: "string" },
+          dau: { type: "number" },
+          dau_trend_pct: { type: "number" },
+          cohorts: {
+            type: "array",
+            items: {
+              type: "object",
+              required: ["name", "size", "action_needed"],
+              properties: {
+                name: { type: "string" },
+                size: { type: "number" },
+                retention_trend: { type: "string" },
+                action_needed: { type: "boolean" },
+              },
+            },
+          },
+          anomalies: {
+            type: "array",
+            items: anomalyItemSchema,
+          },
+          data_quality_notes: { type: "string" },
+        },
+      };
+
+      const zod = jsonSchemaToZod(fullSchema);
+      const topShape = (zod as z.ZodObject<z.ZodRawShape>).shape;
+
+      // Top-level non-required fields should be nullable
+      expect(topShape.dau instanceof z.ZodNullable, "dau should be nullable").toBe(true);
+      expect(topShape.dau_trend_pct instanceof z.ZodNullable, "dau_trend_pct should be nullable").toBe(true);
+      expect(topShape.data_quality_notes instanceof z.ZodNullable, "data_quality_notes should be nullable").toBe(true);
+
+      // Top-level required fields should NOT be nullable
+      expect(topShape.executive_summary instanceof z.ZodNullable, "executive_summary should NOT be nullable").toBe(false);
+
+      // Nested: cohorts items have optional retention_trend
+      const cohortsArray = topShape.cohorts as z.ZodArray<z.ZodObject<z.ZodRawShape>>;
+      const cohortItemShape = cohortsArray.element.shape;
+      expect(cohortItemShape.retention_trend instanceof z.ZodNullable, "retention_trend should be nullable").toBe(true);
+      expect(cohortItemShape.name instanceof z.ZodNullable, "name should NOT be nullable").toBe(false);
+    });
+  });
+});

package/src/shared/__tests__/llm-proxy.test.ts

@@ -0,0 +1,179 @@
+import { describe, it, expect } from "vitest";
+import {
+  inferProvider,
+  stripProviderPrefix,
+  resolveProxyBaseUrl,
+  buildProxyHeaders,
+} from "../llm-proxy.js";
+
+describe("inferProvider", () => {
+  describe("Anthropic models", () => {
+    it.each([
+      "claude-sonnet-4-6",
+      "claude-opus-4",
+      "claude-haiku-4.5",
+      "claude-3.5-sonnet",
+      "claude-3-opus-20240229",
+      "Claude-Sonnet-4",
+    ])("infers anthropic for %s", (model) => {
+      expect(inferProvider(model)).toBe("anthropic");
+    });
+  });
+
+  describe("OpenAI models", () => {
+    it.each([
+      "gpt-4.1",
+      "gpt-4o",
+      "gpt-4o-mini",
+      "gpt-3.5-turbo",
+      "GPT-4.1",
+      "o1-preview",
+      "o1-mini",
+      "o3-mini",
+      "o3-pro",
+      "o4-mini",
+      "chatgpt-4o-latest",
+    ])("infers openai for %s", (model) => {
+      expect(inferProvider(model)).toBe("openai");
+    });
+  });
+
+  describe("explicit prefix syntax", () => {
+    it("resolves anthropic: prefix", () => {
+      expect(inferProvider("anthropic:custom-model")).toBe("anthropic");
+    });
+
+    it("resolves openai: prefix", () => {
+      expect(inferProvider("openai:ft:gpt-4o:org:suffix")).toBe("openai");
+    });
+
+    it("is case-insensitive for the prefix", () => {
+      expect(inferProvider("OpenAI:gpt-4o")).toBe("openai");
+      expect(inferProvider("Anthropic:claude-sonnet-4")).toBe("anthropic");
+    });
+
+    it("does not treat short prefix before colon as provider", () => {
+      expect(() => inferProvider("x:model")).toThrow("Cannot determine LLM provider");
+    });
+  });
+
+  describe("error cases", () => {
+    it("throws for empty string", () => {
+      expect(() => inferProvider("")).toThrow("Model name is required");
+    });
+
+    it("throws for unknown model name", () => {
+      expect(() => inferProvider("llama-3.2-70b")).toThrow(
+        "Cannot determine LLM provider",
+      );
+    });
+
+    it("includes the model name in the error message", () => {
+      expect(() => inferProvider("mystery-model")).toThrow("mystery-model");
+    });
+
+    it("suggests explicit prefix syntax in the error", () => {
+      expect(() => inferProvider("deepseek-coder")).toThrow(
+        "provider:model-name",
+      );
+    });
+  });
+});
+
+describe("stripProviderPrefix", () => {
+  it("strips anthropic: prefix", () => {
+    expect(stripProviderPrefix("anthropic:claude-sonnet-4")).toBe("claude-sonnet-4");
+  });
+
+  it("strips openai: prefix", () => {
+    expect(stripProviderPrefix("openai:gpt-4o")).toBe("gpt-4o");
+  });
+
+  it("returns original name when no explicit prefix", () => {
+    expect(stripProviderPrefix("claude-sonnet-4")).toBe("claude-sonnet-4");
+    expect(stripProviderPrefix("gpt-4o")).toBe("gpt-4o");
+  });
+
+  it("preserves colons that are part of the model name (ollama format)", () => {
+    expect(stripProviderPrefix("qwen2.5-coder:7b")).toBe("qwen2.5-coder:7b");
+  });
+
+  it("does not strip unknown provider prefixes", () => {
+    expect(stripProviderPrefix("ollama:llama-3.2")).toBe("ollama:llama-3.2");
+  });
+});
+
+describe("resolveProxyBaseUrl", () => {
+  const proxy = "https://api.stigmer.ai";
+
+  it("constructs Anthropic proxy path", () => {
+    expect(resolveProxyBaseUrl(proxy, "anthropic")).toBe(
+      "https://api.stigmer.ai/v1/proxy/llm/anthropic",
+    );
+  });
+
+  it("constructs OpenAI proxy path (includes /v1 suffix)", () => {
+    expect(resolveProxyBaseUrl(proxy, "openai")).toBe(
+      "https://api.stigmer.ai/v1/proxy/llm/openai/v1",
+    );
+  });
+
+  it("strips trailing slashes from the proxy endpoint", () => {
+    expect(resolveProxyBaseUrl("https://api.stigmer.ai///", "anthropic")).toBe(
+      "https://api.stigmer.ai/v1/proxy/llm/anthropic",
+    );
+  });
+
+  it("works with localhost endpoints", () => {
+    expect(resolveProxyBaseUrl("http://localhost:7234", "openai")).toBe(
+      "http://localhost:7234/v1/proxy/llm/openai/v1",
+    );
+  });
+});
+
+describe("buildProxyHeaders", () => {
+  it("includes Authorization bearer token", () => {
+    const headers = buildProxyHeaders("tok_abc123");
+    expect(headers).toEqual({
+      Authorization: "Bearer tok_abc123",
+    });
+  });
+
+  it("includes X-Stigmer-Execution-Id when provided", () => {
+    const headers = buildProxyHeaders("tok_abc", { executionId: "exec-42" });
+    expect(headers).toEqual({
+      Authorization: "Bearer tok_abc",
+      "X-Stigmer-Execution-Id": "exec-42",
+    });
+  });
+
+  it("includes X-Stigmer-Mcp-Server-Id when provided", () => {
+    const headers = buildProxyHeaders("tok_abc", { mcpServerId: "mcp-srv-1" });
+    expect(headers).toEqual({
+      Authorization: "Bearer tok_abc",
+      "X-Stigmer-Mcp-Server-Id": "mcp-srv-1",
+    });
+  });
+
+  it("includes both scope headers when both provided", () => {
+    const headers = buildProxyHeaders("tok_abc", {
+      executionId: "exec-42",
+      mcpServerId: "mcp-srv-1",
+    });
+    expect(headers).toEqual({
+      Authorization: "Bearer tok_abc",
+      "X-Stigmer-Execution-Id": "exec-42",
+      "X-Stigmer-Mcp-Server-Id": "mcp-srv-1",
+    });
+  });
+
+  it("omits scope headers when options are empty strings", () => {
+    const headers = buildProxyHeaders("tok_abc", {
+      executionId: "",
+      mcpServerId: "",
+    });
+    expect(headers).toEqual({
+      Authorization: "Bearer tok_abc",
+    });
+  });
+});