dsh-more 0.0.9 → 0.1.1

package/dist/index.js

@@ -409,7 +409,7 @@ var MESSAGE_VISIBILITY_PROJECTION_KEY = "dshMoreMessageDelete";
 
 // src/platform/dsh/identity.ts
 var PLUGIN_NAME = "dsh-more";
-var PLUGIN_API_PREFIX = `/${PLUGIN_NAME}/api`;
+var PLUGIN_API_PREFIX = `/api/${PLUGIN_NAME}`;
 var PLUGIN_MUTATION_HEADER = "x-dsh-more";
 var PATCH_SETTINGS_NAMESPACE = PLUGIN_NAME;
 
@@ -760,8 +760,12 @@ function installLiveSessionHandleTracker(ctx) {
   tracker.originalResume = originalResume;
   tracker.createDescriptor = Object.getOwnPropertyDescriptor(registry, "create");
   tracker.resumeDescriptor = Object.getOwnPropertyDescriptor(registry, "resume");
-  tracker.wrappedCreate = async (options) => trackedHandle(tracker, await originalCreate.call(registry, options));
-  tracker.wrappedResume = async (options) => trackedHandle(tracker, await originalResume.call(registry, options));
+  tracker.wrappedCreate = async function(options) {
+    return trackedHandle(tracker, await originalCreate.call(this, options));
+  };
+  tracker.wrappedResume = async function(options) {
+    return trackedHandle(tracker, await originalResume.call(this, options));
+  };
   tracker.references = 1;
   registry[TRACKER] = tracker;
   registry.create = tracker.wrappedCreate;
@@ -882,7 +886,9 @@ async function deleteSessionPermanently(ctx, rawSessionId) {
 // src/patches/session-delete/host/index.ts
 var hostPatch3 = {
   id: SESSION_DELETE_PATCH_ID,
-  setup: installLiveSessionHandleTracker,
+  // A disabled action still needs to remember handles created during that time.
+  // Track for the plugin lifetime; the API router remains gated by the switch.
+  observe: installLiveSessionHandleTracker,
   routes: ({ ctx }) => ({
     commit: async (payload) => {
       const sessionId = requireString(payload, "sessionId");
@@ -1143,6 +1149,21 @@ function validateCapabilities(raw) {
   };
 }
 
+// src/platform/dsh/host/settings.ts
+function liveSetting(schema2) {
+  const volatile = Reflect.get(schema2, "volatile");
+  return typeof volatile === "function" ? volatile.call(schema2) : schema2;
+}
+function settingValue(value) {
+  if (typeof value !== "object" || value === null) return value;
+  const get = Reflect.get(value, "get");
+  return typeof get === "function" ? get.call(value) : value;
+}
+function readSettings(ctx, namespace) {
+  if (typeof ctx.settings.get === "function") return ctx.settings.get(namespace);
+  return ctx.settings.describe().find((entry) => entry.ns === namespace)?.value;
+}
+
 // src/patches/model-capabilities/host/deepseek.ts
 function record(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
@@ -1157,7 +1178,7 @@ function validateDeepSeekEfforts(efforts) {
 }
 function ruleFor(ctx, provider, modelId) {
   if (provider !== DEEPSEEK_PROVIDER) return void 0;
-  const profile = record(ctx.settings.get(LLM_DEEPSEEK_SETTINGS_NAMESPACE));
+  const profile = record(readSettings(ctx, LLM_DEEPSEEK_SETTINGS_NAMESPACE));
   const models = Array.isArray(profile.models) ? profile.models : [];
   const model = record(models.find((item) => record(item).id === modelId));
   if (model.reasoningEfforts === void 0) return void 0;
@@ -1400,6 +1421,182 @@ var hostPatch5 = {
   routes: ({ ctx }) => ({ read: () => read(ctx), save: (payload) => save(ctx, payload) })
 };
 
+// src/patches/fast-mode/host/index.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+
+// src/patches/fast-mode/shared.ts
+var FAST_MODE_PATCH_ID = "fast-mode";
+var FAST_MODE_SETTINGS_NS = "dsh-more/fast-mode";
+var DEFAULT_FAST_MODE_SETTINGS = {
+  defaultEnabled: false,
+  serviceTier: "priority",
+  speed: 1.5,
+  enableAnthropicFastMode: true,
+  customBodyParams: {},
+  customHeaders: {}
+};
+
+// src/patches/fast-mode/host/index.ts
+var activeFastSessionStorage = new AsyncLocalStorage();
+var fastSessions = /* @__PURE__ */ new Set();
+function isFastSession(sessionId) {
+  if (!sessionId) return false;
+  return fastSessions.has(sessionId);
+}
+function setFastSession(sessionId, enabled) {
+  if (enabled) fastSessions.add(sessionId);
+  else fastSessions.delete(sessionId);
+}
+function toggleFastSession(sessionId) {
+  const next = !fastSessions.has(sessionId);
+  setFastSession(sessionId, next);
+  return next;
+}
+var interceptorInstalled = false;
+var currentSettings = { ...DEFAULT_FAST_MODE_SETTINGS };
+function readSettings2(ctx) {
+  const descriptor = ctx.settings?.describe?.().find((entry) => entry.ns === FAST_MODE_SETTINGS_NS);
+  if (!descriptor || typeof descriptor.value !== "object" || descriptor.value === null) {
+    return { ...DEFAULT_FAST_MODE_SETTINGS };
+  }
+  const val = descriptor.value;
+  return {
+    defaultEnabled: typeof val.defaultEnabled === "boolean" ? val.defaultEnabled : false,
+    serviceTier: typeof val.serviceTier === "string" && val.serviceTier ? val.serviceTier : "priority",
+    speed: typeof val.speed === "number" && val.speed > 0 ? val.speed : 1.5,
+    enableAnthropicFastMode: typeof val.enableAnthropicFastMode === "boolean" ? val.enableAnthropicFastMode : true,
+    customBodyParams: typeof val.customBodyParams === "object" && val.customBodyParams !== null ? val.customBodyParams : {},
+    customHeaders: typeof val.customHeaders === "object" && val.customHeaders !== null ? val.customHeaders : {}
+  };
+}
+function bodyText(body) {
+  if (typeof body === "string") return body;
+  if (body instanceof Uint8Array) return new TextDecoder().decode(body);
+  return void 0;
+}
+function codexFastTier(value) {
+  const tier = (value ?? "").trim().toLowerCase();
+  if (tier === "" || tier === "fast" || tier === "priority") return "priority";
+  return tier;
+}
+function isModelPayload(value) {
+  return typeof value.model === "string" && ("messages" in value || "input" in value || "contents" in value);
+}
+function requestUrl(input) {
+  if (typeof input === "string") return input;
+  if (input instanceof URL) return input.toString();
+  return input.url;
+}
+function patchFastRequest(input, init) {
+  const store = activeFastSessionStorage.getStore();
+  if (!store?.isFast || init?.body == null) return { input, init };
+  const text = bodyText(init.body);
+  if (text === void 0) return { input, init };
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return { input, init };
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return { input, init };
+  const body = parsed;
+  if (!isModelPayload(body)) return { input, init };
+  body.service_tier = codexFastTier(currentSettings.serviceTier);
+  if (currentSettings.customBodyParams) Object.assign(body, currentSettings.customBodyParams);
+  const nextBody = JSON.stringify(body);
+  const headers = new Headers(init.headers);
+  if (headers.has("content-length")) headers.set("content-length", String(Buffer.byteLength(nextBody)));
+  const url = requestUrl(input);
+  if (currentSettings.enableAnthropicFastMode && /anthropic\.com|\/v1\/messages\b/.test(url)) {
+    const beta = headers.get("anthropic-beta");
+    headers.set("anthropic-beta", beta && !beta.includes("fast-mode") ? `${beta},fast-mode-2026-02-01` : beta ?? "fast-mode-2026-02-01");
+  }
+  if (currentSettings.customHeaders) {
+    for (const [name2, value] of Object.entries(currentSettings.customHeaders)) headers.set(name2, value);
+  }
+  return { input, init: { ...init, body: nextBody, headers } };
+}
+function bindFastStream(stream, store) {
+  const iterator = stream[Symbol.asyncIterator]();
+  const pull = (run) => activeFastSessionStorage.run(store, run);
+  const bound = {
+    [Symbol.asyncIterator]() {
+      return bound;
+    },
+    next: () => pull(() => iterator.next()),
+    return: (value) => pull(() => iterator.return?.(value) ?? Promise.resolve({ done: true, value: void 0 })),
+    throw: (error) => pull(() => iterator.throw?.(error) ?? Promise.reject(error))
+  };
+  return bound;
+}
+function installFastModeInterceptor() {
+  if (interceptorInstalled) return;
+  interceptorInstalled = true;
+  const originalFetch = globalThis.fetch;
+  globalThis.fetch = async function(input, init) {
+    try {
+      const patched = patchFastRequest(input, init);
+      return await originalFetch.call(this, patched.input, patched.init);
+    } catch (error) {
+      console.warn("fast-mode fetch interceptor error, sending the original request", error);
+      return originalFetch.call(this, input, init);
+    }
+  };
+}
+var hostPatch6 = {
+  id: FAST_MODE_PATCH_ID,
+  setup: (ctx) => {
+    currentSettings = readSettings2(ctx);
+    installFastModeInterceptor();
+    const dispose = ctx.on("llm/stream", (options, next) => {
+      if (options?.purpose === "session-title" || options?.purpose === "compaction") return next();
+      const sessionId = options?.sessionId === void 0 ? void 0 : String(options.sessionId);
+      const enabled = sessionId !== void 0 && isFastSession(sessionId) || currentSettings.defaultEnabled;
+      if (!enabled) return next();
+      return bindFastStream(next(), { sessionId, isFast: true });
+    }, { global: true, prepend: true });
+    return () => {
+      if (typeof dispose === "function") dispose();
+    };
+  },
+  routes: ({ ctx }) => ({
+    getState: (payload) => {
+      const sessionId = typeof payload?.sessionId === "string" ? payload.sessionId : void 0;
+      return { enabled: sessionId ? isFastSession(sessionId) : false, settings: readSettings2(ctx) };
+    },
+    toggle: (payload) => {
+      const sessionId = typeof payload?.sessionId === "string" ? payload.sessionId : "";
+      if (!sessionId) throw new Error("\u7F3A\u5C11 sessionId");
+      return { enabled: toggleFastSession(sessionId) };
+    },
+    set: (payload) => {
+      const sessionId = typeof payload?.sessionId === "string" ? payload.sessionId : "";
+      if (!sessionId) throw new Error("\u7F3A\u5C11 sessionId");
+      const enabled = Boolean(payload?.enabled);
+      setFastSession(sessionId, enabled);
+      return { enabled };
+    },
+    getSettings: () => readSettings2(ctx),
+    saveSettings: async (payload) => {
+      if (typeof payload !== "object" || payload === null) throw new Error("\u65E0\u6548\u7684\u914D\u7F6E\u5185\u5BB9");
+      const descriptor = ctx.settings?.describe?.().find((entry) => entry.ns === FAST_MODE_SETTINGS_NS);
+      const next = {
+        defaultEnabled: Boolean(payload.defaultEnabled),
+        serviceTier: typeof payload.serviceTier === "string" && payload.serviceTier ? payload.serviceTier : "priority",
+        speed: typeof payload.speed === "number" && payload.speed > 0 ? payload.speed : 1.5,
+        enableAnthropicFastMode: payload.enableAnthropicFastMode !== false,
+        customBodyParams: typeof payload.customBodyParams === "object" && payload.customBodyParams !== null ? payload.customBodyParams : {},
+        customHeaders: typeof payload.customHeaders === "object" && payload.customHeaders !== null ? payload.customHeaders : {}
+      };
+      currentSettings = next;
+      if (typeof ctx.settings?.mutate === "function") {
+        await ctx.settings.mutate(FAST_MODE_SETTINGS_NS, [{ op: "set", path: [], value: next }], descriptor?.revision ?? 0);
+      }
+      return next;
+    }
+  })
+};
+
 // src/patches/session-auto-title/host/index.ts
 import { setTimeout as delay } from "node:timers/promises";
 
@@ -1462,7 +1659,7 @@ async function* validate(stream, signal, status) {
     throw error;
   }
 }
-var hostPatch6 = {
+var hostPatch7 = {
   id: SESSION_AUTO_TITLE_PATCH_ID,
   setup: (ctx) => {
     const status = { requests: 0, successes: 0, failures: 0, retries: 0 };
@@ -1563,7 +1760,7 @@ async function moveSessionGroup(ctx, payload) {
   if (ctx.workspaceRegistry.list().some((workspace) => workspace.sessionIds.includes(sessionId))) {
     throw new DshMoreError("bad-request", "\u8FD9\u6761\u4F1A\u8BDD\u5DF2\u6709\u539F\u751F\u5DE5\u4F5C\u533A\uFF0C\u53EA\u652F\u6301\u79FB\u52A8\u672A\u5206\u7EC4\u6216\u624B\u52A8\u5F52\u7EC4\u7684\u4F1A\u8BDD\u3002");
   }
-  const current = decodeSessionGroups(ctx.settings.get(SESSION_GROUPS_NAMESPACE)) ?? EMPTY_GROUPS;
+  const current = decodeSessionGroups(readSettings(ctx, SESSION_GROUPS_NAMESPACE)) ?? EMPTY_GROUPS;
   const result = { sessionId, workspaceId };
   if ((current.assignments[sessionId] ?? null) === workspaceId) return result;
   await ctx.settings.mutate(SESSION_GROUPS_NAMESPACE, [workspaceId === null ? { op: "unset", path: ["assignments", sessionId] } : { op: "set", path: ["assignments", sessionId], value: workspaceId }]);
@@ -1577,11 +1774,13 @@ function prepareTask(payload, homeDirectory = homedir()) {
   }
   return { sessionId: payload.sessionId, cwd: join(homeDirectory, "Documents", "DSH", "tasks", payload.sessionId) };
 }
-var hostPatch7 = {
+var hostPatch8 = {
   id: PROJECTLESS_TASKS_PATCH_ID,
   setup: (ctx) => {
     const fiber = ctx.inject(["settings"], (scope) => {
-      scope.settings.register(SESSION_GROUPS_NAMESPACE, SessionGroupsSchema);
+      if (typeof scope.settings.register === "function") {
+        scope.settings.register(SESSION_GROUPS_NAMESPACE, SessionGroupsSchema);
+      }
     });
     return () => {
       void fiber.dispose();
@@ -1591,18 +1790,40 @@ var hostPatch7 = {
 };
 
 // src/generated/host-registry.ts
-var HOST_PATCHES = [hostPatch, hostPatch2, hostPatch3, hostPatch4, hostPatch5, hostPatch6, hostPatch7];
+var HOST_PATCHES = [hostPatch, hostPatch2, hostPatch3, hostPatch4, hostPatch5, hostPatch6, hostPatch7, hostPatch8];
 
 // src/generated/patch-catalog.ts
+var PATCH_CATALOG = [
+  { "id": "message-edit", "name": "\u7F16\u8F91\u5E76\u91CD\u65B0\u5F00\u59CB", "description": "\u7F16\u8F91\u7528\u6237\u6D88\u606F\u5E76\u4E22\u5F03\u8BE5\u6D88\u606F\u4E4B\u540E\u7684\u5386\u53F2", "defaultEnabled": true, "order": 100, "clientKind": "message-action" },
+  { "id": "message-delete", "name": "\u5355\u6761\u6D88\u606F\u5220\u9664", "description": "\u5220\u9664\u6307\u5B9A\u6D88\u606F\u5E76\u4FDD\u7559\u524D\u540E\u5386\u53F2\u8BB0\u5F55", "defaultEnabled": true, "order": 200, "clientKind": "message-action" },
+  { "id": "session-delete", "name": "\u6C38\u4E45\u5220\u9664\u4F1A\u8BDD", "description": "\u505C\u6B62\u76EE\u6807\u4F1A\u8BDD\u5E76\u4ECE\u78C1\u76D8\u6C38\u4E45\u5220\u9664\uFF0C\u4E0D\u5F71\u54CD\u539F\u751F\u5F52\u6863", "defaultEnabled": true, "order": 300, "clientKind": "standalone" },
+  { "id": "conversation-markdown-export", "name": "\u5BFC\u51FA\u5B8C\u6574\u804A\u5929\u8BB0\u5F55", "description": "\u5C06\u5F53\u524D\u4F1A\u8BDD\u7684\u5B8C\u6574\u804A\u5929\u8BB0\u5F55\u4E0B\u8F7D\u4E3A Markdown \u6587\u4EF6", "defaultEnabled": true, "order": 400, "clientKind": "standalone" },
+  { "id": "model-capabilities", "name": "\u6A21\u578B\u80FD\u529B\u914D\u7F6E", "description": "\u5728\u6A21\u578B\u914D\u7F6E\u9875\u8BBE\u7F6E\u6BCF\u4E2A\u6A21\u578B\u7684\u8BC6\u56FE\u80FD\u529B\u3001\u53EF\u9009\u601D\u8003\u7C7B\u578B\u4E0E\u601D\u8003\u53C2\u6570\u683C\u5F0F", "defaultEnabled": true, "order": 500, "clientKind": "standalone" },
+  { "id": "fast-mode", "name": "\u52A0\u901F", "description": "\u5728\u8F93\u5165\u6846\u548C /fast \u547D\u4EE4\u4E2D\u5F00\u5173\u52A0\u901F\u3002\u54CD\u5E94\u66F4\u5FEB\uFF0C\u4F46\u4F1A\u66F4\u5FEB\u6D88\u8017\u989D\u5EA6", "defaultEnabled": true, "order": 550, "clientKind": "standalone" },
+  { "id": "session-auto-title", "name": "\u4F1A\u8BDD\u81EA\u52A8\u547D\u540D", "description": "\u65B0\u4F1A\u8BDD\u9996\u6761\u9700\u6C42\u540E\uFF0C\u4F7F\u7528\u5F53\u524D\u6A21\u578B\u751F\u6210\u300C\u7C7B\u578B \xB7 \u5177\u4F53\u4EFB\u52A1\u300D\u6807\u9898\uFF1B\u4FDD\u7559\u624B\u52A8\u547D\u540D\uFF0C\u5931\u8D25\u65F6\u4FDD\u7559\u539F\u6709\u6807\u9898", "defaultEnabled": true, "order": 600, "clientKind": "standalone" },
+  { "id": "projectless-tasks", "name": "\u72EC\u7ACB\u4EFB\u52A1", "description": "\u5728\u5DE5\u4F5C\u533A\u4E0B\u62C9\u6846\u521B\u5EFA\u72EC\u7ACB\u4EFB\u52A1\u5E76\u4FDD\u7559\u8349\u7A3F\uFF0C\u4E5F\u53EF\u5C06\u672A\u5206\u7EC4\u4F1A\u8BDD\u79FB\u5165\u5DE5\u4F5C\u533A\u5217\u8868", "defaultEnabled": true, "order": 700, "clientKind": "standalone" }
+];
 var DEFAULT_PATCH_SETTINGS = {
   "message-edit": true,
   "message-delete": true,
   "session-delete": true,
   "conversation-markdown-export": true,
   "model-capabilities": true,
+  "fast-mode": true,
   "session-auto-title": true,
   "projectless-tasks": true
 };
+function decodePatchSettings(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
+  const candidate = value;
+  const decoded = { ...DEFAULT_PATCH_SETTINGS };
+  for (const patch of PATCH_CATALOG) {
+    const enabled = candidate[patch.id];
+    if (enabled !== void 0 && typeof enabled !== "boolean") return void 0;
+    if (typeof enabled === "boolean") decoded[patch.id] = enabled;
+  }
+  return decoded;
+}
 
 // src/kernel/host/activation.ts
 var NOOP = () => void 0;
@@ -1610,10 +1831,28 @@ var HostPatchActivation = class {
   constructor(ctx, patches) {
     this.ctx = ctx;
     this.byId = new Map(patches.map((patch) => [patch.id, patch]));
+    try {
+      for (const patch of patches) {
+        const dispose = patch.observe?.(ctx);
+        if (dispose !== void 0) this.observers.push(dispose);
+      }
+    } catch (error) {
+      const failures = [error];
+      for (const dispose of this.observers.splice(0).reverse()) {
+        try {
+          dispose();
+        } catch (failure) {
+          failures.push(failure);
+        }
+      }
+      if (failures.length > 1) throw new AggregateError(failures, "patch observation failed");
+      throw error;
+    }
   }
   ctx;
   byId;
   disposers = /* @__PURE__ */ new Map();
+  observers = [];
   settings = { ...DEFAULT_PATCH_SETTINGS };
   apply(next) {
     for (const [id, patch] of this.byId) {
@@ -1632,11 +1871,24 @@ var HostPatchActivation = class {
     return this.settings[id] === true && this.byId.has(id);
   }
   dispose() {
-    for (const dispose of [...this.disposers.values()].reverse()) dispose();
+    const disposers = [...this.disposers.values()].reverse();
     this.disposers.clear();
+    disposers.push(...this.observers.splice(0).reverse());
+    const failures = [];
+    for (const dispose of disposers) {
+      try {
+        dispose();
+      } catch (error) {
+        failures.push(error);
+      }
+    }
+    if (failures.length > 0) throw new AggregateError(failures, "patch cleanup failed");
   }
 };
 
+// src/kernel/host/settings.ts
+import z4 from "@deepseek-ai/schemastery";
+
 // src/generated/host-settings-schema.ts
 import z3 from "@deepseek-ai/schemastery";
 var PatchSettingsSchema = z3.object({
@@ -1645,13 +1897,28 @@ var PatchSettingsSchema = z3.object({
   "session-delete": z3.boolean().default(true),
   "conversation-markdown-export": z3.boolean().default(true),
   "model-capabilities": z3.boolean().default(true),
+  "fast-mode": z3.boolean().default(true),
   "session-auto-title": z3.boolean().default(true),
   "projectless-tasks": z3.boolean().default(true)
 });
 
 // src/kernel/host/settings.ts
 var PATCH_SETTINGS_NAMESPACE2 = PATCH_SETTINGS_NAMESPACE;
-function installPatchSettings(ctx, activation) {
+var PatchConfig = z4.object(Object.fromEntries(
+  Object.entries(PatchSettingsSchema.dict ?? {}).map(([key, schema2]) => [key, liveSetting(schema2)])
+));
+function installPatchSettings(ctx, activation, config = DEFAULT_PATCH_SETTINGS) {
+  if (typeof ctx.settings.installSection !== "function") {
+    const refresh = () => {
+      const values = typeof config === "object" && config !== null ? Object.fromEntries(Object.entries(config).map(([key, value]) => [key, settingValue(value)])) : config;
+      const settings = decodePatchSettings(values);
+      if (settings === void 0) throw new TypeError("Invalid DSH More patch configuration");
+      activation.apply(settings);
+    };
+    ctx.on("loader/volatile-update", refresh);
+    refresh();
+    return;
+  }
   let source = () => DEFAULT_PATCH_SETTINGS;
   ctx.settings.installSection(ctx, PATCH_SETTINGS_NAMESPACE2, PatchSettingsSchema, DEFAULT_PATCH_SETTINGS, {
     setSource: (next) => {
@@ -1663,6 +1930,9 @@ function installPatchSettings(ctx, activation) {
   });
 }
 
+// src/platform/dsh/host/api-router.ts
+import { Readable } from "node:stream";
+
 // src/platform/dsh/host/trust.ts
 function header(req, name2) {
   const value = req.headers[name2];
@@ -1719,6 +1989,43 @@ function registerPatchApi(ctx, patches, confirmationSecret, isEnabled) {
   const host = ctx;
   const routes = collectRoutes(patches, { ctx, confirmationSecret });
   const logger = ctx.logger(PLUGIN_NAME);
+  const connection = typeof ctx.get === "function" ? ctx.get("connection") : void 0;
+  if (connection?.fetch?.register !== void 0) {
+    for (const [route, registered] of routes) {
+      connection.fetch.register({
+        path: `${PLUGIN_API_PREFIX}/${route}`,
+        methods: ["POST"],
+        requestBody: "buffered",
+        fetch: async (request) => {
+          let status = 200;
+          let headers = {};
+          let body = "";
+          const res = {
+            writeHead(code, values) {
+              status = code;
+              headers = values;
+            },
+            end(value) {
+              body = value;
+            }
+          };
+          try {
+            if (request.headers.get(PLUGIN_MUTATION_HEADER) !== "1") throw new DshMoreError("forbidden", "\u8BF7\u6C42\u6765\u6E90\u4E0D\u53D7\u4FE1\u4EFB\u3002", 403);
+            if (!isEnabled(registered.patchId)) throw new DshMoreError("patch-disabled", "\u8FD9\u4E2A\u8865\u4E01\u5F53\u524D\u5DF2\u5173\u95ED\u3002", 409);
+            const req = request.body === null ? Readable.from([]) : Readable.fromWeb(request.body);
+            req.headers = Object.fromEntries(request.headers);
+            requireJsonContentType(req);
+            writeOk(res, await registered.handler(await readJson(req)));
+          } catch (error) {
+            if (!(error instanceof DshMoreError) || error.status >= 500) logger.error("patch API %s failed: %s", route, String(error));
+            writeError(res, error);
+          }
+          return new Response(body, { status, headers });
+        }
+      });
+    }
+    return;
+  }
   ctx.effect(() => ctx.webServer.register({
     kind: "prefix",
     path: PLUGIN_API_PREFIX,
@@ -1764,19 +2071,21 @@ var inject = [
   "webRuntime",
   "agents",
   "sessions",
+  "connection",
   "sessionPersistence",
   "sessionProjections",
   "workspaceRegistry",
   "agentPresets",
   "settings"
 ];
-function apply(ctx) {
+function apply(ctx, config) {
   const activation = new HostPatchActivation(ctx, HOST_PATCHES);
   ctx.effect(() => () => activation.dispose(), `${PLUGIN_NAME}: patch activation`);
-  installPatchSettings(ctx, activation);
+  installPatchSettings(ctx, activation, config);
   registerPatchApi(ctx, HOST_PATCHES, randomBytes(32), (patchId) => activation.isEnabled(patchId));
 }
 export {
+  PatchConfig as Config,
   apply,
   inject,
   name

package/dist/session-groups.js

@@ -0,0 +1,17 @@
+// src/patches/projectless-tasks/host/settings.ts
+import z from "@deepseek-ai/schemastery";
+
+// src/platform/dsh/host/settings.ts
+function liveSetting(schema) {
+  const volatile = Reflect.get(schema, "volatile");
+  return typeof volatile === "function" ? volatile.call(schema) : schema;
+}
+
+// src/patches/projectless-tasks/host/settings.ts
+var Config = z.object({ assignments: liveSetting(z.dict(z.string()).default({})) });
+function apply() {
+}
+export {
+  Config,
+  apply
+};

package/dist/types/generated/host-settings-schema.d.ts

@@ -5,6 +5,7 @@ export declare const PatchSettingsSchema: z<Schemastery.ObjectS<{
     "session-delete": z<boolean, boolean>;
     "conversation-markdown-export": z<boolean, boolean>;
     "model-capabilities": z<boolean, boolean>;
+    "fast-mode": z<boolean, boolean>;
     "session-auto-title": z<boolean, boolean>;
     "projectless-tasks": z<boolean, boolean>;
 }>, Schemastery.ObjectT<{
@@ -13,6 +14,7 @@ export declare const PatchSettingsSchema: z<Schemastery.ObjectS<{
     "session-delete": z<boolean, boolean>;
     "conversation-markdown-export": z<boolean, boolean>;
     "model-capabilities": z<boolean, boolean>;
+    "fast-mode": z<boolean, boolean>;
     "session-auto-title": z<boolean, boolean>;
     "projectless-tasks": z<boolean, boolean>;
 }>>;

package/dist/types/generated/patch-catalog.d.ts

@@ -33,6 +33,13 @@ export declare const PATCH_CATALOG: readonly [{
     readonly defaultEnabled: true;
     readonly order: 500;
     readonly clientKind: "standalone";
+}, {
+    readonly id: "fast-mode";
+    readonly name: "加速";
+    readonly description: "在输入框和 /fast 命令中开关加速。响应更快，但会更快消耗额度";
+    readonly defaultEnabled: true;
+    readonly order: 550;
+    readonly clientKind: "standalone";
 }, {
     readonly id: "session-auto-title";
     readonly name: "会话自动命名";
@@ -55,6 +62,7 @@ export interface PatchSettings {
     "session-delete": boolean;
     "conversation-markdown-export": boolean;
     "model-capabilities": boolean;
+    "fast-mode": boolean;
     "session-auto-title": boolean;
     "projectless-tasks": boolean;
 }

package/dist/types/index.d.ts

@@ -1,4 +1,5 @@
 import type { Context } from '@deepseek-ai/cordis';
+export { PatchConfig as Config } from './kernel/host/settings.js';
 export declare const name = "dsh-more";
 export declare const inject: string[];
-export declare function apply(ctx: Context): void;
+export declare function apply(ctx: Context, config?: unknown): void;

package/dist/types/kernel/client/config-card.d.ts

@@ -1,9 +1,7 @@
 import type { Context as ClientContext } from '@deepseek-ai/cordis';
-import type { PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots';
 export type {} from '@deepseek-ai/dsh-client-ui-settings-plugins/client';
 import type { PatchActivationSource } from './activation.js';
-type CardProps = PropsRuntime<'settings.plugin.item'>;
-export interface PatchConfigCardProps extends CardProps {
+export interface PatchConfigCardProps {
     activation: PatchActivationSource;
     initiallyOpen?: boolean;
 }

package/dist/types/kernel/host/activation.d.ts

@@ -6,6 +6,7 @@ export declare class HostPatchActivation {
     private readonly ctx;
     private readonly byId;
     private readonly disposers;
+    private readonly observers;
     private settings;
     constructor(ctx: Context, patches: readonly HostPatch[]);
     apply(next: PatchSettings): void;

package/dist/types/kernel/host/patch.d.ts

@@ -7,6 +7,8 @@ export interface HostPatchRuntime {
 /** A self-contained host-side patch contributed to the umbrella plugin. */
 export interface HostPatch {
     readonly id: string;
+    /** Passive lifetime bookkeeping; must not perform the feature's user action. */
+    observe?(ctx: Context): () => void;
     setup?(ctx: Context): () => void;
     routes(runtime: HostPatchRuntime): Readonly<Record<string, PatchApiHandler>>;
 }

package/dist/types/kernel/host/settings.d.ts

@@ -1,5 +1,11 @@
 import type { Context } from '@deepseek-ai/cordis';
+import z from '@deepseek-ai/schemastery';
 import type { HostPatchActivation } from './activation.js';
 export declare const PATCH_SETTINGS_NAMESPACE = "dsh-more";
+export declare const PatchConfig: z<Schemastery.ObjectS<{
+    [k: string]: z<any>;
+}>, Schemastery.ObjectT<{
+    [k: string]: z<any>;
+}>>;
 /** Bind persisted DSH settings to live Host patch activation. */
-export declare function installPatchSettings(ctx: Context, activation: HostPatchActivation): void;
+export declare function installPatchSettings(ctx: Context, activation: HostPatchActivation, config?: unknown): void;

package/dist/types/patches/fast-mode/client/index.d.ts

@@ -0,0 +1,19 @@
+import type { Context as ClientContext } from '@deepseek-ai/cordis';
+import type { ClientPatch } from '../../../kernel/client/patch.js';
+interface SessionFastClientState {
+    active: boolean;
+    busy: boolean;
+}
+declare class FastModeClientStore {
+    private states;
+    private listeners;
+    getState(sessionId?: string): SessionFastClientState;
+    setState(sessionId: string | undefined, next: Partial<SessionFastClientState>): void;
+    subscribe: (listener: () => void) => (() => void);
+    private notify;
+}
+export declare const fastModeClientStore: FastModeClientStore;
+export declare function syncSessionFastState(sessionId: string): Promise<boolean>;
+export declare function toggleFastMode(ctx: ClientContext, sessionId?: string): Promise<void>;
+export declare const clientPatch: ClientPatch;
+export {};

package/dist/types/patches/fast-mode/client/styles.d.ts

@@ -0,0 +1 @@
+export declare const fastModeStyles = "\n.dshmore-fast-btn {\n  box-sizing: border-box;\n  display: inline-flex;\n  align-items: center;\n  justify-content: center;\n  gap: 5px;\n  height: 28px;\n  padding: 0 10px;\n  font-family: var(--dsw-font-family, -apple-system, BlinkMacSystemFont, \"Segoe UI\", Roboto, sans-serif);\n  font-size: 12px;\n  font-weight: 500;\n  line-height: 1;\n  border-radius: 14px;\n  border: 1px solid var(--dsw-alias-border-l2, rgba(128, 128, 128, 0.3));\n  background: var(--dsw-alias-interactive-bg-idle, rgba(128, 128, 128, 0.08));\n  color: var(--dsw-alias-label-primary, inherit);\n  cursor: pointer;\n  transition: all 0.15s ease-in-out;\n  user-select: none;\n  white-space: nowrap;\n  outline: none;\n  margin-right: 6px;\n  flex: none;\n}\n\n.dshmore-fast-btn:hover:not(:disabled) {\n  background: var(--dsw-alias-interactive-bg-hover, rgba(128, 128, 128, 0.18));\n  border-color: var(--dsw-alias-border-l1, rgba(128, 128, 128, 0.5));\n}\n\n.dshmore-fast-btn--active {\n  background: rgba(245, 158, 11, 0.16) !important;\n  color: #f59e0b !important;\n  border-color: #f59e0b !important;\n  box-shadow: 0 0 8px rgba(245, 158, 11, 0.3) !important;\n  font-weight: 600;\n}\n\n.dshmore-fast-btn:disabled,\n.dshmore-fast-btn--busy {\n  opacity: 0.6;\n  cursor: wait;\n}\n\n.dshmore-fast-btn-icon {\n  display: inline-flex;\n  align-items: center;\n  justify-content: center;\n  flex: none;\n  line-height: 1;\n}\n\n.dshmore-fast-btn-label {\n  display: inline-block;\n  line-height: 1;\n}\n";

package/dist/types/patches/fast-mode/host/index.d.ts

@@ -0,0 +1,26 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import type { Context } from '@deepseek-ai/cordis';
+import type { HostPatch } from '../../../kernel/host/patch.js';
+import { type FastModeSettings } from '../shared.js';
+export interface FastModeStore {
+    sessionId?: string | undefined;
+    isFast: boolean;
+}
+export declare const activeFastSessionStorage: AsyncLocalStorage<FastModeStore>;
+export declare function isFastSession(sessionId?: string): boolean;
+export declare function setFastSession(sessionId: string, enabled: boolean): void;
+export declare function toggleFastSession(sessionId: string): boolean;
+export declare function readSettings(ctx: Context): FastModeSettings;
+/** Apply Codex/OpenAI Fast to one outbound model call. Unknown fields such as speed are not invented. */
+export declare function patchFastRequest(input: RequestInfo | URL, init?: RequestInit): {
+    input: RequestInfo | URL;
+    init: RequestInit | undefined;
+};
+/**
+ * The agent loop iterates the model stream after llm/stream listeners return.
+ * Creating the iterator inside AsyncLocalStorage is not enough: the fetch runs
+ * on a later next() call, so each pull re-enters the fast context.
+ */
+export declare function bindFastStream<T>(stream: AsyncIterable<T>, store: FastModeStore): AsyncIterable<T> & AsyncIterator<T>;
+export declare function installFastModeInterceptor(): void;
+export declare const hostPatch: HostPatch;

package/dist/types/patches/fast-mode/shared.d.ts

@@ -0,0 +1,17 @@
+export declare const FAST_MODE_PATCH_ID = "fast-mode";
+export declare const FAST_MODE_SETTINGS_NS = "dsh-more/fast-mode";
+export interface FastModeSettings {
+    /** Whether fast mode is enabled globally by default across all sessions */
+    defaultEnabled: boolean;
+    /** Wire service tier. Codex/CLIProxyAPI only keeps the exact value "priority" for Fast; "fast" is deleted. */
+    serviceTier: string;
+    /** Retained for older settings documents. Not sent on the wire; Fast is a service tier, not a speed field. */
+    speed: number;
+    /** Whether Anthropic hosts also receive the fast-mode beta header */
+    enableAnthropicFastMode: boolean;
+    /** Custom parameters merged into outgoing LLM request body */
+    customBodyParams: Record<string, unknown>;
+    /** Custom headers merged into outgoing LLM request */
+    customHeaders: Record<string, string>;
+}
+export declare const DEFAULT_FAST_MODE_SETTINGS: FastModeSettings;