@ryanfw/prompt-orchestration-pipeline 1.3.4 → 1.3.5

package/src/core/__tests__/job-view.test.ts

@@ -1196,6 +1196,104 @@ describe("normalizeJobView", () => {
       });
     });
   });
+
+  describe("tokenUsage provider key normalization (AC-8)", () => {
+    test('rewrites a persisted "zhipu:<model>" key to "zai:<model>"', () => {
+      // Arrange / Act
+      const view: JobView = normalizeJobView(
+        {
+          state: "done",
+          tasks: { alpha: { state: "done", tokenUsage: [["zhipu:glm-5", 10, 5, 0.25]] } },
+        },
+        JOB_ID,
+        LOCATION,
+      );
+
+      // Assert
+      expect(view.tasks.alpha?.tokenUsage).toEqual([["zai:glm-5", 10, 5, 0.25]]);
+    });
+
+    test('rewrites a persisted "claudecode:<model>" key to "claude-code:<model>"', () => {
+      // Arrange / Act
+      const view: JobView = normalizeJobView(
+        {
+          state: "done",
+          tasks: { alpha: { state: "done", tokenUsage: [["claudecode:sonnet", 1, 2, 0]] } },
+        },
+        JOB_ID,
+        LOCATION,
+      );
+
+      // Assert
+      expect(view.tasks.alpha?.tokenUsage).toEqual([["claude-code:sonnet", 1, 2, 0]]);
+    });
+
+    test("preserves an unknown provider segment unchanged", () => {
+      // Arrange / Act
+      const view: JobView = normalizeJobView(
+        {
+          state: "done",
+          tasks: { alpha: { state: "done", tokenUsage: [["unknown:model", 1, 1, 1]] } },
+        },
+        JOB_ID,
+        LOCATION,
+      );
+
+      // Assert
+      expect(view.tasks.alpha?.tokenUsage).toEqual([["unknown:model", 1, 1, 1]]);
+    });
+
+    test("preserves a colonless first element unchanged", () => {
+      // Arrange / Act
+      const view: JobView = normalizeJobView(
+        {
+          state: "done",
+          tasks: { alpha: { state: "done", tokenUsage: [["bad"]] } },
+        },
+        JOB_ID,
+        LOCATION,
+      );
+
+      // Assert
+      expect(view.tasks.alpha?.tokenUsage).toEqual([["bad"]]);
+    });
+
+    test("normalizes only the first colon-delimited segment", () => {
+      // Arrange / Act
+      const view: JobView = normalizeJobView(
+        {
+          state: "done",
+          tasks: { alpha: { state: "done", tokenUsage: [["zhipu:glm-5:extra", 1, 1, 1]] } },
+        },
+        JOB_ID,
+        LOCATION,
+      );
+
+      // Assert
+      expect(view.tasks.alpha?.tokenUsage).toEqual([["zai:glm-5:extra", 1, 1, 1]]);
+    });
+
+    test("cost totals match the pre-normalization values for a legacy key", () => {
+      // Arrange / Act
+      const view: JobView = normalizeJobView(
+        {
+          state: "done",
+          tasks: { alpha: { state: "done", tokenUsage: [["zhipu:glm-5", 10, 5, 0.25]] } },
+        },
+        JOB_ID,
+        LOCATION,
+      );
+
+      // Assert — the numeric aggregation is independent of the key normalization.
+      expect(view.costs).toMatchObject({
+        totalCost: 0.25,
+        totalTokens: 15,
+        totalInputTokens: 10,
+        totalOutputTokens: 5,
+      });
+      expect(view.tasks.alpha?.tokenUsage?.[0]).toEqual(["zai:glm-5", 10, 5, 0.25]);
+    });
+  });
 });
 
 describe("deriveProgress (AC-6)", () => {

package/src/core/agent-step.ts

@@ -292,7 +292,10 @@ interface AgentRunDeps {
 export async function executeAgent(
   args: {
     io: TaskFileIO;
-    entry: AgentEntryConfig & { name: string };
+    entry: AgentEntryConfig & {
+      name: string;
+      onEvent?: (event: HarnessEvent) => void;
+    };
   },
   deps?: AgentRunDeps,
 ): Promise<AgentStepResult> {
@@ -347,6 +350,7 @@ export async function executeAgent(
         void io.writeLog(logName, JSON.stringify(redacted) + "\n", {
           mode: "append",
         });
+        entry.onEvent?.(event);
       },
     };
 

package/src/core/agent-types.ts

@@ -1,4 +1,4 @@
-import type { HarnessName, ModelPayload, Usage } from "../harness/index.ts";
+import type { HarnessEvent, HarnessName, ModelPayload, Usage } from "../harness/index.ts";
 
 export interface McpServerConnection {
   url: string;
@@ -54,6 +54,11 @@ export interface TaskAgentOptions {
   idleTimeoutMs?: number;
   /** Capture a git diff of the working tree as an `agent.patch` artifact. */
   captureDiff?: boolean;
+  /**
+   * Invoked for every adapter {@link HarnessEvent} observed during the run,
+   * after POP's own buffer + debug-log write. Absent, behavior is unchanged.
+   */
+  onEvent?: (event: HarnessEvent) => void;
 }
 
 /** The `runAgent()` function injected into JavaScript task stages. */

package/src/core/job-view.ts

@@ -1,3 +1,4 @@
+import { normalizeLegacyProvider } from "../config/models.ts";
 import {
   JOB_STATUS_SYNONYMS,
   VALID_JOB_STATUSES,
@@ -145,6 +146,25 @@ function toTaskError(value: unknown): JobViewTask["error"] {
   return undefined;
 }
 
+function normalizeTokenUsageEntry(entry: unknown): unknown {
+  if (!Array.isArray(entry)) return entry;
+  const first = entry[0];
+  if (typeof first !== "string") return entry;
+  const colonIndex = first.indexOf(":");
+  if (colonIndex === -1) return entry;
+  const providerSegment = first.slice(0, colonIndex);
+  const canonical = normalizeLegacyProvider(providerSegment);
+  if (canonical === null) return entry;
+  const copy = entry.slice();
+  copy[0] = `${canonical}:${first.slice(colonIndex + 1)}`;
+  return copy;
+}
+
+function normalizeTokenUsage(value: unknown): unknown[] | undefined {
+  if (!Array.isArray(value)) return undefined;
+  return value.map(normalizeTokenUsageEntry);
+}
+
 function toGateInfo(value: unknown): GateInfo | null | undefined {
   if (value === null) return null;
   if (!isRecord(value)) return undefined;
@@ -189,7 +209,7 @@ function toJobViewTask(name: string, value: unknown): JobViewTask {
     currentStage: typeof task["currentStage"] === "string" ? task["currentStage"] : undefined,
     failedStage: typeof task["failedStage"] === "string" ? task["failedStage"] : undefined,
     artifacts: task["artifacts"],
-    tokenUsage: Array.isArray(task["tokenUsage"]) ? task["tokenUsage"] : undefined,
+    tokenUsage: normalizeTokenUsage(task["tokenUsage"]),
     error: toTaskError(task["error"]),
     skipReason: typeof task["skipReason"] === "string" ? task["skipReason"] : undefined,
     skippedBy: typeof task["skippedBy"] === "string" ? task["skippedBy"] : undefined,

package/src/llm/__tests__/dispatch.test.ts

@@ -0,0 +1,130 @@
+import { describe, expect, it, vi } from "vitest";
+import { mock } from "bun:test";
+import type { ChatOptions } from "../../providers/types.ts";
+
+let moonshotReceived: Record<string, unknown> | undefined;
+let claudeCodeReceived: Record<string, unknown> | undefined;
+
+const moonshotChatMock = vi.fn(async (opts: ChatOptions) => {
+  moonshotReceived = opts as unknown as Record<string, unknown>;
+  return {
+    content: "moonshot-response",
+    usage: { prompt_tokens: 1, completion_tokens: 1, total_tokens: 2 },
+  };
+});
+
+const claudeCodeChatMock = vi.fn(async (opts: ChatOptions) => {
+  claudeCodeReceived = opts as unknown as Record<string, unknown>;
+  return { content: "claude-code-response" };
+});
+
+mock.module("../../providers/moonshot.ts", () => ({
+  moonshotChat: moonshotChatMock,
+}));
+
+mock.module("../../providers/claude-code.ts", () => ({
+  claudeCodeChat: claudeCodeChatMock,
+  isClaudeCodeAvailable: () => false,
+}));
+
+import { chat, registerMockProvider } from "../index.ts";
+import type { MockProvider } from "../../providers/types.ts";
+
+const baseMessages = [{ role: "user" as const, content: "hi" }];
+
+describe("registry dispatch", () => {
+  it("moonshot forwards only declared sampling params (temperature, topP, stop)", async () => {
+    moonshotChatMock.mockClear();
+    await chat({
+      provider: "moonshot",
+      messages: baseMessages,
+      model: "kimi-k2.5",
+      temperature: 0.5,
+      topP: 0.9,
+      stop: ["end"],
+      frequencyPenalty: 1.0,
+      presencePenalty: 0.5,
+    });
+
+    expect(moonshotReceived).toBeDefined();
+    const opts = moonshotReceived!;
+    expect(opts.temperature).toBe(0.5);
+    expect(opts.topP).toBe(0.9);
+    expect(opts.stop).toEqual(["end"]);
+    expect(opts.frequencyPenalty).toBeUndefined();
+    expect(opts.presencePenalty).toBeUndefined();
+  });
+
+  it("claude-code (CLI) forwards no sampling params", async () => {
+    claudeCodeChatMock.mockClear();
+    await chat({
+      provider: "claude-code",
+      messages: baseMessages,
+      model: "sonnet",
+      temperature: 0.5,
+      topP: 0.9,
+      stop: ["x"],
+      frequencyPenalty: 1.0,
+      presencePenalty: 0.5,
+    });
+
+    expect(claudeCodeReceived).toBeDefined();
+    const opts = claudeCodeReceived!;
+    expect(opts.temperature).toBeUndefined();
+    expect(opts.topP).toBeUndefined();
+    expect(opts.stop).toBeUndefined();
+    expect(opts.frequencyPenalty).toBeUndefined();
+    expect(opts.presencePenalty).toBeUndefined();
+  });
+
+  it("forwards common fields to the adapter", async () => {
+    moonshotChatMock.mockClear();
+    await chat({
+      provider: "moonshot",
+      messages: baseMessages,
+      model: "kimi-k2.5",
+      maxTokens: 4096,
+      maxRetries: 2,
+      requestTimeoutMs: 30_000,
+    });
+
+    expect(moonshotReceived).toBeDefined();
+    const opts = moonshotReceived!;
+    expect(opts.messages).toEqual(baseMessages);
+    expect(opts.model).toBe("kimi-k2.5");
+    expect(opts.maxTokens).toBe(4096);
+    expect(opts.maxRetries).toBe(2);
+    expect(opts.requestTimeoutMs).toBe(30_000);
+  });
+
+  it("mock dispatches through registered mockProvider with common fields", async () => {
+    const mockFn = vi.fn().mockResolvedValue({
+      content: { mock: true },
+      usage: { prompt_tokens: 1, completion_tokens: 1, total_tokens: 2 },
+    });
+    registerMockProvider({ chat: mockFn } as MockProvider);
+
+    await chat({
+      provider: "mock",
+      messages: baseMessages,
+      model: "test-model",
+    });
+
+    expect(mockFn).toHaveBeenCalledTimes(1);
+    const received = mockFn.mock.calls[0]![0] as Record<string, unknown>;
+    expect(received.provider).toBe("mock");
+    expect(received.messages).toEqual(baseMessages);
+    expect(received.model).toBe("test-model");
+  });
+
+  it("throws for unknown provider before dispatch", async () => {
+    await expect(
+      chat({ provider: "nonexistent" as "mock", messages: baseMessages }),
+    ).rejects.toThrow(/unknown provider/i);
+  });
+});
+
+// ADAPTERS type-level exhaustiveness: ADAPTERS in src/llm/index.ts is typed
+// `Record<ProviderName, AdapterFn>`. Adding a new ProviderName without an
+// ADAPTERS row fails `bun run typecheck` because the mapped type requires every
+// union member. This is a compile-time guarantee — no runtime test needed.

package/src/llm/__tests__/index.test.ts

@@ -439,10 +439,10 @@ describe("LLM Gateway", () => {
       }
     });
 
-    it("returns false for claudecode", () => {
+    it("returns false for claude-code", () => {
       expect(
-        resolveUsageAvailable("claudecode", {
-          provider: "claudecode",
+        resolveUsageAvailable("claude-code", {
+          provider: "claude-code",
           messages: baseMessages,
         }),
       ).toBe(false);
@@ -545,7 +545,7 @@ describe("LLM Gateway", () => {
       expect(cost).toBe(0);
     });
 
-    it("handles claudecode provider name mapping", () => {
+    it("prices claude-code provider", () => {
       // claude-code:sonnet — tokenCostInPerMillion: 0, tokenCostOutPerMillion: 0
       const usage: NormalizedUsage = {
         promptTokens: 1000,
@@ -553,7 +553,7 @@ describe("LLM Gateway", () => {
         totalTokens: 2000,
         source: "reported",
       };
-      const cost = calculateCost("claudecode", "sonnet", usage);
+      const cost = calculateCost("claude-code", "sonnet", usage);
       expect(cost).toBe(0);
     });
   });
@@ -570,18 +570,18 @@ describe("LLM Gateway", () => {
       });
     });
 
-    it("returns the zero-cost entry for claudecode provider mapping", () => {
+    it("returns the zero-cost entry for claude-code", () => {
       // claude-code:sonnet — zero-cost subscription
-      const price = findModelPrice("claudecode", "sonnet");
+      const price = findModelPrice("claude-code", "sonnet");
       expect(price).toEqual({
         tokenCostInPerMillion: 0,
         tokenCostOutPerMillion: 0,
       });
     });
 
-    it("returns the price for zhipu provider mapping", () => {
-      // zhipu maps to zai; zai:glm-5 → tokenCostInPerMillion: 1, tokenCostOutPerMillion: 3.2
-      const price = findModelPrice("zhipu", "glm-5");
+    it("returns the price for zai", () => {
+      // zai:glm-5 → tokenCostInPerMillion: 1, tokenCostOutPerMillion: 3.2
+      const price = findModelPrice("zai", "glm-5");
       expect(price).toEqual({
         tokenCostInPerMillion: 1,
         tokenCostOutPerMillion: 3.2,
@@ -874,10 +874,10 @@ describe("LLM Gateway", () => {
       // Should have provider groups
       expect(typeof llm).toBe("object");
 
-      // Check that known providers exist under the public gateway names.
+      // Check that known providers exist under the canonical gateway names.
       expect(llm["openai"]).toBeDefined();
       expect(llm["anthropic"]).toBeDefined();
-      expect(llm["claudecode"]).toBeDefined();
+      expect(llm["claude-code"]).toBeDefined();
       expect(llm["zai"]).toBeDefined();
 
       // Each provider group should have callable functions
@@ -891,13 +891,14 @@ describe("LLM Gateway", () => {
       }
     });
 
-    it("keeps the claude-code config-name alias and exposes zai directly", () => {
+    it("exposes canonical provider groups only (no legacy alias keys)", () => {
       const llm = createLLM();
 
-      expect(llm["claudecode"]).toBe(llm["claude-code"]);
-      expect(typeof llm["claudecode"]?.["sonnet"]).toBe("function");
+      expect(typeof llm["claude-code"]?.["sonnet"]).toBe("function");
       expect(typeof llm["zai"]?.["glm5"]).toBe("function");
-      expect(llm["zhipu"]).toBe(llm["zai"]);
+      // Legacy spellings are gone from the model-map surface.
+      expect(llm["claudecode"]).toBeUndefined();
+      expect(llm["zhipu"]).toBeUndefined();
       expect(llm["xai"]).toBeUndefined();
     });
 
@@ -974,7 +975,6 @@ describe("LLM Gateway", () => {
       expect(availability.gemini).toBe(false);
       expect(availability.deepseek).toBe(false);
       expect(availability.zai).toBe(false);
-      expect(availability.zhipu).toBe(false);
       expect(availability.moonshot).toBe(false);
       expect(availability.alibaba).toBe(false);
     });
@@ -990,7 +990,6 @@ describe("LLM Gateway", () => {
       expect(availability.openai).toBe(true);
       expect(availability.anthropic).toBe(true);
       expect(availability.zai).toBe(true);
-      expect(availability.zhipu).toBe(true);
       expect(availability.alibaba).toBe(true);
     });
 

package/src/llm/__tests__/legacy-normalization.test.ts

@@ -0,0 +1,109 @@
+import { describe, expect, it, vi } from "vitest";
+import { mock } from "bun:test";
+import type { ChatOptions } from "../../providers/types.ts";
+
+const zaiChatMock = vi.fn(async (_opts: ChatOptions) => ({
+  content: { ok: true },
+  usage: { prompt_tokens: 1, completion_tokens: 1, total_tokens: 2 },
+}));
+
+mock.module("../../providers/zhipu.ts", () => ({
+  zaiChat: zaiChatMock,
+}));
+
+mock.module("../../core/config.ts", () => ({
+  getConfig: () => ({
+    llm: {
+      defaultProvider: "zhipu",
+      defaultModel: "glm-5",
+      internalProvider: "zai",
+      internalModel: "glm-5",
+      maxConcurrency: 5,
+      retryMaxAttempts: 3,
+      retryBackoffMs: 1000,
+    },
+    taskRunner: {
+      maxRefinementAttempts: 3,
+      stageTimeout: 300000,
+      llmRequestTimeout: 3600000,
+      maxAttempts: 3,
+    },
+  }),
+  resetConfig: () => {},
+}));
+
+import {
+  chat,
+  complete,
+  createLLMWithOverride,
+  findModelPrice,
+} from "../index.ts";
+
+const baseMessages = [{ role: "user" as const, content: "hi" }];
+
+function lastCallProvider(): string {
+  const calls = zaiChatMock.mock.calls as unknown as Array<
+    [ChatOptions]
+  >;
+  return calls[0]![0].provider;
+}
+
+describe("legacy provider normalization (AC-4)", () => {
+  it("chat() dispatches legacy zhipu to the zai adapter", async () => {
+    zaiChatMock.mockClear();
+
+    await chat({
+      provider: "zhipu" as never,
+      messages: baseMessages,
+      model: "glm-5",
+    });
+
+    expect(zaiChatMock).toHaveBeenCalledTimes(1);
+    expect(lastCallProvider()).toBe("zai");
+  });
+
+  it("complete() resolves a legacy zhipu defaultProvider to zai", async () => {
+    zaiChatMock.mockClear();
+
+    await complete("hello");
+
+    expect(zaiChatMock).toHaveBeenCalledTimes(1);
+    expect(lastCallProvider()).toBe("zai");
+  });
+
+  it("createLLMWithOverride() resolves a legacy zhipu override to zai", async () => {
+    zaiChatMock.mockClear();
+
+    const llm = createLLMWithOverride({
+      provider: "zhipu" as never,
+      model: "glm-5",
+    });
+
+    await llm.chat({ provider: "openai", messages: baseMessages } as ChatOptions);
+
+    expect(zaiChatMock).toHaveBeenCalledTimes(1);
+    expect(lastCallProvider()).toBe("zai");
+  });
+
+  it("findModelPrice() normalizes a persisted zhipu cost key to zai", () => {
+    const legacyPrice = findModelPrice("zhipu", "glm-5");
+    const canonicalPrice = findModelPrice("zai", "glm-5");
+
+    expect(legacyPrice).not.toBeNull();
+    expect(legacyPrice).toEqual(canonicalPrice);
+    expect(legacyPrice).toEqual({
+      tokenCostInPerMillion: 1,
+      tokenCostOutPerMillion: 3.2,
+    });
+  });
+
+  it("chat() throws an explicit Unknown provider error before adapter dispatch", async () => {
+    zaiChatMock.mockClear();
+
+    await expect(
+      chat({ provider: "neverheard" as never, messages: baseMessages }),
+    ).rejects.toThrow("Unknown provider: neverheard");
+
+    expect(zaiChatMock).not.toHaveBeenCalled();
+  });
+});