@ryanfw/prompt-orchestration-pipeline 1.2.7 → 1.2.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ryanfw/prompt-orchestration-pipeline",
-  "version": "1.2.7",
+  "version": "1.2.9",
   "description": "A Prompt-orchestration pipeline (POP) is a framework for building, running, and experimenting with complex chains of LLM tasks.",
   "type": "module",
   "main": "src/ui/server/index.ts",

package/src/config/__tests__/models.test.ts

@@ -15,7 +15,7 @@ import {
 } from "../models";
 import type { ModelConfigEntry } from "../models";
 
-const MODEL_COUNT = 48;
+const MODEL_COUNT = 50;
 const PROVIDER_COUNT = 8;
 
 describe("ModelAlias", () => {
@@ -177,6 +177,21 @@ describe("getModelConfig", () => {
     expect(config!.provider).toBe("openai");
   });
 
+  it("returns configs for Alibaba Qwen 3.6 models", () => {
+    expect(getModelConfig("alibaba:qwen3.6-flash")).toMatchObject({
+      provider: "alibaba",
+      model: "qwen3.6-flash",
+    });
+    expect(getModelConfig("alibaba:qwen3.6-plus")).toMatchObject({
+      provider: "alibaba",
+      model: "qwen3.6-plus",
+    });
+    expect(getModelConfig("alibaba:qwen3.6-max-preview")).toMatchObject({
+      provider: "alibaba",
+      model: "qwen3.6-max-preview",
+    });
+  });
+
   it("returns null for unknown aliases", () => {
     expect(getModelConfig("nonexistent:model")).toBeNull();
     expect(getModelConfig("invalid")).toBeNull();
@@ -218,6 +233,14 @@ describe("FUNCTION_NAME_BY_ALIAS", () => {
   it("has correct value for gemini:flash-2.5-lite", () => {
     expect(FUNCTION_NAME_BY_ALIAS["gemini:flash-2.5-lite"]).toBe("flash25Lite");
   });
+
+  it("has correct values for Alibaba Qwen 3.6 models", () => {
+    expect(FUNCTION_NAME_BY_ALIAS["alibaba:qwen3.6-flash"]).toBe("qwen36Flash");
+    expect(FUNCTION_NAME_BY_ALIAS["alibaba:qwen3.6-plus"]).toBe("qwen36Plus");
+    expect(FUNCTION_NAME_BY_ALIAS["alibaba:qwen3.6-max-preview"]).toBe(
+      "qwen36MaxPreview",
+    );
+  });
 });
 
 describe("PROVIDER_FUNCTIONS", () => {
@@ -248,6 +271,13 @@ describe("PROVIDER_FUNCTIONS", () => {
     }
   });
 
+  it("includes callable paths for Alibaba Qwen 3.6 models", () => {
+    const alibabaPaths = PROVIDER_FUNCTIONS.alibaba.map((entry) => entry.fullPath);
+    expect(alibabaPaths).toContain("llm.alibaba.qwen36Flash");
+    expect(alibabaPaths).toContain("llm.alibaba.qwen36Plus");
+    expect(alibabaPaths).toContain("llm.alibaba.qwen36MaxPreview");
+  });
+
   it("is frozen (top-level)", () => {
     expect(Object.isFrozen(PROVIDER_FUNCTIONS)).toBe(true);
   });

package/src/config/models.ts

@@ -27,7 +27,11 @@ function deepFreeze<T>(obj: T): T {
   if (obj === null || typeof obj !== "object") return obj;
   Object.freeze(obj);
   for (const value of Object.values(obj as object)) {
-    if (value !== null && typeof value === "object" && !Object.isFrozen(value)) {
+    if (
+      value !== null &&
+      typeof value === "object" &&
+      !Object.isFrozen(value)
+    ) {
       deepFreeze(value);
     }
   }
@@ -84,8 +88,10 @@ export const ModelAlias = Object.freeze({
   ZAI_GLM_4_5_AIR: "zai:glm-4-5-air",
   ZAI_GLM_4_5_AIR_X: "zai:glm-4-5-air-x",
   // Alibaba (Qwen via DashScope, international/Singapore deployment)
-  ALIBABA_QWEN3_MAX: "alibaba:qwen3-max",
+  ALIBABA_QWEN3_6_MAX_PREVIEW: "alibaba:qwen3.6-max-preview",
   ALIBABA_QWEN3_6_PLUS: "alibaba:qwen3.6-plus",
+  ALIBABA_QWEN3_6_FLASH: "alibaba:qwen3.6-flash",
+  ALIBABA_QWEN3_MAX: "alibaba:qwen3-max",
   ALIBABA_QWEN3_5_PLUS: "alibaba:qwen3.5-plus",
   ALIBABA_QWEN3_5_FLASH: "alibaba:qwen3.5-flash",
   ALIBABA_QWEN_PLUS: "alibaba:qwen-plus",
@@ -342,11 +348,11 @@ const MODEL_CONFIG_RAW: Record<ModelAliasKey, ModelConfigEntry> = {
     tokenCostOutPerMillion: 4.5,
   },
   // Alibaba (Qwen via DashScope, international/Singapore deployment, base tier)
-  "alibaba:qwen3-max": {
+  "alibaba:qwen3.6-max-preview": {
     provider: "alibaba",
-    model: "qwen3-max",
-    tokenCostInPerMillion: 1.2,
-    tokenCostOutPerMillion: 6,
+    model: "qwen3.6-max-preview",
+    tokenCostInPerMillion: 1.3,
+    tokenCostOutPerMillion: 7.8,
   },
   "alibaba:qwen3.6-plus": {
     provider: "alibaba",
@@ -354,6 +360,18 @@ const MODEL_CONFIG_RAW: Record<ModelAliasKey, ModelConfigEntry> = {
     tokenCostInPerMillion: 0.276,
     tokenCostOutPerMillion: 1.651,
   },
+  "alibaba:qwen3.6-flash": {
+    provider: "alibaba",
+    model: "qwen3.6-flash",
+    tokenCostInPerMillion: 0.025,
+    tokenCostOutPerMillion: 1.5,
+  },
+  "alibaba:qwen3-max": {
+    provider: "alibaba",
+    model: "qwen3-max",
+    tokenCostInPerMillion: 1.2,
+    tokenCostOutPerMillion: 6,
+  },
   "alibaba:qwen3.5-plus": {
     provider: "alibaba",
     model: "qwen3.5-plus",
@@ -399,7 +417,9 @@ const MODEL_CONFIG_RAW: Record<ModelAliasKey, ModelConfigEntry> = {
 };
 
 export const MODEL_CONFIG: Readonly<Record<ModelAliasKey, ModelConfigEntry>> =
-  deepFreeze(MODEL_CONFIG_RAW) as Readonly<Record<ModelAliasKey, ModelConfigEntry>>;
+  deepFreeze(MODEL_CONFIG_RAW) as Readonly<
+    Record<ModelAliasKey, ModelConfigEntry>
+  >;
 
 export const VALID_MODEL_ALIASES: ReadonlySet<ModelAliasKey> = new Set(
   Object.keys(MODEL_CONFIG) as ModelAliasKey[],
@@ -409,18 +429,24 @@ export const VALID_MODEL_ALIASES: ReadonlySet<ModelAliasKey> = new Set(
 
 export function aliasToFunctionName(alias: string): string {
   if (typeof alias !== "string") {
-    throw new Error(`Invalid model alias: expected string, got ${typeof alias}`);
+    throw new Error(
+      `Invalid model alias: expected string, got ${typeof alias}`,
+    );
   }
   if (!alias.includes(":")) {
     throw new Error(`Invalid model alias: "${alias}" does not contain a colon`);
   }
   const model = alias.split(":").slice(1).join(":");
-  return model.replace(/[-.]([a-z0-9])/gi, (_, char: string) => char.toUpperCase());
+  return model.replace(/[-.]([a-z0-9])/gi, (_, char: string) =>
+    char.toUpperCase(),
+  );
 }
 
 export function getProviderFromAlias(alias: string): ProviderName {
   if (typeof alias !== "string") {
-    throw new Error(`Invalid model alias: expected string, got ${typeof alias}`);
+    throw new Error(
+      `Invalid model alias: expected string, got ${typeof alias}`,
+    );
   }
   if (!alias.includes(":")) {
     throw new Error(`Invalid model alias: "${alias}" does not contain a colon`);
@@ -430,7 +456,9 @@ export function getProviderFromAlias(alias: string): ProviderName {
 
 export function getModelFromAlias(alias: string): string {
   if (typeof alias !== "string") {
-    throw new Error(`Invalid model alias: expected string, got ${typeof alias}`);
+    throw new Error(
+      `Invalid model alias: expected string, got ${typeof alias}`,
+    );
   }
   if (!alias.includes(":")) {
     throw new Error(`Invalid model alias: "${alias}" does not contain a colon`);
@@ -439,33 +467,38 @@ export function getModelFromAlias(alias: string): string {
 }
 
 export function getModelConfig(alias: string): ModelConfigEntry | null {
-  return (MODEL_CONFIG as Record<string, ModelConfigEntry | undefined>)[alias] ?? null;
+  return (
+    (MODEL_CONFIG as Record<string, ModelConfigEntry | undefined>)[alias] ??
+    null
+  );
 }
 
 // ─── Default Model By Provider ───────────────────────────────────────────────
 
-export const DEFAULT_MODEL_BY_PROVIDER: Readonly<Record<ProviderName, ModelAliasKey>> =
-  Object.freeze({
-    openai: "openai:gpt-5.4",
-    anthropic: "anthropic:sonnet-4-6",
-    gemini: "gemini:flash-2.5",
-    deepseek: "deepseek:v4-flash",
-    moonshot: "moonshot:kimi-k2.6",
-    "claude-code": "claude-code:sonnet",
-    zai: "zai:glm-5-1",
-    alibaba: "alibaba:qwen3-max",
-  } as const);
+export const DEFAULT_MODEL_BY_PROVIDER: Readonly<
+  Record<ProviderName, ModelAliasKey>
+> = Object.freeze({
+  openai: "openai:gpt-5.4",
+  anthropic: "anthropic:sonnet-4-6",
+  gemini: "gemini:flash-2.5",
+  deepseek: "deepseek:v4-flash",
+  moonshot: "moonshot:kimi-k2.6",
+  "claude-code": "claude-code:sonnet",
+  zai: "zai:glm-5-1",
+  alibaba: "alibaba:qwen3-max",
+} as const);
 
 // ─── Function Name Derived Index ─────────────────────────────────────────────
 
-export const FUNCTION_NAME_BY_ALIAS: Readonly<Record<ModelAliasKey, string>> = Object.freeze(
-  Object.fromEntries(
-    (Object.keys(MODEL_CONFIG) as ModelAliasKey[]).map((alias) => [
-      alias,
-      aliasToFunctionName(alias),
-    ]),
-  ) as Record<ModelAliasKey, string>,
-);
+export const FUNCTION_NAME_BY_ALIAS: Readonly<Record<ModelAliasKey, string>> =
+  Object.freeze(
+    Object.fromEntries(
+      (Object.keys(MODEL_CONFIG) as ModelAliasKey[]).map((alias) => [
+        alias,
+        aliasToFunctionName(alias),
+      ]),
+    ) as Record<ModelAliasKey, string>,
+  );
 
 // ─── Provider Functions Index ────────────────────────────────────────────────
 
@@ -487,7 +520,13 @@ export function buildProviderFunctionsIndex(): ProviderFunctionsIndex {
       index[provider] = [];
     }
     index[provider]!.push(
-      Object.freeze({ alias, provider, model, functionName, fullPath }) as ProviderFunctionEntry,
+      Object.freeze({
+        alias,
+        provider,
+        model,
+        functionName,
+        fullPath,
+      }) as ProviderFunctionEntry,
     );
   }
 
@@ -499,7 +538,8 @@ export function buildProviderFunctionsIndex(): ProviderFunctionsIndex {
   return Object.freeze(index) as ProviderFunctionsIndex;
 }
 
-export const PROVIDER_FUNCTIONS: ProviderFunctionsIndex = buildProviderFunctionsIndex();
+export const PROVIDER_FUNCTIONS: ProviderFunctionsIndex =
+  buildProviderFunctionsIndex();
 
 // ─── Module-Load Invariant Validation ────────────────────────────────────────
 
@@ -546,13 +586,19 @@ export function validateModelRegistry(
     }
 
     // Check non-negative token costs
-    if (typeof entry.tokenCostInPerMillion !== "number" || entry.tokenCostInPerMillion < 0) {
+    if (
+      typeof entry.tokenCostInPerMillion !== "number" ||
+      entry.tokenCostInPerMillion < 0
+    ) {
       throw new Error(
         `Model config invariant violation: alias "${alias}" has invalid tokenCostInPerMillion: ` +
           `${entry.tokenCostInPerMillion}`,
       );
     }
-    if (typeof entry.tokenCostOutPerMillion !== "number" || entry.tokenCostOutPerMillion < 0) {
+    if (
+      typeof entry.tokenCostOutPerMillion !== "number" ||
+      entry.tokenCostOutPerMillion < 0
+    ) {
       throw new Error(
         `Model config invariant violation: alias "${alias}" has invalid tokenCostOutPerMillion: ` +
           `${entry.tokenCostOutPerMillion}`,

package/src/config/paths.ts

@@ -8,25 +8,30 @@ export interface PipelinePaths {
   readonly rejected: string;
 }
 
+export function getPipelineDataDir(baseDir: string): string {
+  return join(baseDir, "pipeline-data");
+}
+
 export function resolvePipelinePaths(baseDir: string): PipelinePaths {
+  const dataDir = getPipelineDataDir(baseDir);
   return {
-    pending: join(baseDir, "pipeline-data", "pending"),
-    current: join(baseDir, "pipeline-data", "current"),
-    complete: join(baseDir, "pipeline-data", "complete"),
-    rejected: join(baseDir, "pipeline-data", "rejected"),
+    pending: join(dataDir, "pending"),
+    current: join(dataDir, "current"),
+    complete: join(dataDir, "complete"),
+    rejected: join(dataDir, "rejected"),
   };
 }
 
 export function getPendingSeedPath(baseDir: string, jobId: string): string {
-  return join(baseDir, "pipeline-data", "pending", `${jobId}-seed.json`);
+  return join(getPipelineDataDir(baseDir), "pending", `${jobId}-seed.json`);
 }
 
 export function getCurrentSeedPath(baseDir: string, jobId: string): string {
-  return join(baseDir, "pipeline-data", "current", jobId, "seed.json");
+  return join(getPipelineDataDir(baseDir), "current", jobId, "seed.json");
 }
 
 export function getCompleteSeedPath(baseDir: string, jobId: string): string {
-  return join(baseDir, "pipeline-data", "complete", jobId, "seed.json");
+  return join(getPipelineDataDir(baseDir), "complete", jobId, "seed.json");
 }
 
 export function getJobDirectoryPath(
@@ -34,7 +39,7 @@ export function getJobDirectoryPath(
   jobId: string,
   location: JobLocationValue,
 ): string {
-  return join(baseDir, "pipeline-data", location, jobId);
+  return join(getPipelineDataDir(baseDir), location, jobId);
 }
 
 export function getJobMetadataPath(

package/src/core/__tests__/config.test.ts

@@ -1,5 +1,6 @@
 import { describe, test, expect, afterEach } from "bun:test";
 import { defaultConfig, resetConfig, loadConfig, getConfig, getConfigValue, getPipelineConfig } from "../config";
+import type { AppConfig } from "../config";
 import { mkdtemp, writeFile, mkdir, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
@@ -71,6 +72,126 @@ describe("defaultConfig", () => {
     expect(defaultConfig.ui.port).toBe(3000);
     expect(defaultConfig.taskRunner.maxRefinementAttempts).toBeGreaterThan(0);
   });
+
+  test("taskRunner.maxAttempts defaults to 3", () => {
+    expect(defaultConfig.taskRunner.maxAttempts).toBe(3);
+  });
+
+  test("orchestrator.maxConcurrentJobs defaults to 3", () => {
+    expect(defaultConfig.orchestrator.maxConcurrentJobs).toBe(3);
+  });
+});
+
+describe("validateConfig (via loadConfig)", () => {
+  afterEach(() => {
+    resetConfig();
+  });
+
+  test("throws when taskRunner.maxAttempts is 0", async () => {
+    const dir = await mkdtemp(join(tmpdir(), "config-test-"));
+    const configDir = join(dir, "pipeline-config", "test");
+    const tasksDir = join(configDir, "tasks");
+    await mkdir(tasksDir, { recursive: true });
+    await writeFile(join(configDir, "pipeline.json"), JSON.stringify({ name: "test", tasks: ["t1"] }));
+    await writeFile(join(dir, "pipeline-config", "registry.json"), JSON.stringify({
+      pipelines: { test: { configDir, tasksDir } }
+    }));
+    const overrideFile = join(dir, "config.json");
+    await writeFile(overrideFile, JSON.stringify({ taskRunner: { maxAttempts: 0 } }));
+    const origRoot = process.env.PO_ROOT;
+    process.env.PO_ROOT = dir;
+    try {
+      await expect(loadConfig({ configPath: overrideFile })).rejects.toThrow("taskRunner.maxAttempts must be an integer >= 1");
+    } finally {
+      if (origRoot) process.env.PO_ROOT = origRoot; else delete process.env.PO_ROOT;
+      await rm(dir, { recursive: true });
+    }
+  });
+
+  test("throws when taskRunner.maxAttempts is non-integer", async () => {
+    const dir = await mkdtemp(join(tmpdir(), "config-test-"));
+    const configDir = join(dir, "pipeline-config", "test");
+    const tasksDir = join(configDir, "tasks");
+    await mkdir(tasksDir, { recursive: true });
+    await writeFile(join(configDir, "pipeline.json"), JSON.stringify({ name: "test", tasks: ["t1"] }));
+    await writeFile(join(dir, "pipeline-config", "registry.json"), JSON.stringify({
+      pipelines: { test: { configDir, tasksDir } }
+    }));
+    const overrideFile = join(dir, "config.json");
+    await writeFile(overrideFile, JSON.stringify({ taskRunner: { maxAttempts: 2.5 } }));
+    const origRoot = process.env.PO_ROOT;
+    process.env.PO_ROOT = dir;
+    try {
+      await expect(loadConfig({ configPath: overrideFile })).rejects.toThrow("taskRunner.maxAttempts must be an integer >= 1");
+    } finally {
+      if (origRoot) process.env.PO_ROOT = origRoot; else delete process.env.PO_ROOT;
+      await rm(dir, { recursive: true });
+    }
+  });
+});
+
+describe("PO_TASK_MAX_ATTEMPTS env override", () => {
+  afterEach(() => {
+    delete process.env.PO_TASK_MAX_ATTEMPTS;
+    resetConfig();
+  });
+
+  test("getConfig reads PO_TASK_MAX_ATTEMPTS into taskRunner.maxAttempts", () => {
+    process.env.PO_TASK_MAX_ATTEMPTS = "5";
+    resetConfig();
+    const config: AppConfig = getConfig();
+    expect(config.taskRunner.maxAttempts).toBe(5);
+  });
+
+  test("getConfig rejects non-numeric PO_TASK_MAX_ATTEMPTS values", () => {
+    process.env.PO_TASK_MAX_ATTEMPTS = "abc";
+    resetConfig();
+    expect(() => getConfig()).toThrow("PO_TASK_MAX_ATTEMPTS must be an integer >= 1");
+  });
+
+  test("getConfig rejects non-integer PO_TASK_MAX_ATTEMPTS values", () => {
+    process.env.PO_TASK_MAX_ATTEMPTS = "2.5";
+    resetConfig();
+    expect(() => getConfig()).toThrow("PO_TASK_MAX_ATTEMPTS must be an integer >= 1");
+  });
+});
+
+describe("PO_MAX_RUNNING_JOBS env override", () => {
+  afterEach(() => {
+    delete process.env.PO_MAX_RUNNING_JOBS;
+    resetConfig();
+  });
+
+  test("getConfig reads PO_MAX_RUNNING_JOBS into orchestrator.maxConcurrentJobs", () => {
+    process.env.PO_MAX_RUNNING_JOBS = "7";
+    resetConfig();
+    const config: AppConfig = getConfig();
+    expect(config.orchestrator.maxConcurrentJobs).toBe(7);
+  });
+
+  test("getConfig rejects PO_MAX_RUNNING_JOBS=0", () => {
+    process.env.PO_MAX_RUNNING_JOBS = "0";
+    resetConfig();
+    expect(() => getConfig()).toThrow("orchestrator.maxConcurrentJobs");
+  });
+
+  test("getConfig rejects negative PO_MAX_RUNNING_JOBS", () => {
+    process.env.PO_MAX_RUNNING_JOBS = "-1";
+    resetConfig();
+    expect(() => getConfig()).toThrow("orchestrator.maxConcurrentJobs");
+  });
+
+  test("getConfig rejects non-integer PO_MAX_RUNNING_JOBS", () => {
+    process.env.PO_MAX_RUNNING_JOBS = "1.5";
+    resetConfig();
+    expect(() => getConfig()).toThrow("orchestrator.maxConcurrentJobs");
+  });
+
+  test("getConfig rejects non-numeric PO_MAX_RUNNING_JOBS", () => {
+    process.env.PO_MAX_RUNNING_JOBS = "abc";
+    resetConfig();
+    expect(() => getConfig()).toThrow("orchestrator.maxConcurrentJobs");
+  });
 });
 
 describe("getConfig", () => {