@ryanfw/prompt-orchestration-pipeline 1.0.5 → 1.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ryanfw/prompt-orchestration-pipeline",
-  "version": "1.0.5",
+  "version": "1.1.0",
   "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

@@ -1,4 +1,4 @@
-import { describe, it, expect } from "bun:test";
+import { describe, it, expect } from "vitest";
 import {
   ModelAlias,
   MODEL_CONFIG,
@@ -15,8 +15,8 @@ import {
 } from "../models";
 import type { ModelConfigEntry } from "../models";
 
-const MODEL_COUNT = 35;
-const PROVIDER_COUNT = 7;
+const MODEL_COUNT = 42;
+const PROVIDER_COUNT = 8;
 
 describe("ModelAlias", () => {
   it(`has exactly ${MODEL_COUNT} entries`, () => {
@@ -91,7 +91,7 @@ describe("VALID_MODEL_ALIASES", () => {
 
 describe("DEFAULT_MODEL_BY_PROVIDER", () => {
   it(`has entries for all ${PROVIDER_COUNT} providers`, () => {
-    const providers = ["openai", "anthropic", "gemini", "deepseek", "moonshot", "claude-code", "zai"];
+    const providers = ["openai", "anthropic", "gemini", "deepseek", "moonshot", "claude-code", "zai", "alibaba"];
     expect(Object.keys(DEFAULT_MODEL_BY_PROVIDER).length).toBe(PROVIDER_COUNT);
     for (const provider of providers) {
       expect(provider in DEFAULT_MODEL_BY_PROVIDER).toBe(true);
@@ -203,7 +203,7 @@ describe("FUNCTION_NAME_BY_ALIAS", () => {
 
 describe("PROVIDER_FUNCTIONS", () => {
   it(`has entries for all ${PROVIDER_COUNT} providers`, () => {
-    const providers = ["openai", "anthropic", "gemini", "deepseek", "moonshot", "claude-code", "zai"];
+    const providers = ["openai", "anthropic", "gemini", "deepseek", "moonshot", "claude-code", "zai", "alibaba"];
     for (const provider of providers) {
       expect(provider in PROVIDER_FUNCTIONS).toBe(true);
     }

package/src/config/models.ts

@@ -5,7 +5,8 @@ export type ProviderName =
   | "deepseek"
   | "moonshot"
   | "claude-code"
-  | "zai";
+  | "zai"
+  | "alibaba";
 
 export interface ModelConfigEntry {
   readonly provider: ProviderName;
@@ -79,6 +80,14 @@ export const ModelAlias = Object.freeze({
   ZAI_GLM_4_LONG: "zai:glm-4-long",
   ZAI_GLM_Z1_FLASH: "zai:glm-z1-flash",
   ZAI_GLM_Z1_AIR: "zai:glm-z1-air",
+  // Alibaba (Qwen via DashScope)
+  ALIBABA_QWEN3_MAX: "alibaba:qwen3-max",
+  ALIBABA_QWEN3_5_PLUS: "alibaba:qwen3.5-plus",
+  ALIBABA_QWEN_PLUS: "alibaba:qwen-plus",
+  ALIBABA_QWEN_FLASH: "alibaba:qwen-flash",
+  ALIBABA_QWQ_PLUS: "alibaba:qwq-plus",
+  ALIBABA_QWEN3_CODER_PLUS: "alibaba:qwen3-coder-plus",
+  ALIBABA_QWEN3_CODER_FLASH: "alibaba:qwen3-coder-flash",
 } as const);
 
 export type ModelAliasKey = (typeof ModelAlias)[keyof typeof ModelAlias];
@@ -304,6 +313,49 @@ const MODEL_CONFIG_RAW: Record<ModelAliasKey, ModelConfigEntry> = {
     tokenCostInPerMillion: 0.1,
     tokenCostOutPerMillion: 0.4,
   },
+  // Alibaba (Qwen via DashScope)
+  "alibaba:qwen3-max": {
+    provider: "alibaba",
+    model: "qwen3-max",
+    tokenCostInPerMillion: 0.359,
+    tokenCostOutPerMillion: 1.434,
+  },
+  "alibaba:qwen3.5-plus": {
+    provider: "alibaba",
+    model: "qwen3.5-plus",
+    tokenCostInPerMillion: 0.115,
+    tokenCostOutPerMillion: 0.688,
+  },
+  "alibaba:qwen-plus": {
+    provider: "alibaba",
+    model: "qwen-plus",
+    tokenCostInPerMillion: 0.115,
+    tokenCostOutPerMillion: 0.287,
+  },
+  "alibaba:qwen-flash": {
+    provider: "alibaba",
+    model: "qwen-flash",
+    tokenCostInPerMillion: 0.022,
+    tokenCostOutPerMillion: 0.216,
+  },
+  "alibaba:qwq-plus": {
+    provider: "alibaba",
+    model: "qwq-plus",
+    tokenCostInPerMillion: 0.8,
+    tokenCostOutPerMillion: 2.4,
+  },
+  "alibaba:qwen3-coder-plus": {
+    provider: "alibaba",
+    model: "qwen3-coder-plus",
+    tokenCostInPerMillion: 0.115, // nearest-family qwen-plus
+    tokenCostOutPerMillion: 0.287, // nearest-family qwen-plus
+  },
+  "alibaba:qwen3-coder-flash": {
+    provider: "alibaba",
+    model: "qwen3-coder-flash",
+    tokenCostInPerMillion: 0.022, // nearest-family qwen-flash
+    tokenCostOutPerMillion: 0.216, // nearest-family qwen-flash
+  },
 };
 
 export const MODEL_CONFIG: Readonly<Record<ModelAliasKey, ModelConfigEntry>> =
@@ -361,6 +413,7 @@ export const DEFAULT_MODEL_BY_PROVIDER: Readonly<Record<ProviderName, ModelAlias
     moonshot: "moonshot:kimi-k2.5",
     "claude-code": "claude-code:sonnet",
     zai: "zai:glm-4-plus",
+    alibaba: "alibaba:qwen3-max",
   } as const);
 
 // ─── Function Name Derived Index ─────────────────────────────────────────────

package/src/core/logger.ts

@@ -66,11 +66,20 @@ export function createLogger(componentName: string, context?: LogContext): Logge
     }
   }
 
+  function stringify(data: unknown): string {
+    if (typeof data === "string") return data;
+    try {
+      return JSON.stringify(data);
+    } catch {
+      return String(data);
+    }
+  }
+
   return {
     debug(message, data) {
       if (process.env["NODE_ENV"] === "production" && !process.env["DEBUG"]) return;
       if (data !== undefined) {
-        console.debug(prefix, message, data);
+        console.debug(prefix, message, stringify(data));
       } else {
         console.debug(prefix, message);
       }
@@ -78,7 +87,7 @@ export function createLogger(componentName: string, context?: LogContext): Logge
 
     log(message, data) {
       if (data !== undefined) {
-        console.log(prefix, message, data);
+        console.log(prefix, message, stringify(data));
       } else {
         console.log(prefix, message);
       }
@@ -86,7 +95,7 @@ export function createLogger(componentName: string, context?: LogContext): Logge
 
     warn(message, data) {
       if (data !== undefined) {
-        console.warn(prefix, message, data);
+        console.warn(prefix, message, stringify(data));
       } else {
         console.warn(prefix, message);
       }
@@ -95,7 +104,7 @@ export function createLogger(componentName: string, context?: LogContext): Logge
     error(message, data) {
       const enriched = data !== undefined ? formatData(data) : undefined;
       if (enriched !== undefined) {
-        console.error(prefix, message, enriched);
+        console.error(prefix, message, stringify(enriched));
       } else {
         console.error(prefix, message);
       }
@@ -103,7 +112,7 @@ export function createLogger(componentName: string, context?: LogContext): Logge
 
     group(label, data) {
       if (data !== undefined) {
-        console.group(prefix, label, data);
+        console.group(prefix, label, stringify(data));
       } else {
         console.group(prefix, label);
       }
@@ -114,7 +123,7 @@ export function createLogger(componentName: string, context?: LogContext): Logge
     },
 
     sse(eventType, eventData) {
-      console.log(prefix, `[SSE:${eventType}]`, eventData);
+      console.log(prefix, `[SSE:${eventType}]`, stringify(eventData));
       void getSSERegistry().then((registry) => {
         if (!registry) return;
         try {

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

@@ -477,6 +477,7 @@ describe("LLM Gateway", () => {
       delete process.env["ZAI_API_KEY"];
       delete process.env["ZHIPU_API_KEY"];
       delete process.env["MOONSHOT_API_KEY"];
+      delete process.env["ALIBABA_API_KEY"];
 
       const availability = getAvailableProviders();
 
@@ -487,12 +488,14 @@ describe("LLM Gateway", () => {
       expect(availability.zai).toBe(false);
       expect(availability.zhipu).toBe(false);
       expect(availability.moonshot).toBe(false);
+      expect(availability.alibaba).toBe(false);
     });
 
     it("returns true for providers with API keys set", () => {
       process.env["OPENAI_API_KEY"] = "test";
       process.env["ANTHROPIC_API_KEY"] = "test";
       process.env["ZAI_API_KEY"] = "test";
+      process.env["ALIBABA_API_KEY"] = "test";
 
       const availability = getAvailableProviders();
 
@@ -500,6 +503,7 @@ describe("LLM Gateway", () => {
       expect(availability.anthropic).toBe(true);
       expect(availability.zai).toBe(true);
       expect(availability.zhipu).toBe(true);
+      expect(availability.alibaba).toBe(true);
     });
 
     it("reports mock as available when provider is registered", () => {
@@ -507,6 +511,14 @@ describe("LLM Gateway", () => {
       const availability = getAvailableProviders();
       expect(availability.mock).toBe(true);
     });
+
+    it("dispatches to alibaba adapter without unknown-provider error", async () => {
+      // Verify the callAdapter dispatch path resolves for provider "alibaba".
+      // The call will fail (no real API key), but NOT with "Unknown provider".
+      await expect(
+        chat({ provider: "alibaba", messages: baseMessages }),
+      ).rejects.not.toThrow(/unknown provider/i);
+    });
   });
 
   // ── JSON Format Inference ──────────────────────────────────────────────

package/src/llm/index.ts

@@ -8,6 +8,7 @@ import { anthropicChat } from "../providers/anthropic.ts";
 import { openaiChat } from "../providers/openai.ts";
 import { geminiChat } from "../providers/gemini.ts";
 import { deepseekChat } from "../providers/deepseek.ts";
+import { alibabaChat } from "../providers/alibaba.ts";
 import { moonshotChat } from "../providers/moonshot.ts";
 import { zaiChat } from "../providers/zhipu.ts";
 import { claudeCodeChat, isClaudeCodeAvailable } from "../providers/claude-code.ts";
@@ -68,6 +69,7 @@ const JSON_INFER_PROVIDERS = new Set<ProviderName>([
   "deepseek",
   "gemini",
   "moonshot",
+  "alibaba",
 ]);
 
 function inferJsonFormat(options: ChatOptions): ChatOptions {
@@ -93,6 +95,12 @@ async function callAdapter(
   const { provider, messages, model, temperature, maxTokens, responseFormat, topP, stop, maxRetries } = options;
 
   switch (provider) {
+    case "alibaba":
+      return alibabaChat({
+        messages, model, temperature, maxTokens, responseFormat, topP, stop, maxRetries,
+        frequencyPenalty: options.frequencyPenalty,
+        presencePenalty: options.presencePenalty,
+      });
     case "anthropic":
       return anthropicChat({ messages, model, temperature, maxTokens, responseFormat, topP, stop, maxRetries });
     case "openai":
@@ -435,6 +443,7 @@ 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"],

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

@@ -0,0 +1,186 @@
+import { describe, expect, it, vi, beforeEach, afterEach } from "vitest";
+import { alibabaChat } from "../alibaba.ts";
+import { ProviderJsonParseError } from "../types.ts";
+import type { AlibabaOptions } from "../types.ts";
+import type { Mock } from "vitest";
+
+function makeAlibabaResponse(
+  content: string,
+  promptTokens = 10,
+  completionTokens = 20,
+) {
+  return {
+    choices: [{ message: { content } }],
+    usage: {
+      prompt_tokens: promptTokens,
+      completion_tokens: completionTokens,
+      total_tokens: promptTokens + completionTokens,
+    },
+  };
+}
+
+function mockFetchResponse(body: unknown, status = 200) {
+  return {
+    ok: status >= 200 && status < 300,
+    status,
+    json: vi.fn().mockResolvedValue(body),
+    text: vi.fn().mockResolvedValue(JSON.stringify(body)),
+  } as unknown as Response;
+}
+
+const baseOptions: AlibabaOptions = {
+  messages: [
+    { role: "system", content: "You are helpful." },
+    { role: "user", content: "Return JSON." },
+  ],
+  responseFormat: "json_object",
+};
+
+describe("alibabaChat", () => {
+  let originalFetch: typeof globalThis.fetch;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  let fetchMock: Mock<(...args: any[]) => any>;
+
+  beforeEach(() => {
+    originalFetch = globalThis.fetch;
+    fetchMock = vi.fn();
+    globalThis.fetch = fetchMock as unknown as typeof fetch;
+    process.env["ALIBABA_API_KEY"] = "test-key";
+  });
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch;
+    delete process.env["ALIBABA_API_KEY"];
+    delete process.env["ALIBABA_BASE_URL"];
+  });
+
+  it("returns parsed JSON content with usage on success", async () => {
+    const jsonPayload = { result: "success", count: 42 };
+    fetchMock.mockResolvedValue(
+      mockFetchResponse(
+        makeAlibabaResponse(JSON.stringify(jsonPayload), 15, 25),
+      ),
+    );
+
+    const result = await alibabaChat(baseOptions);
+
+    expect(result.content).toEqual(jsonPayload);
+    expect(result.usage).toEqual({
+      prompt_tokens: 15,
+      completion_tokens: 25,
+      total_tokens: 40,
+    });
+    expect(result.raw).toBeDefined();
+  });
+
+  it("throws ProviderJsonParseError on invalid JSON when responseFormat is json_object", async () => {
+    const nonJsonText = "This is plain text, not JSON at all.";
+    fetchMock.mockResolvedValue(
+      mockFetchResponse(makeAlibabaResponse(nonJsonText)),
+    );
+
+    try {
+      await alibabaChat(baseOptions);
+      expect.unreachable("should have thrown");
+    } catch (err) {
+      expect(err).toBeInstanceOf(ProviderJsonParseError);
+      const parseErr = err as ProviderJsonParseError;
+      expect(parseErr.provider).toBe("alibaba");
+      expect(parseErr.model).toBe("qwen-plus");
+      expect(parseErr.sample).toBeTruthy();
+    }
+  });
+
+  it("retries on HTTP 500 with exponential backoff", async () => {
+    const jsonPayload = { retried: true };
+    fetchMock
+      .mockResolvedValueOnce(
+        mockFetchResponse({ error: { message: "Server error" } }, 500),
+      )
+      .mockResolvedValueOnce(
+        mockFetchResponse({ error: { message: "Server error" } }, 500),
+      )
+      .mockResolvedValueOnce(
+        mockFetchResponse(
+          makeAlibabaResponse(JSON.stringify(jsonPayload)),
+        ),
+      );
+
+    const result = await alibabaChat({ ...baseOptions, maxRetries: 3 });
+
+    expect(fetchMock).toHaveBeenCalledTimes(3);
+    expect(result.content).toEqual(jsonPayload);
+  });
+
+  it("does NOT retry on HTTP 401", async () => {
+    fetchMock.mockResolvedValue(
+      mockFetchResponse({ error: { message: "Unauthorized" } }, 401),
+    );
+
+    await expect(
+      alibabaChat({ ...baseOptions, maxRetries: 3 }),
+    ).rejects.toMatchObject({ status: 401, message: "Unauthorized" });
+
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+  });
+
+  it("uses ALIBABA_BASE_URL env var when set", async () => {
+    process.env["ALIBABA_BASE_URL"] = "https://custom.api.example.com";
+    const jsonPayload = { ok: true };
+    fetchMock.mockResolvedValue(
+      mockFetchResponse(makeAlibabaResponse(JSON.stringify(jsonPayload))),
+    );
+
+    await alibabaChat(baseOptions);
+
+    const [url] = fetchMock.mock.calls[0] as [string, RequestInit];
+    expect(url).toBe(
+      "https://custom.api.example.com/chat/completions",
+    );
+  });
+
+  it("passes frequencyPenalty and presencePenalty in request body", async () => {
+    const jsonPayload = { ok: true };
+    fetchMock.mockResolvedValue(
+      mockFetchResponse(makeAlibabaResponse(JSON.stringify(jsonPayload))),
+    );
+
+    await alibabaChat({
+      ...baseOptions,
+      frequencyPenalty: 0.5,
+      presencePenalty: 0.2,
+    });
+
+    const body = JSON.parse(
+      (fetchMock.mock.calls[0] as [string, RequestInit])[1].body as string,
+    );
+    expect(body.frequency_penalty).toBe(0.5);
+    expect(body.presence_penalty).toBe(0.2);
+  });
+
+  it("sends enable_thinking true by default", async () => {
+    fetchMock.mockResolvedValue(
+      mockFetchResponse(makeAlibabaResponse(JSON.stringify({ ok: true }))),
+    );
+
+    await alibabaChat(baseOptions);
+
+    const body = JSON.parse(
+      (fetchMock.mock.calls[0] as [string, RequestInit])[1].body as string,
+    );
+    expect(body.enable_thinking).toBe(true);
+  });
+
+  it("sends enable_thinking false when thinking is disabled", async () => {
+    fetchMock.mockResolvedValue(
+      mockFetchResponse(makeAlibabaResponse(JSON.stringify({ ok: true }))),
+    );
+
+    await alibabaChat({ ...baseOptions, thinking: "disabled" });
+
+    const body = JSON.parse(
+      (fetchMock.mock.calls[0] as [string, RequestInit])[1].body as string,
+    );
+    expect(body.enable_thinking).toBe(false);
+  });
+});

package/src/providers/alibaba.ts

@@ -0,0 +1,193 @@
+// ── src/providers/alibaba.ts ──
+// Alibaba (DashScope) adapter using OpenAI-compatible chat completions API.
+
+import {
+  extractMessages,
+  ensureMessagesPresent,
+  ensureJsonResponseFormat,
+  isRetryableError,
+  sleep,
+  stripMarkdownFences,
+  tryParseJSON,
+  createProviderError,
+} from "./base.ts";
+import { ProviderJsonParseError } from "./types.ts";
+import type {
+  AlibabaOptions,
+  AdapterResponse,
+  ResponseFormatObject,
+} from "./types.ts";
+
+const DEFAULT_MODEL = "qwen-plus";
+const DEFAULT_TEMPERATURE = 0.7;
+const DEFAULT_THINKING: "enabled" | "disabled" = "enabled";
+const DEFAULT_MAX_RETRIES = 3;
+
+/**
+ * Determines whether the response format indicates JSON mode.
+ * Returns true for "json", "json_object", { type: "json_object" }, { json_schema: ... }.
+ */
+function isJsonMode(
+  responseFormat: string | ResponseFormatObject | undefined,
+): boolean {
+  if (!responseFormat) return false;
+  if (typeof responseFormat === "string") {
+    return responseFormat === "json" || responseFormat === "json_object";
+  }
+  return (
+    responseFormat.type === "json_object" ||
+    responseFormat.json_schema != null
+  );
+}
+
+export async function alibabaChat(
+  options: AlibabaOptions,
+): Promise<AdapterResponse> {
+  const {
+    messages,
+    model = DEFAULT_MODEL,
+    temperature = DEFAULT_TEMPERATURE,
+    maxTokens,
+    responseFormat,
+    topP,
+    stop,
+    maxRetries = DEFAULT_MAX_RETRIES,
+    frequencyPenalty,
+    presencePenalty,
+    thinking = DEFAULT_THINKING,
+  } = options;
+
+  ensureMessagesPresent(messages, "alibaba");
+
+  const jsonMode = isJsonMode(responseFormat);
+
+  const { systemMsg, userMessages, assistantMessages } =
+    extractMessages(messages);
+
+  // Build the messages array in conversation order
+  const apiMessages: Array<{ role: string; content: string }> = [];
+  if (systemMsg) {
+    apiMessages.push({ role: "system", content: systemMsg });
+  }
+
+  const nonSystemMessages = [...userMessages, ...assistantMessages].sort(
+    (a, b) => {
+      const aIdx = messages.indexOf(a);
+      const bIdx = messages.indexOf(b);
+      return aIdx - bIdx;
+    },
+  );
+  for (const m of nonSystemMessages) {
+    apiMessages.push({ role: m.role, content: m.content });
+  }
+
+  const apiKey = process.env["ALIBABA_API_KEY"];
+
+  const endpoint = `${process.env["ALIBABA_BASE_URL"] ?? "https://dashscope-us.aliyuncs.com/compatible-mode/v1"}/chat/completions`;
+
+  const body: Record<string, unknown> = {
+    model,
+    messages: apiMessages,
+    temperature,
+  };
+
+  if (maxTokens != null) body["max_tokens"] = maxTokens;
+  if (topP != null) body["top_p"] = topP;
+  if (stop != null) body["stop"] = stop;
+  if (frequencyPenalty != null) body["frequency_penalty"] = frequencyPenalty;
+  if (presencePenalty != null) body["presence_penalty"] = presencePenalty;
+  body["enable_thinking"] = thinking === "enabled";
+
+  if (jsonMode) {
+    ensureJsonResponseFormat(responseFormat, "alibaba");
+    body["response_format"] = { type: "json_object" };
+  }
+
+  let lastError: unknown;
+
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      const response = await fetch(endpoint, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${apiKey ?? ""}`,
+        },
+        body: JSON.stringify(body),
+      });
+
+      if (!response.ok) {
+        let errorBody: unknown;
+        try {
+          errorBody = await response.json();
+        } catch {
+          errorBody = await response.text();
+        }
+
+        const err = createProviderError(
+          response.status,
+          errorBody,
+          `Alibaba API error: ${response.status}`,
+        );
+
+        // 401 is never retried
+        if (response.status === 401) {
+          throw err;
+        }
+
+        throw err;
+      }
+
+      const data = (await response.json()) as {
+        choices: Array<{
+          message: { content: string };
+        }>;
+        usage?: {
+          prompt_tokens: number;
+          completion_tokens: number;
+          total_tokens: number;
+        };
+      };
+
+      const rawText = data.choices?.[0]?.message?.content ?? "";
+      const stripped = stripMarkdownFences(rawText);
+      const parsed = tryParseJSON(stripped);
+
+      // In JSON mode, if tryParseJSON returns a string, the response is unparseable
+      if (jsonMode && typeof parsed === "string") {
+        throw new ProviderJsonParseError(
+          "alibaba",
+          model,
+          parsed.slice(0, 200),
+        );
+      }
+
+      const usage = data.usage ?? {
+        prompt_tokens: 0,
+        completion_tokens: 0,
+        total_tokens: 0,
+      };
+
+      return {
+        content:
+          typeof parsed === "string"
+            ? parsed
+            : (parsed as Record<string, unknown>),
+        text: rawText,
+        usage,
+        raw: data,
+      };
+    } catch (err) {
+      lastError = err;
+
+      if (!isRetryableError(err) || attempt >= maxRetries) {
+        throw err;
+      }
+
+      // Exponential backoff: 2^attempt * 1000ms
+      await sleep(Math.pow(2, attempt) * 1000);
+    }
+  }
+
+  throw lastError;
+}

package/src/providers/types.ts

@@ -69,6 +69,7 @@ export type ProviderName =
   | "zhipu"
   | "claudecode"
   | "moonshot"
+  | "alibaba"
   | "mock";
 
 /** Options for the chat() gateway function. */
@@ -106,6 +107,13 @@ export interface DeepSeekOptions extends ProviderOptions {
   stream?: boolean;
 }
 
+/** Alibaba-specific options. */
+export interface AlibabaOptions extends ProviderOptions {
+  frequencyPenalty?: number;
+  presencePenalty?: number;
+  thinking?: "enabled" | "disabled";
+}
+
 /** Moonshot-specific options. */
 export interface MoonshotOptions {
   messages: ChatMessage[];
@@ -160,6 +168,7 @@ export interface ProviderAvailability {
   zhipu: boolean;
   claudecode: boolean;
   moonshot: boolean;
+  alibaba: boolean;
   mock: boolean;
 }
 

package/src/ui/server/endpoints/job-control-endpoints.ts

@@ -1,4 +1,4 @@
-import { mkdir, rename } from "node:fs/promises";
+import { mkdir, rename, unlink } from "node:fs/promises";
 import path from "node:path";
 
 import { createErrorResponse } from "../config-bridge";
@@ -6,7 +6,7 @@ import { Constants } from "../config-bridge-node";
 import { readJob } from "../job-reader";
 import { sendJson } from "../utils/http-utils";
 import { getJobDirectoryPath } from "../../../config/paths";
-import { readJobStatus, resetJobToCleanSlate, resetSingleTask } from "../../../core/status-writer";
+import { readJobStatus, resetJobToCleanSlate, resetSingleTask, writeJobStatus } from "../../../core/status-writer";
 
 const RUNNER_PATH = path.resolve(import.meta.dir, "../../../core/pipeline-runner.ts");
 
@@ -36,6 +36,55 @@ async function spawnDetached(args: string[], env?: Record<string, string | undef
   proc.unref();
 }
 
+async function readRunnerPid(jobDir: string): Promise<number | null> {
+  try {
+    const content = await Bun.file(path.join(jobDir, "runner.pid")).text();
+    const pid = parseInt(content.trim(), 10);
+    return Number.isNaN(pid) ? null : pid;
+  } catch {
+    return null;
+  }
+}
+
+async function killProcess(pid: number): Promise<{ killed: boolean; signal: string | null }> {
+  try {
+    process.kill(pid, 15); // SIGTERM
+  } catch (err: unknown) {
+    if ((err as NodeJS.ErrnoException).code === "ESRCH") {
+      return { killed: false, signal: null };
+    }
+    throw err;
+  }
+
+  // Do not hold the HTTP request open while waiting for shutdown.
+  const timer = setTimeout(() => {
+    try {
+      process.kill(pid, 0);
+    } catch {
+      return;
+    }
+
+    try {
+      process.kill(pid, 9); // SIGKILL
+    } catch (err: unknown) {
+      if ((err as NodeJS.ErrnoException).code !== "ESRCH") {
+        console.error(`[handleJobStop] Failed to SIGKILL pid ${pid}:`, err);
+      }
+    }
+  }, 1500);
+  timer.unref();
+
+  return { killed: true, signal: "SIGTERM" };
+}
+
+async function cleanupRunnerPid(jobDir: string): Promise<void> {
+  try {
+    await unlink(path.join(jobDir, "runner.pid"));
+  } catch (err: unknown) {
+    if ((err as NodeJS.ErrnoException).code !== "ENOENT") throw err;
+  }
+}
+
 export async function resolveJobLifecycle(dataDir: string, jobId: string): Promise<string | null> {
   const result = await readJob(jobId);
   if (!result.ok) return null;
@@ -168,7 +217,64 @@ export async function handleJobStop(
     if (!lifecycle) {
       return sendJson(404, createErrorResponse(Constants.ERROR_CODES.JOB_NOT_FOUND, `job "${jobId}" was not found`));
     }
-    return sendJson(202, { ok: true, jobId, action: "stop", lifecycle });
+
+    const jobDir = getJobDirectoryPath(dataDir, jobId, lifecycle as "current" | "complete");
+
+    // Kill the runner process via PID file
+    let pidFound = false;
+    let usedSignal: string | null = null;
+
+    const pid = await readRunnerPid(jobDir);
+    if (pid !== null) {
+      pidFound = true;
+      try {
+        const result = await killProcess(pid);
+        usedSignal = result.signal;
+      } catch (err) {
+        console.error(`[handleJobStop] Error killing pid ${pid} for job ${jobId}:`, err);
+      }
+      await cleanupRunnerPid(jobDir);
+    }
+
+    let resetTask: string | null = null;
+
+    // Reset running task and clear root-level fields in a single atomic write.
+    await writeJobStatus(jobDir, (snapshot) => {
+      if (snapshot.current && snapshot.tasks[snapshot.current]?.state === "running") {
+        resetTask = snapshot.current;
+      } else {
+        for (const taskId of Object.keys(snapshot.tasks)) {
+          if (snapshot.tasks[taskId]!.state === "running") {
+            resetTask = taskId;
+            break;
+          }
+        }
+      }
+
+      if (resetTask) {
+        const task = snapshot.tasks[resetTask];
+        if (task) {
+          task.state = "pending";
+          task.currentStage = null;
+          delete task.failedStage;
+          delete task.error;
+          task.attempts = 0;
+          task.refinementAttempts = 0;
+          task.tokenUsage = [];
+        }
+      }
+
+      snapshot.current = null;
+      snapshot.currentStage = null;
+    });
+
+    return sendJson(202, {
+      ok: true,
+      jobId,
+      stopped: pidFound,
+      resetTask,
+      signal: usedSignal,
+    });
   } finally {
     endStop(jobId);
   }