@aipanel/provider-deepseek 1.2.0-beta.0

package/es/profile.js

@@ -0,0 +1,57 @@
+import fs from "fs";
+import path from "path";
+import { pathToFileURL } from "url";
+import { MCP_API_PATH, createLogger } from "@aipanel/core/node";
+const log = createLogger("DeepSeekProfile");
+function buildDshOverlay(options) {
+  const { vitePort, cwd, pluginDistPath, clientAvailable = true } = options;
+  const mcpUrl = `http://127.0.0.1:${vitePort}${MCP_API_PATH}`;
+  const rows = [];
+  rows.push(
+    [
+      "    - id: aipanel-mcp",
+      "      name: '@deepseek-ai/dsh-mcp-client'",
+      "      config:",
+      "        serverName: aipanel",
+      "        transport: streamable-http",
+      `        url: ${mcpUrl}`,
+      "        headers: {}"
+    ].join("\n")
+  );
+  if (pluginDistPath && fs.existsSync(pluginDistPath)) {
+    const pluginSpec = pathToFileURL(pluginDistPath).href;
+    log.debug("injecting aipanel host plugin row", { pluginDistPath, pluginSpec });
+    rows.push(
+      [
+        "    - id: aipanel",
+        `      name: '${pluginSpec}'`,
+        "      inject: [tools, subprocess]",
+        "      config:",
+        `        cwd: ${JSON.stringify(cwd)}`,
+        "        autoDiagnose: true"
+      ].join("\n")
+    );
+  } else {
+    log.debug("aipanel dsh-plugin dist not found, skipping host plugin row", { pluginDistPath });
+  }
+  rows.push(
+    [
+      "    - id: aipanel-client",
+      "      name: '@aipanel/dsh-client'",
+      ...clientAvailable ? [] : ["      disabled: true"]
+    ].join("\n")
+  );
+  return ["- insert:", rows.join("\n"), ""].join("\n");
+}
+function writeDshOverlay(workspaceCwd, overlay) {
+  const dir = path.join(workspaceCwd, "node_modules", ".cache", "aipanel");
+  fs.mkdirSync(dir, { recursive: true });
+  const file = path.join(dir, "dsh-overlay.cordis.yml");
+  fs.writeFileSync(file, overlay, "utf-8");
+  log.debug("Wrote dsh overlay", { file });
+  return file;
+}
+export {
+  buildDshOverlay,
+  writeDshOverlay
+};

package/es/provider.d.ts

@@ -0,0 +1,49 @@
+import type { ChatSession, ProviderConfig, ProviderEnvironmentInfo, ProviderEvent, ProviderStartOptions, ProviderStartResult, WebProvider } from "@aipanel/core";
+/** DeepSeekWebProvider 构造配置（核心层传入的运行时参数） */
+export interface DeepSeekWebProviderConfig {
+    /** 服务主机名 */
+    hostname: string;
+}
+/** DeepSeekWebProvider 构造依赖（端口等运行时状态由编排层提供） */
+export interface DeepSeekWebProviderDeps {
+    /** 实际 Web 端口读取器 */
+    getWebPort: () => number;
+    /** 实际代理端口读取器 */
+    getProxyPort: () => number;
+}
+/**
+ * DeepSeek Harness Web Provider
+ * 组合 CLI 进程管理、RPC 会话 API、桥接脚本，向核心层暴露 WebProvider 契约。
+ */
+export declare class DeepSeekWebProvider implements WebProvider {
+    readonly id = "deepseek";
+    readonly displayName = "DeepSeek Harness";
+    /** SPA 型无 URL 深链：iframe 保持应用壳，切会话通过 FOCUS_SESSION 消息完成 */
+    readonly capabilities: {
+        readonly deepLink: false;
+    };
+    private readonly api;
+    private deps;
+    private process;
+    private bridgeOptions;
+    private readonly opts;
+    constructor(config: DeepSeekWebProviderConfig, deps: DeepSeekWebProviderDeps, options?: Record<string, unknown>);
+    /** 代理注入到 HTML 的桥接脚本（Provider 资产） */
+    get bridgeScript(): string | undefined;
+    /** 初始化桥接配置（主题等） */
+    applyConfig(config: ProviderConfig): void;
+    checkEnvironment(): Promise<ProviderEnvironmentInfo>;
+    start(options: ProviderStartOptions): Promise<ProviderStartResult>;
+    /** 把 providerOptions 配置映射为 dsh settings 命名空间 patch（仅含用户显式配置项） */
+    private buildSettingsToApply;
+    /** 解析 aipanel dsh-plugin 的构建产物路径（存在才在 overlay 里注入插件行）。
+     * 注意用 fileURLToPath：URL.pathname 是 percent-encoded，中文路径下 existsSync 会误判不存在。 */
+    private resolvePluginDist;
+    stop(): Promise<void>;
+    killOrphans(): Promise<number>;
+    listSessions(projectDir: string): Promise<ChatSession[]>;
+    createSession(projectDir: string, title?: string): Promise<ChatSession>;
+    deleteSession(sessionId: string): Promise<void>;
+    buildSessionUrl(projectDir: string, sessionId: string): string;
+    subscribeEvents(handler: (e: ProviderEvent) => void): () => void;
+}

package/es/provider.js

@@ -0,0 +1,290 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import { fileURLToPath } from "node:url";
+import { createLogger } from "@aipanel/core/node";
+import { DEFAULT_DEEPSEEK_PROVIDER_OPTIONS } from "./constants.js";
+import { DSH_LOOPBACK_HOST, DSH_MUX_EVENTS_PATH, DSH_HOST_EVENTS_PATH } from "./constants.js";
+import { DeepSeekAPI } from "./api.js";
+import { generateBridgeScript } from "./bridge-script.js";
+import { startDeepSeekWeb } from "./deepseek-web.js";
+import { buildDshOverlay, writeDshOverlay } from "./profile.js";
+import { checkDeepSeekInstalled, getDeepSeekVersion, killOrphanDeepSeekProcesses } from "./system.js";
+import {
+  dshProfileDir,
+  ensureDshClient,
+  resolveDevDshClientSource,
+  DSH_CLIENT_PACKAGE
+} from "./dsh-install.js";
+const log = createLogger("DeepSeekWebProvider");
+class DeepSeekWebProvider {
+  constructor(config, deps, options) {
+    __publicField(this, "id", "deepseek");
+    __publicField(this, "displayName", "DeepSeek Harness");
+    /** SPA 型无 URL 深链：iframe 保持应用壳，切会话通过 FOCUS_SESSION 消息完成 */
+    __publicField(this, "capabilities", { deepLink: false });
+    __publicField(this, "api");
+    __publicField(this, "deps");
+    __publicField(this, "process", null);
+    __publicField(this, "bridgeOptions", {});
+    __publicField(this, "opts");
+    this.deps = deps;
+    this.opts = resolveDeepSeekOptions(options);
+    this.api = new DeepSeekAPI(DSH_LOOPBACK_HOST, deps.getWebPort);
+  }
+  /** 代理注入到 HTML 的桥接脚本（Provider 资产） */
+  get bridgeScript() {
+    return generateBridgeScript(this.bridgeOptions);
+  }
+  /** 初始化桥接配置（主题等） */
+  applyConfig(config) {
+    this.bridgeOptions = { theme: config.theme ?? "auto" };
+  }
+  async checkEnvironment() {
+    if (!await checkDeepSeekInstalled()) {
+      return {
+        ok: false,
+        message: `DeepSeek Harness (dsh) is not installed!
+
+Please install dsh first:
+
+  npm install -g @deepseek-ai/dsh
+
+or run without installing:
+
+  npx @deepseek-ai/dsh web
+        `
+      };
+    }
+    const version = await getDeepSeekVersion();
+    return { ok: true, version: version ?? void 0 };
+  }
+  async start(options) {
+    log.debug("Starting dsh web process", {
+      port: options.port,
+      hostname: DSH_LOOPBACK_HOST,
+      cwd: options.cwd,
+      vitePort: options.vitePort
+    });
+    const devClientDir = resolveDevDshClientSource(import.meta.url);
+    const clientAvailable = await ensureDshClient(
+      dshProfileDir(this.opts.home),
+      devClientDir ?? DSH_CLIENT_PACKAGE,
+      this.opts.home
+    );
+    if (!clientAvailable) {
+      log.warn("@aipanel/dsh-client unavailable; @ menu chip highlight disabled", {
+        metaUrl: import.meta.url
+      });
+    }
+    const overlay = buildDshOverlay({
+      vitePort: options.vitePort,
+      cwd: options.cwd,
+      pluginDistPath: this.resolvePluginDist(),
+      clientAvailable
+    });
+    const patchPath = writeDshOverlay(options.cwd, overlay);
+    const proc = startDeepSeekWeb({
+      port: options.port,
+      hostname: DSH_LOOPBACK_HOST,
+      cwd: options.cwd,
+      patchPath,
+      home: this.opts.home,
+      verbose: options.verbose
+    });
+    this.process = proc;
+    const settings = this.buildSettingsToApply();
+    if (Object.keys(settings).length > 0) {
+      void this.api.applySettings(settings).catch((e) => {
+        log.warn("failed to apply provider settings to dsh", {
+          settings,
+          error: e instanceof Error ? e.message : String(e)
+        });
+      });
+    }
+    return { url: this.api.shellUrl, processHandle: proc };
+  }
+  /** 把 providerOptions 配置映射为 dsh settings 命名空间 patch（仅含用户显式配置项） */
+  buildSettingsToApply() {
+    const sections = {};
+    if (this.opts.agentPreset !== void 0) {
+      sections["agent-presets"] = { ...sections["agent-presets"], default: this.opts.agentPreset };
+    }
+    if (this.opts.permissionPreset !== void 0) {
+      sections.permission = {
+        ...sections.permission,
+        defaultPreset: this.opts.permissionPreset
+      };
+    }
+    if (this.opts.busyEnter !== void 0) {
+      sections["ui-conversation"] = {
+        ...sections["ui-conversation"],
+        busyEnter: this.opts.busyEnter
+      };
+    }
+    return sections;
+  }
+  /** 解析 aipanel dsh-plugin 的构建产物路径（存在才在 overlay 里注入插件行）。
+   * 注意用 fileURLToPath：URL.pathname 是 percent-encoded，中文路径下 existsSync 会误判不存在。 */
+  resolvePluginDist() {
+    const fromHere = new URL("../dsh-plugin/dist/index.js", import.meta.url);
+    return fileURLToPath(fromHere);
+  }
+  async stop() {
+    if (this.process) {
+      log.debug("Killing dsh web process", { pid: this.process.pid });
+      this.process.kill("SIGTERM");
+      this.process = null;
+    }
+  }
+  async killOrphans() {
+    return killOrphanDeepSeekProcesses();
+  }
+  async listSessions(projectDir) {
+    const sessions = await this.api.listSessions(projectDir);
+    const url = this.buildSessionUrl(projectDir, "");
+    return sessions.map((s) => toChatSession(s, url));
+  }
+  async createSession(projectDir, title) {
+    const url = this.buildSessionUrl(projectDir, "");
+    const created = await this.api.createSession(projectDir);
+    return {
+      id: created.sessionId,
+      title: title ?? "",
+      updatedAt: Date.now(),
+      url
+    };
+  }
+  // 删除走归档：dsh 无硬删除语义（workspace.archiveSession），
+  // 归档后 listSessions 按 archivedSessionIds 过滤即从列表消失。
+  async deleteSession(sessionId) {
+    await this.api.archiveSession(sessionId);
+  }
+  buildSessionUrl(projectDir, sessionId) {
+    void projectDir;
+    void sessionId;
+    return `http://${DSH_LOOPBACK_HOST}:${this.deps.getProxyPort()}/`;
+  }
+  subscribeEvents(handler) {
+    const port = this.deps.getWebPort();
+    const base = `ws://${DSH_LOOPBACK_HOST}:${port}`;
+    const endpoints = [DSH_MUX_EVENTS_PATH, DSH_HOST_EVENTS_PATH];
+    log.debug("Subscribing to dsh event streams (WebSocket)", {
+      endpoints: endpoints.map((p) => base + p)
+    });
+    let aborted = false;
+    const sockets = /* @__PURE__ */ new Set();
+    const retryTimers = /* @__PURE__ */ new Set();
+    const cleanupAll = () => {
+      for (const timer of retryTimers) clearTimeout(timer);
+      retryTimers.clear();
+      for (const ws of sockets) {
+        try {
+          ws.close();
+        } catch {
+        }
+      }
+      sockets.clear();
+    };
+    const connect = (path, attempt = 0) => {
+      if (aborted) return;
+      let socket;
+      try {
+        socket = new WebSocket(base + path);
+      } catch (e) {
+        log.warn("dsh event WebSocket create failed", { path, error: String(e) });
+        scheduleReconnect(path, attempt + 1);
+        return;
+      }
+      sockets.add(socket);
+      socket.onmessage = (ev) => {
+        try {
+          const frame = JSON.parse(String(ev.data));
+          const event = mapEvent(frame);
+          if (event) handler(event);
+        } catch {
+        }
+      };
+      socket.onclose = () => {
+        sockets.delete(socket);
+        scheduleReconnect(path, attempt + 1);
+      };
+      socket.onerror = () => {
+        try {
+          socket.close();
+        } catch {
+        }
+      };
+    };
+    const scheduleReconnect = (path, attempt) => {
+      if (aborted) return;
+      const delays = [250, 500, 1e3, 2e3, 5e3];
+      const after = delays[Math.min(attempt, delays.length - 1)];
+      const timer = setTimeout(() => {
+        retryTimers.delete(timer);
+        connect(path);
+      }, after);
+      retryTimers.add(timer);
+    };
+    endpoints.forEach((p) => connect(p));
+    return () => {
+      aborted = true;
+      cleanupAll();
+    };
+  }
+}
+function mapEvent(frame) {
+  if (!frame || typeof frame.method !== "string" || !frame.payload) return null;
+  const payload = frame.payload;
+  const sessionId = payload.sessionId ?? "";
+  switch (frame.method) {
+    case "host/session-status": {
+      if (!sessionId) return null;
+      const running = payload.running === true;
+      return { type: "session.status", sessionId, status: running ? "running" : "idle" };
+    }
+    case "session/event": {
+      const event = payload.event;
+      const type = event?.type ?? "";
+      if (!sessionId || !type) return null;
+      switch (type) {
+        case "assistant/message":
+        case "turn/end":
+          return { type: "thinking", sessionId, thinking: false };
+        case "assistant/chunk":
+        case "thinking/delta":
+        case "turn/start":
+        case "step/start":
+          return { type: "thinking", sessionId, thinking: true };
+        default:
+          return null;
+      }
+    }
+    default:
+      return null;
+  }
+}
+function toChatSession(s, url) {
+  return {
+    id: s.sessionId,
+    // dsh 标题在 projections.values.title，不在顶层
+    title: s.projections?.values?.title ?? "",
+    updatedAt: s.updatedAt,
+    parentId: s.parentSessionId,
+    url
+  };
+}
+function resolveDeepSeekOptions(options) {
+  if (!options) return { ...DEFAULT_DEEPSEEK_PROVIDER_OPTIONS };
+  const po = options.providerOptions ?? {};
+  return {
+    ...DEFAULT_DEEPSEEK_PROVIDER_OPTIONS,
+    home: po.home ?? options.home,
+    agentPreset: po.agentPreset ?? options.agentPreset,
+    permissionPreset: po.permissionPreset ?? options.permissionPreset,
+    busyEnter: po.busyEnter ?? options.busyEnter
+  };
+}
+export {
+  DeepSeekWebProvider
+};

package/es/system.d.ts

@@ -0,0 +1,3 @@
+export declare function checkDeepSeekInstalled(): Promise<boolean>;
+export declare function getDeepSeekVersion(): Promise<string | null>;
+export declare function killOrphanDeepSeekProcesses(): Promise<number>;

package/es/system.js

@@ -0,0 +1,170 @@
+import { spawn } from "child_process";
+import { createLogger } from "@aipanel/core/node";
+const log = createLogger("DeepSeekSystem");
+async function checkDeepSeekInstalled() {
+  const timer = log.timer("checkDeepSeekInstalled");
+  return new Promise((resolve) => {
+    log.debug("Checking if dsh is installed...");
+    const proc = spawn("dsh", ["--version"], { stdio: "ignore", shell: true });
+    proc.on("close", (code) => {
+      const installed = code === 0;
+      timer.end(installed ? "\u2713 dsh is installed" : "\u274C dsh not found");
+      resolve(installed);
+    });
+    proc.on("error", (err) => {
+      log.debug("Failed to check dsh installation", { error: err.message });
+      timer.end("\u274C Check failed");
+      resolve(false);
+    });
+  });
+}
+function getDeepSeekVersion() {
+  return new Promise((resolve) => {
+    const proc = spawn("dsh", ["--version"], { stdio: "pipe", shell: true });
+    let output = "";
+    proc.stdout?.on("data", (data) => {
+      output += data.toString();
+    });
+    proc.on("close", (code) => {
+      if (code === 0 && output.trim()) {
+        resolve(output.trim());
+      } else {
+        resolve(null);
+      }
+    });
+    proc.on("error", () => {
+      resolve(null);
+    });
+  });
+}
+const KILL_ORPHAN_TIMEOUT = 5e3;
+async function killOrphanDeepSeekProcesses() {
+  const timer = log.timer("killOrphanDeepSeekProcesses");
+  log.debug("Looking for orphan dsh processes (PPID=1)");
+  return new Promise((resolve) => {
+    let settled = false;
+    const done = (count) => {
+      if (settled) return;
+      settled = true;
+      resolve(count);
+    };
+    const timeout = setTimeout(() => {
+      log.warn("Kill orphan processes timed out, skipping");
+      timer.end("\u26A0 Timeout, skipped");
+      done(0);
+    }, KILL_ORPHAN_TIMEOUT);
+    const wrappedResolve = (count) => {
+      clearTimeout(timeout);
+      done(count);
+    };
+    if (process.platform === "win32") {
+      killOrphanProcessesOnWindows(wrappedResolve, timer);
+    } else {
+      killOrphanProcessesOnUnix(wrappedResolve, timer);
+    }
+  });
+}
+function killOrphanProcessesOnWindows(resolve, timer) {
+  log.debug("Using Windows method to find orphan processes");
+  const proc = spawn(
+    "wmic",
+    ["process", "where", 'name="node.exe"', "get", "processid,parentprocessid,commandline"],
+    { stdio: "pipe" }
+  );
+  let output = "";
+  proc.stdout?.on("data", (data) => {
+    output += data.toString();
+  });
+  proc.on("close", () => {
+    const pidsToKill = [];
+    output.split("\n").forEach((rawLine) => {
+      const line = rawLine.trim();
+      if (!line.includes("dsh")) return;
+      const parts = line.trim().split(/\s+/);
+      if (parts.length >= 2) {
+        const ppid = parts[0];
+        const pid = parts[1];
+        if (ppid === "1" && pid && !isNaN(Number(pid))) {
+          pidsToKill.push(pid);
+        }
+      }
+    });
+    if (pidsToKill.length > 0) {
+      log.debug(`Found ${pidsToKill.length} orphan processes`, { pids: pidsToKill });
+      let killedCount = 0;
+      let completedCount = 0;
+      pidsToKill.forEach((pid) => {
+        const killProc = spawn("taskkill", ["/F", "/PID", pid], { stdio: "ignore" });
+        killProc.on("close", (code) => {
+          completedCount++;
+          if (code === 0) killedCount++;
+          if (completedCount === pidsToKill.length) {
+            timer.end(`\u2713 Killed ${killedCount} orphan processes`);
+            resolve(killedCount);
+          }
+        });
+      });
+    } else {
+      log.debug("No orphan processes found");
+      timer.end("No orphan processes found");
+      resolve(0);
+    }
+  });
+  proc.on("error", (err) => {
+    log.debug("Failed to find orphan processes", { error: err.message });
+    timer.end("\u274C Failed to find orphan processes");
+    resolve(0);
+  });
+}
+function killOrphanProcessesOnUnix(resolve, timer) {
+  log.debug("Using Unix method to find orphan processes");
+  const proc = spawn("ps", ["-e", "-o", "pid,ppid,args"], { stdio: "pipe" });
+  let output = "";
+  proc.stdout?.on("data", (data) => {
+    output += data.toString();
+  });
+  proc.on("close", () => {
+    const lines = output.split("\n");
+    const pidsToKill = [];
+    lines.forEach((line) => {
+      if (!line.includes("dsh")) return;
+      const parts = line.trim().split(/\s+/);
+      if (parts.length >= 3) {
+        const pid = parts[0];
+        const ppid = parts[1];
+        if (ppid === "1") {
+          pidsToKill.push(pid);
+        }
+      }
+    });
+    if (pidsToKill.length > 0) {
+      log.debug(`Found ${pidsToKill.length} orphan processes`, { pids: pidsToKill });
+      const killProc = spawn("kill", ["-9", ...pidsToKill], { stdio: "ignore" });
+      killProc.on("close", (code) => {
+        const killedCount = code === 0 ? pidsToKill.length : 0;
+        timer.end(
+          killedCount > 0 ? `\u2713 Killed ${killedCount} orphan processes` : "\u274C Failed to kill processes"
+        );
+        resolve(killedCount);
+      });
+      killProc.on("error", () => {
+        timer.end("\u274C Failed to kill processes");
+        resolve(0);
+      });
+    } else {
+      log.debug("No orphan processes found");
+      timer.end("No orphan processes found");
+      resolve(0);
+    }
+  });
+  proc.on("error", (err) => {
+    log.debug("Failed to find orphan processes", { error: err.message });
+    timer.end("\u274C Failed to find orphan processes");
+    resolve(0);
+  });
+}
+export {
+  checkDeepSeekInstalled,
+  getDeepSeekVersion,
+  killOrphanDeepSeekProcesses
+};

package/es/types.d.ts

@@ -0,0 +1,127 @@
+/**
+ * DeepSeek Harness Provider 专属类型
+ * 所有与 DeepSeek Harness (dsh) 绑定的类型自包含于此，核心层不感知。
+ */
+/** 权限预设（对应 dsh settings permission.defaultPreset） */
+export type DeepSeekPermissionPreset = "read-only" | "workspace-write" | "danger-full-access";
+/** 繁忙时 Enter 键行为（对应 dsh settings ui-conversation.busyEnter） */
+export type DeepSeekBusyEnter = "queue" | "steer";
+/**
+ * DeepSeek Provider 专属配置（对应插件配置的 providerOptions 段）
+ * 保留字符串索引签名，以赋给 PluginOptions 的 Record<string, unknown> 泛型约束。
+ */
+export type DeepSeekProviderOptions = {
+    /** dsh 数据目录（$DSH_HOME），默认跟随系统（~/.dsh） */
+    home?: string;
+    /** 默认 Agent 预设（dsh settings agent-presets.default，如 code/standard；新建会话的默认模式） */
+    agentPreset?: string;
+    /** 默认权限预设（dsh settings permission.defaultPreset） */
+    permissionPreset?: DeepSeekPermissionPreset;
+    /** 繁忙时 Enter 键行为（dsh settings ui-conversation.busyEnter） */
+    busyEnter?: DeepSeekBusyEnter;
+    /**
+     * Provider 允许自定义扩展字段
+     * [key: string]: unknown;
+     */
+    [key: string]: unknown;
+};
+/**
+ * dsh API 四象限 RPC envelope（客户端请求 / 服务端响应）。
+ * 字段为 type/rpcId/method/payload + result:{ok,value|error}，不是标准 JSON-RPC。
+ */
+/** 客户端 → 服务端 请求体（POST /api/<method>） */
+export interface ClientRequest {
+    type: "client-request";
+    rpcId: string;
+    method: string;
+    payload: Record<string, unknown>;
+}
+/** 服务端 → 客户端 响应体 */
+export interface ServerResponse {
+    type: "server-response";
+    rpcId: string;
+    result: {
+        ok: true;
+        value: unknown;
+    } | {
+        ok: false;
+        error: {
+            code?: string;
+            message?: string;
+        };
+    };
+}
+/** 服务端推送帧（SSE data 载荷） */
+export interface ServerRequest {
+    type: "server-request";
+    rpcId: string;
+    method: string;
+    payload: Record<string, unknown>;
+}
+/** 会话摘要（POST /api/session.list 的 items 项） */
+export interface SessionSummary {
+    sessionId: string;
+    updatedAt: number;
+    running: boolean;
+    blank: boolean;
+    parentSessionId?: string;
+    origin?: "subagent";
+    cwd?: string;
+    agentPreset?: string;
+    /** 会话投影（标题等派生值存在 projections.values.title） */
+    projections?: {
+        values?: {
+            title?: string | null;
+            [key: string]: unknown;
+        };
+        [key: string]: unknown;
+    };
+}
+/** session.list 的 value：容器对象（不是数组），会话在 items 下 */
+export interface SessionListResult {
+    items: SessionSummary[];
+}
+/** 工作区视图（POST /api/workspace.list 的 items 项，用于按目录匹配会话） */
+export interface WorkspaceView {
+    workspaceId: string;
+    path: string;
+    title: string;
+    sessionIds: string[];
+    createdAt: string;
+    updatedAt: string;
+}
+/** workspace.list 的 value：容器对象（不是数组），工作区在 items 下，archivedSessionIds 为已归档会话 */
+export interface WorkspaceListResult {
+    items: WorkspaceView[];
+    archivedSessionIds: string[];
+}
+/** workspace.create 的 value（幂等：已存在则返回既有 workspace，created=false） */
+export interface WorkspaceCreateResult {
+    workspace: WorkspaceView;
+    created: boolean;
+}
+/** 会话流式事件（session/event 的 event 字段） */
+export interface SessionStreamEvent {
+    type: string;
+    seq: number;
+    time?: number;
+    data?: Record<string, unknown>;
+}
+/** dsh 会话日志事件类型（用于 thinking/status 推导的稳定子集） */
+export declare const SESSION_EVENT_TYPES: {
+    /** 回合开始 → 视为 streaming */
+    readonly TURN_START: "turn/start";
+    /** 回合结束（稳定停等） */
+    readonly TURN_END: "turn/end";
+    /** 步骤开始 */
+    readonly STEP_START: "step/start";
+    /** 步骤结束 */
+    readonly STEP_END: "step/end";
+    /** 助手输出完成 */
+    readonly ASSISTANT_MESSAGE: "assistant/message";
+    /** 助手输出增量分片 */
+    readonly ASSISTANT_CHUNK: "assistant/chunk";
+    /** 思考增量分片 */
+    readonly THINKING_DELTA: "thinking/delta";
+};
+export type SessionEventType = (typeof SESSION_EVENT_TYPES)[keyof typeof SESSION_EVENT_TYPES];