@ryanfw/prompt-orchestration-pipeline 1.3.4 → 1.3.5

package/src/llm/index.ts

@@ -20,9 +20,14 @@ import { ensureMessagesPresent, isJsonResponseFormat } from "../providers/base.t
 import {
   MODEL_CONFIG,
   PROVIDER_FUNCTIONS,
+  PROVIDERS,
   getModelConfig,
+  normalizeLegacyProvider,
+} from "../config/models.ts";
+import type {
+  ProviderFunctionEntry,
+  ModelCatalogProviderName,
 } from "../config/models.ts";
-import type { ProviderFunctionsIndex } from "../config/models.ts";
 import type {
   ChatOptions,
   ChatResponse,
@@ -44,22 +49,6 @@ import type {
 } from "../providers/types.ts";
 import { ProviderJsonParseError } from "../providers/types.ts";
 
-// ─── Provider Name Mapping ───────────────────────────────────────────────────
-// types.ts uses "claudecode" (one word), config/models.ts uses "claude-code" (hyphenated).
-
-/** Maps gateway ProviderName to config provider key. */
-function toConfigProvider(name: ProviderName): string {
-  if (name === "claudecode") return "claude-code";
-  if (name === "zhipu") return "zai";
-  return name;
-}
-
-/** Maps config provider key to gateway ProviderName. */
-function fromConfigProvider(configName: string): ProviderName {
-  if (configName === "claude-code") return "claudecode";
-  return configName as ProviderName;
-}
-
 // ─── Module State ────────────────────────────────────────────────────────────
 
 const llmEvents = new EventEmitter();
@@ -73,68 +62,82 @@ function warnUnknownAliasOnce(alias: string): void {
   console.warn(`[llm] unknown model alias "${alias}"; reporting cost as estimated`);
 }
 
+function normalizeProviderOrThrow(name: string): ProviderName {
+  const canonical = normalizeLegacyProvider(name);
+  if (!canonical) {
+    throw new Error(`Unknown provider: ${name}`);
+  }
+  return canonical;
+}
+
 // ─── Adapter Dispatch ────────────────────────────────────────────────────────
 
-async function dispatchByProvider(
-  options: ChatOptions,
-): Promise<AdapterResponse> {
-  const { provider, messages, model, temperature, maxTokens, responseFormat, topP, stop, maxRetries, requestTimeoutMs } = options;
-
-  switch (provider) {
-    case "alibaba":
-      return alibabaChat({
-        messages, model, temperature, maxTokens, responseFormat, topP, stop, maxRetries, requestTimeoutMs,
-        frequencyPenalty: options.frequencyPenalty,
-        presencePenalty: options.presencePenalty,
-      });
-    case "anthropic":
-      return anthropicChat({ messages, model, temperature, maxTokens, responseFormat, topP, stop, maxRetries, requestTimeoutMs });
-    case "openai":
-      return openaiChat({
-        messages, model, temperature, maxTokens, responseFormat, topP, stop, maxRetries, requestTimeoutMs,
-        seed: undefined,
-        frequencyPenalty: options.frequencyPenalty,
-        presencePenalty: options.presencePenalty,
-      });
-    case "gemini":
-      return geminiChat({
-        messages, model, temperature, maxTokens, responseFormat, topP, stop, maxRetries, requestTimeoutMs,
-        frequencyPenalty: options.frequencyPenalty,
-        presencePenalty: options.presencePenalty,
-      });
-    case "deepseek":
-      return deepseekChat({
-        messages, model, temperature, maxTokens, responseFormat, topP, stop, maxRetries, requestTimeoutMs,
-        frequencyPenalty: options.frequencyPenalty,
-        presencePenalty: options.presencePenalty,
-      });
-    case "moonshot":
-      return moonshotChat({ messages, model, maxTokens, responseFormat, maxRetries, requestTimeoutMs });
-    case "zai":
-    case "zhipu":
-      return zaiChat({ messages, model, temperature, maxTokens, responseFormat, topP, stop, maxRetries, requestTimeoutMs });
-    case "claudecode":
-      return claudeCodeChat({ messages, model, maxTokens, responseFormat, maxRetries, requestTimeoutMs });
-    case "opencode":
-      return opencodeChat({
-        messages, model, responseFormat, maxRetries, requestTimeoutMs,
-        opencode: options.opencode,
-      });
-    case "mock": {
-      if (!mockProvider) {
-        throw new Error("No mock provider registered. Call registerMockProvider() first.");
-      }
-      return mockProvider.chat(options);
+type AdapterFn = (opts: ChatOptions) => Promise<AdapterResponse>;
+
+const ADAPTERS: Record<ProviderName, AdapterFn> = {
+  openai: (opts) => openaiChat(opts),
+  anthropic: (opts) => anthropicChat(opts),
+  gemini: (opts) => geminiChat(opts),
+  deepseek: (opts) => deepseekChat(opts),
+  moonshot: (opts) => moonshotChat(opts),
+  zai: (opts) => zaiChat(opts),
+  alibaba: (opts) => alibabaChat(opts),
+  "claude-code": (opts) => claudeCodeChat(opts),
+  opencode: (opts) => opencodeChat(opts),
+  mock: (opts) => {
+    if (!mockProvider) {
+      throw new Error("No mock provider registered. Call registerMockProvider() first.");
     }
-    default:
-      throw new Error(`Unknown provider: ${provider as string}`);
+    return mockProvider.chat(opts);
+  },
+};
+
+const CLI_AVAILABILITY: Partial<Record<ProviderName, () => boolean>> = {
+  "claude-code": isClaudeCodeAvailable,
+  opencode: isOpenCodeAvailable,
+};
+
+function buildAdapterOptions(options: ChatOptions): ChatOptions {
+  const declared = PROVIDERS[options.provider].sampling;
+  const opts: ChatOptions = {
+    provider: options.provider,
+    messages: options.messages,
+    model: options.model,
+    maxTokens: options.maxTokens,
+    responseFormat: options.responseFormat,
+    maxRetries: options.maxRetries,
+    requestTimeoutMs: options.requestTimeoutMs,
+  };
+  if (options.opencode !== undefined) {
+    opts.opencode = options.opencode;
+  }
+  if (declared.includes("temperature") && options.temperature !== undefined) {
+    opts.temperature = options.temperature;
+  }
+  if (declared.includes("topP") && options.topP !== undefined) {
+    opts.topP = options.topP;
+  }
+  if (declared.includes("stop") && options.stop !== undefined) {
+    opts.stop = options.stop;
   }
+  if (declared.includes("frequencyPenalty") && options.frequencyPenalty !== undefined) {
+    opts.frequencyPenalty = options.frequencyPenalty;
+  }
+  if (declared.includes("presencePenalty") && options.presencePenalty !== undefined) {
+    opts.presencePenalty = options.presencePenalty;
+  }
+  return opts;
 }
 
 async function callAdapter(
   options: ChatOptions,
 ): Promise<AdapterResponse> {
-  const response = await dispatchByProvider(options);
+  const adapter = ADAPTERS[options.provider] as AdapterFn | undefined;
+  if (!adapter) {
+    throw new Error(`Unknown provider: ${options.provider as string}`);
+  }
+  const adapterOptions = buildAdapterOptions(options);
+  const response = await adapter(adapterOptions);
   response.usageAvailable = resolveUsageAvailable(options.provider, options);
   return response;
 }
@@ -173,14 +176,14 @@ async function performJsonRepair(
 /**
  * Returns whether a provider can structurally report token usage for the given
  * options. This is the single source of truth for `usageAvailable`; adapters
- * never set it themselves. Forward-compatible with the #25 provider registry,
- * where this becomes a registry column.
+ * never set it themselves. The base capability comes from
+ * `PROVIDERS[provider].usageAvailable`; OpenCode keeps its runtime mode/baseUrl
+ * exception because SDK mode reports usage while CLI mode does not.
  */
 export function resolveUsageAvailable(
   provider: ProviderName,
   options: ChatOptions,
 ): boolean {
-  if (provider === "claudecode") return false;
   if (provider === "opencode") {
     if (options.opencode?.mode === "cli") return false;
     if (options.opencode?.mode === "sdk") return true;
@@ -190,7 +193,7 @@ export function resolveUsageAvailable(
       process.env.OPENCODE_BASE_URL;
     return baseUrl != null;
   }
-  return true;
+  return PROVIDERS[provider].usageAvailable;
 }
 
 // ─── Usage Normalization ─────────────────────────────────────────────────────
@@ -352,6 +355,8 @@ async function writeDebugLog(options: ChatOptions, response: ChatResponse): Prom
 // ─── Public API ──────────────────────────────────────────────────────────────
 
 export async function chat(options: ChatOptions): Promise<ChatResponse> {
+  const provider = normalizeProviderOrThrow(options.provider);
+  options = { ...options, provider };
   ensureMessagesPresent(options.messages, options.provider);
   const configTimeout = getConfig().taskRunner.llmRequestTimeout;
   const opts = {
@@ -415,7 +420,7 @@ export async function chat(options: ChatOptions): Promise<ChatResponse> {
       : 0;
     const costEstimated = price === null || usage.source !== "reported";
     if (price === null) {
-      warnUnknownAliasOnce(`${toConfigProvider(opts.provider)}:${model}`);
+      warnUnknownAliasOnce(`${opts.provider}:${model}`);
     }
     const duration = Date.now() - startTime;
 
@@ -474,7 +479,7 @@ export async function complete(
   prompt: string,
   options?: Partial<ChatOptions>,
 ): Promise<ChatResponse> {
-  const defaultProvider = getConfig().llm.defaultProvider as ProviderName;
+  const defaultProvider = normalizeProviderOrThrow(getConfig().llm.defaultProvider);
   return chat({
     provider: defaultProvider,
     messages: [{ role: "user", content: prompt }],
@@ -512,6 +517,7 @@ export function createHighLevelLLM(options?: Partial<ChatOptions>): HighLevelLLM
 export function createLLMWithOverride(
   override: { provider: ProviderName; model: string },
 ): HighLevelLLM {
+  const canonicalProvider = normalizeProviderOrThrow(override.provider);
   const base = createHighLevelLLM();
 
   const GUARDED_METHODS = new Set([
@@ -538,11 +544,11 @@ export function createLLMWithOverride(
       // If accessing known top-level methods, return them bound with override
       if (prop === "chat") {
         return (opts: ChatOptions) =>
-          chat({ ...opts, provider: override.provider, model: override.model });
+          chat({ ...opts, provider: canonicalProvider, model: override.model });
       }
       if (prop === "complete") {
         return (prompt: string, opts?: Partial<ChatOptions>) =>
-          complete(prompt, { ...opts, provider: override.provider, model: override.model });
+          complete(prompt, { ...opts, provider: canonicalProvider, model: override.model });
       }
       if (prop === "createChain" || prop === "withRetry" || prop === "parallel" || prop === "getAvailableProviders") {
         return Reflect.get(target, prop, receiver);
@@ -560,7 +566,7 @@ export function createLLMWithOverride(
             return (opts?: Partial<ChatOptions>) =>
               chat({
                 ...opts,
-                provider: override.provider,
+                provider: canonicalProvider,
                 model: override.model,
               } as ChatOptions);
           },
@@ -571,7 +577,7 @@ export function createLLMWithOverride(
       return (opts?: Partial<ChatOptions>) =>
         chat({
           ...opts,
-          provider: override.provider,
+          provider: canonicalProvider,
           model: override.model,
         } as ChatOptions);
     },
@@ -679,19 +685,18 @@ export function registerMockProvider(provider: MockProvider): void {
 }
 
 export function getAvailableProviders(): ProviderAvailability {
-  return {
-    alibaba: !!process.env["ALIBABA_API_KEY"],
-    openai: !!process.env["OPENAI_API_KEY"],
-    anthropic: !!process.env["ANTHROPIC_API_KEY"],
-    gemini: !!process.env["GEMINI_API_KEY"],
-    deepseek: !!process.env["DEEPSEEK_API_KEY"],
-    zai: !!(process.env["ZAI_API_KEY"] ?? process.env["ZHIPU_API_KEY"]),
-    zhipu: !!(process.env["ZAI_API_KEY"] ?? process.env["ZHIPU_API_KEY"]),
-    moonshot: !!process.env["MOONSHOT_API_KEY"],
-    claudecode: isClaudeCodeAvailable(),
-    mock: mockProvider !== null,
-    opencode: isOpenCodeAvailable(),
-  };
+  const availability = {} as ProviderAvailability;
+  for (const name of Object.keys(PROVIDERS) as ProviderName[]) {
+    if (name === "mock") {
+      availability[name] = mockProvider !== null;
+      continue;
+    }
+    const meta = PROVIDERS[name];
+    const envAvailable = meta.envKeys.some((key) => !!process.env[key]);
+    const cliAvailable = CLI_AVAILABILITY[name]?.() ?? false;
+    availability[name] = envAvailable || cliAvailable;
+  }
+  return availability;
 }
 
 export function estimateTokens(text: string): number {
@@ -704,7 +709,7 @@ export interface ModelPrice {
 }
 
 /**
- * Looks up the per-million-token price for a gateway `(provider, model)` pair.
+ * Looks up the per-million-token price for a `(provider, model)` pair.
  * Returns `null` when no price is known. This is the single cost-lookup surface
  * used by both `calculateCost` and the `costEstimated` discriminator in `chat()`.
  */
@@ -712,8 +717,9 @@ export function findModelPrice(
   provider: string,
   model: string,
 ): ModelPrice | null {
-  const configProvider = toConfigProvider(provider as ProviderName);
-  const alias = `${configProvider}:${model}`;
+  const canonical = normalizeLegacyProvider(provider);
+  if (!canonical) return null;
+  const alias = `${canonical}:${model}`;
   const direct = getModelConfig(alias);
   if (direct) {
     return {
@@ -722,7 +728,7 @@ export function findModelPrice(
     };
   }
   for (const entry of Object.values(MODEL_CONFIG)) {
-    if (entry.provider === configProvider && entry.model === model) {
+    if (entry.provider === canonical && entry.model === model) {
       return {
         tokenCostInPerMillion: entry.tokenCostInPerMillion,
         tokenCostOutPerMillion: entry.tokenCostOutPerMillion,
@@ -749,31 +755,22 @@ export function calculateCost(
 function buildProviderModelMap(): ProviderModelMap {
   const map: ProviderModelMap = {};
 
-  for (const [configProviderName, entries] of Object.entries(
-    PROVIDER_FUNCTIONS as ProviderFunctionsIndex,
-  )) {
-    const gatewayProvider = fromConfigProvider(configProviderName);
+  for (const [providerName, entries] of Object.entries(PROVIDER_FUNCTIONS) as [
+    ModelCatalogProviderName,
+    ProviderFunctionEntry[],
+  ][]) {
     const group: ProviderGroup = {};
 
     for (const entry of entries) {
       group[entry.functionName] = (opts?: Partial<ChatOptions>) =>
         chat({
-          provider: gatewayProvider,
+          provider: providerName,
           model: entry.model,
           ...opts,
         } as ChatOptions);
     }
 
-    map[gatewayProvider] = group;
-
-    // Preserve config-key access for callers still using hyphenated config names.
-    if (configProviderName !== gatewayProvider) {
-      map[configProviderName] = group;
-    }
-
-    if (gatewayProvider === "zai") {
-      map["zhipu"] = group;
-    }
+    map[providerName] = group;
   }
 
   return map;

package/src/providers/__tests__/claude-code.test.ts

@@ -125,9 +125,15 @@ describe("claudeCodeChat", () => {
     const plainText = "This is not JSON";
     spawnMock.mockReturnValue(createMockProcFromText(plainText));
 
-    await expect(claudeCodeChat(baseOptions)).rejects.toBeInstanceOf(
-      ProviderJsonParseError,
-    );
+    try {
+      await claudeCodeChat(baseOptions);
+      expect.unreachable("should have thrown");
+    } catch (err) {
+      expect(err).toBeInstanceOf(ProviderJsonParseError);
+      const parseErr = err as ProviderJsonParseError;
+      expect(parseErr.provider).toBe("claude-code");
+      expect(parseErr.model).toBe("sonnet");
+    }
   });
 
   it("combines system and user messages into the prompt", async () => {

package/src/providers/__tests__/moonshot.test.ts

@@ -175,7 +175,7 @@ describe("moonshotChat", () => {
     expect(headers["Content-Type"]).toBe("application/json");
   });
 
-  it("does not include temperature, topP, frequencyPenalty, or presencePenalty in request body", async () => {
+  it("omits temperature, top_p, and stop from request body when not supplied", async () => {
     const events = makeOpenAiSseEvents([JSON.stringify({ ok: true })]);
     fetchMock.mockResolvedValue(mockStreamingResponse(events));
 
@@ -186,8 +186,38 @@ describe("moonshotChat", () => {
     );
     expect(body.temperature).toBeUndefined();
     expect(body.top_p).toBeUndefined();
-    expect(body.frequency_penalty).toBeUndefined();
-    expect(body.presence_penalty).toBeUndefined();
+    expect(body.stop).toBeUndefined();
+  });
+
+  it("includes temperature, top_p, and stop in request body when supplied", async () => {
+    const events = makeOpenAiSseEvents([JSON.stringify({ ok: true })]);
+    fetchMock.mockResolvedValue(mockStreamingResponse(events));
+
+    await moonshotChat({
+      ...baseOptions,
+      temperature: 0.4,
+      topP: 0.8,
+      stop: ["\n\nUser:"],
+    });
+
+    const body = JSON.parse(
+      (fetchMock.mock.calls[0] as [string, RequestInit])[1].body as string,
+    );
+    expect(body.temperature).toBe(0.4);
+    expect(body.top_p).toBe(0.8);
+    expect(body.stop).toEqual(["\n\nUser:"]);
+  });
+
+  it("passes stop as a string when given a string", async () => {
+    const events = makeOpenAiSseEvents([JSON.stringify({ ok: true })]);
+    fetchMock.mockResolvedValue(mockStreamingResponse(events));
+
+    await moonshotChat({ ...baseOptions, stop: "END" });
+
+    const body = JSON.parse(
+      (fetchMock.mock.calls[0] as [string, RequestInit])[1].body as string,
+    );
+    expect(body.stop).toBe("END");
   });
 
   describe("content-filter fallback to DeepSeek", () => {

package/src/providers/__tests__/types.test.ts

@@ -5,6 +5,7 @@ import {
   type ChatOptions,
   type LLMRequestCompleteEvent,
   type LLMRequestErrorEvent,
+  type MoonshotOptions,
   type NormalizedUsage,
   type OpenCodeOptions,
   type OpenCodePermissionAction,
@@ -13,6 +14,8 @@ import {
   type OpenCodePermissionName,
   type OpenCodePermissionRule,
   type OpenCodeRequestConfig,
+  type ProviderAvailability,
+  type ProviderName,
   type UsageSource,
 } from "../types.ts";
 
@@ -192,6 +195,46 @@ describe("OpenCode types", () => {
   });
 });
 
+describe("provider type contracts", () => {
+  it("ProviderName excludes the legacy zhipu and claudecode spellings", () => {
+    type HasLegacy = "zhipu" | "claudecode" extends ProviderName ? true : false;
+    const legacyExcluded: HasLegacy = false;
+    expect(legacyExcluded).toBe(false);
+  });
+
+  it("ProviderName includes canonical claude-code and zai", () => {
+    type HasClaudeCode = "claude-code" extends ProviderName ? true : false;
+    type HasZai = "zai" extends ProviderName ? true : false;
+    const claudeCodePresent: HasClaudeCode = true;
+    const zaiPresent: HasZai = true;
+    expect(claudeCodePresent).toBe(true);
+    expect(zaiPresent).toBe(true);
+  });
+
+  it("ProviderAvailability is keyed by canonical claude-code, not legacy spellings", () => {
+    type HasClaudeCode =
+      "claude-code" extends keyof ProviderAvailability ? true : false;
+    type HasLegacyKeys =
+      "zhipu" | "claudecode" extends keyof ProviderAvailability ? true : false;
+    const claudeCodePresent: HasClaudeCode = true;
+    const legacyAbsent: HasLegacyKeys = false;
+    expect(claudeCodePresent).toBe(true);
+    expect(legacyAbsent).toBe(false);
+  });
+
+  it("MoonshotOptions accepts temperature, topP, and stop sampling params", () => {
+    const options: MoonshotOptions = {
+      messages: [{ role: "user", content: "hello" }],
+      temperature: 0.5,
+      topP: 0.9,
+      stop: ["\n\n"],
+    };
+    expect(options.temperature).toBe(0.5);
+    expect(options.topP).toBe(0.9);
+    expect(options.stop).toEqual(["\n\n"]);
+  });
+});
+
 describe("usage telemetry contracts", () => {
   it("NormalizedUsage requires a source field", () => {
     const usage: NormalizedUsage = {