stratagate-dsh 0.2.57 → 0.2.60

package/dist/index.js

@@ -5,6 +5,9 @@ import { createUserMessage as createUserMessage3 } from "@deepseek-ai/dsh-llm";
 
 // src/config.ts
 import z from "@deepseek-ai/schemastery";
+var StructuredReasoningEffortSettings = z.object({
+  structuredReasoningEffort: z.union(["auto", "force-off"]).default("auto").description("\u8BB0\u5FC6\u5904\u7406\u7ED3\u6784\u5316\u8C03\u7528\u7684\u63A8\u7406\u6863\u4F4D\u7B56\u7565").comment("auto\uFF1A\u4EC5\u5728\u6A21\u578B\u660E\u786E\u652F\u6301 off \u65F6\u4F7F\u7528\uFF1Bforce-off\uFF1A\u4F18\u5148\u4F7F\u7528 off\uFF0C\u4E0D\u652F\u6301\u6216\u80FD\u529B\u68C0\u67E5\u5931\u8D25\u65F6\u5B89\u5168\u964D\u7EA7\uFF0C\u5E76\u5BF9\u540C\u4E00\u6A21\u578B\u53EA\u544A\u8B66\u4E00\u6B21\u3002")
+});
 var Config = z.object({
   database: z.string().required(),
   namespaceMode: z.union(["project", "session", "global"]).default("project"),
@@ -16,7 +19,8 @@ var Config = z.object({
   provider: z.string(),
   model: z.string(),
   maxOutputTokens: z.natural().min(256).default(2048),
-  structuredTaskTimeoutMs: z.natural().min(1e3).default(45e3)
+  structuredTaskTimeoutMs: z.natural().min(1e3).default(12e4),
+  structuredReasoningEffort: z.union(["auto", "force-off"]).default("auto")
 });
 function resolveConfig(config) {
   const database = config.database?.trim() ?? "";
@@ -38,7 +42,8 @@ function resolveConfig(config) {
     ingestSubagents: config.ingestSubagents ?? false,
     ...provider && model ? { provider, model } : {},
     maxOutputTokens: Math.max(256, Math.floor(config.maxOutputTokens ?? 2048)),
-    structuredTaskTimeoutMs: Math.max(1e3, Math.floor(config.structuredTaskTimeoutMs ?? 45e3))
+    structuredTaskTimeoutMs: Math.max(1e3, Math.floor(config.structuredTaskTimeoutMs ?? 12e4)),
+    structuredReasoningEffort: config.structuredReasoningEffort ?? "auto"
   };
 }
 
@@ -4744,7 +4749,7 @@ function extractorPayload(context) {
 }
 var JSON_RESPONSE_ATTEMPTS = 2;
 var JSON_RETRY_INSTRUCTION = "Your previous response did not make one valid call to the requested tool. Do not spend output on analysis or reasoning. Immediately call that tool exactly once with complete arguments. Do not return an answer as text or markdown.";
-var DEFAULT_STRUCTURED_TIMEOUT_MS = 45e3;
+var DEFAULT_STRUCTURED_TIMEOUT_MS = 12e4;
 var STRUCTURED_FIELDS = {
   summarizer: ["l0Title", "l0Tags", "l1Summary", "l2Keypoints", "shouldExtract"],
   extractor: ["shouldExtract", "reason", "events"],
@@ -4918,6 +4923,7 @@ var DshModelBridge = class {
   constructor(ctx, config) {
     this.ctx = ctx;
     this.config = config;
+    this.structuredReasoningEffort = config.structuredReasoningEffort ?? "auto";
     this.ctx.on?.("llm/adapters-updated", () => {
       this.offCapabilities.clear();
     });
@@ -4927,6 +4933,11 @@ var DshModelBridge = class {
   sessions = new AsyncLocalStorage();
   successfulResponses = [];
   offCapabilities = /* @__PURE__ */ new Map();
+  warnedOffFallbackRoutes = /* @__PURE__ */ new Set();
+  structuredReasoningEffort;
+  setStructuredReasoningEffort(mode) {
+    this.structuredReasoningEffort = mode;
+  }
   run(session, operation) {
     return this.sessions.run({ session, sessionId: session.id }, operation);
   }
@@ -5146,7 +5157,7 @@ ${JSON_RETRY_INSTRUCTION}`,
         if (useOff && isOffRejection(error)) {
           this.offCapabilities.set(routeKey, "unsupported");
           useOff = false;
-          this.ctx.logger.warn(`stratagate-memory ${baseRoute.provider}/${baseRoute.model} rejected reasoningEffort=off; retrying once without it`);
+          this.warnOffFallbackOnce(routeKey, `${baseRoute.provider}/${baseRoute.model} rejected reasoningEffort=off; retrying once without it`);
           attempt -= 1;
           continue;
         }
@@ -5158,7 +5169,7 @@ ${JSON_RETRY_INSTRUCTION}`,
         if (useOff && isOffRejection(finish.failure)) {
           this.offCapabilities.set(routeKey, "unsupported");
           useOff = false;
-          this.ctx.logger.warn(`stratagate-memory ${baseRoute.provider}/${baseRoute.model} rejected reasoningEffort=off; retrying once without it`);
+          this.warnOffFallbackOnce(routeKey, `${baseRoute.provider}/${baseRoute.model} rejected reasoningEffort=off; retrying once without it`);
           attempt -= 1;
           continue;
         }
@@ -5236,8 +5247,19 @@ ${JSON_RETRY_INSTRUCTION}`,
   async shouldUseOff(route) {
     const key = `${route.provider}\0${route.model}`;
     const cached = this.offCapabilities.get(key);
-    if (cached) return cached === "supported";
-    if (typeof this.ctx.llm.resolveModelInfo !== "function") return true;
+    if (cached) {
+      if (cached === "unsupported" && this.structuredReasoningEffort === "force-off") {
+        this.warnOffFallbackOnce(key, `${route.provider}/${route.model} does not support reasoningEffort=off; using the model default`);
+      }
+      return cached === "supported";
+    }
+    if (typeof this.ctx.llm.resolveModelInfo !== "function") {
+      this.offCapabilities.set(key, "unsupported");
+      if (this.structuredReasoningEffort === "force-off") {
+        this.warnOffFallbackOnce(key, `${route.provider}/${route.model} capabilities are unavailable; using the model default`);
+      }
+      return false;
+    }
     const controller = new AbortController();
     const lookupTimeoutMs = Math.min(5e3, this.config.structuredTaskTimeoutMs ?? DEFAULT_STRUCTURED_TIMEOUT_MS);
     let timer;
@@ -5252,16 +5274,28 @@ ${JSON_RETRY_INSTRUCTION}`,
           timer.unref?.();
         })
       ]);
-      if (!info.reasoning) return true;
+      if (!info.reasoning) return this.structuredReasoningEffort === "force-off";
       const supported = info.reasoning.efforts.some(({ id }) => String(id) === "off");
       this.offCapabilities.set(key, supported ? "supported" : "unsupported");
+      if (!supported && this.structuredReasoningEffort === "force-off") {
+        this.warnOffFallbackOnce(key, `${route.provider}/${route.model} does not support reasoningEffort=off; using the model default`);
+      }
       return supported;
     } catch {
-      return true;
+      this.offCapabilities.set(key, "unsupported");
+      if (this.structuredReasoningEffort === "force-off") {
+        this.warnOffFallbackOnce(key, `${route.provider}/${route.model} capability lookup failed; using the model default`);
+      }
+      return false;
     } finally {
       if (timer) clearTimeout(timer);
     }
   }
+  warnOffFallbackOnce(routeKey, message) {
+    if (this.warnedOffFallbackRoutes.has(routeKey)) return;
+    this.warnedOffFallbackRoutes.add(routeKey);
+    this.ctx.logger.warn(`stratagate-memory ${message}`);
+  }
   async consumeStructuredStream(request, assembler) {
     const timeoutMs = this.config.structuredTaskTimeoutMs ?? DEFAULT_STRUCTURED_TIMEOUT_MS;
     const controller = new AbortController();
@@ -5529,6 +5563,10 @@ var DshMetadataStore = class {
 };
 
 // src/runtime.ts
+var DRAIN_THRESHOLD = 3;
+var DRAIN_EAGER_MS = 150;
+var DRAIN_BASE_BACKOFF_MS = 2e3;
+var DRAIN_MAX_BACKOFF_MS = 6e4;
 var AUTO_EVENT_LIMIT = 4;
 var AUTO_ELEMENT_LIMIT = 4;
 var AUTO_MEMORY_TOKEN_BUDGET = 900;
@@ -5601,11 +5639,15 @@ var StrataGateRuntime = class {
   externalImportRuns = /* @__PURE__ */ new Map();
   feedbackDrafts = /* @__PURE__ */ new Map();
   pendingFeedbackSuggestionSessions = /* @__PURE__ */ new Set();
-  ingestTail = Promise.resolve();
+  pendingTurns = /* @__PURE__ */ new Map();
+  drainTimers = /* @__PURE__ */ new Map();
+  drainBackoffMs = /* @__PURE__ */ new Map();
+  drainTails = /* @__PURE__ */ new Map();
+  drainErrors = /* @__PURE__ */ new Map();
+  sessionsById = /* @__PURE__ */ new Map();
   settingsTail = Promise.resolve();
   batchSequence = 0;
   closed = false;
-  ingestError;
   blockTurnSize;
   blockDecayLambda;
   transientLastFeedbackPromptAt = null;
@@ -5614,20 +5656,89 @@ var StrataGateRuntime = class {
     if (!this.config.ingestSubagents && session.header.origin === "subagent") return;
     const turn = this.folder.accept(session, event);
     if (!turn) return;
-    this.ingestTail = this.ingestTail.catch(() => {
-    }).then(async () => {
-      const memory = await this.space(session);
-      try {
-        const result = await memory.appendTurn(turn, { deferDerivation: true });
-        if (result.sealedBlock) this.scheduleBlockDerivation(session, memory);
-      } finally {
-        await this.persistSuccessfulResponses(memory);
-      }
-    }).catch((error) => {
-      this.ingestError = error;
+    const key = String(session.id);
+    this.sessionsById.set(key, session);
+    const queued = this.pendingTurns.get(key) ?? [];
+    queued.push(turn);
+    this.pendingTurns.set(key, queued);
+    this.scheduleDrain(session);
+  }
+  /** Serialize drains per session while allowing unrelated sessions to settle independently. */
+  enqueueDrain(session) {
+    const key = String(session.id);
+    const prior = this.drainTails.get(key) ?? Promise.resolve();
+    const next = prior.catch(() => {
+    }).then(() => this.drain(session));
+    this.drainTails.set(key, next);
+    void next.then(() => {
+      if ((this.pendingTurns.get(key)?.length ?? 0) === 0) this.drainErrors.delete(key);
+    }, (error) => {
+      this.drainErrors.set(key, error);
       this.notePluginError(session, error);
       this.onIngestError(error);
     });
+    return next;
+  }
+  /** Batch short bursts and retry failed drains with bounded exponential backoff. */
+  scheduleDrain(session, overrideDelayMs) {
+    const key = String(session.id);
+    if (this.closed) return;
+    const queued = this.pendingTurns.get(key)?.length ?? 0;
+    if (queued === 0) return;
+    const delay = overrideDelayMs ?? (queued >= DRAIN_THRESHOLD ? DRAIN_EAGER_MS : Math.min(this.drainBackoffMs.get(key) ?? DRAIN_BASE_BACKOFF_MS, DRAIN_MAX_BACKOFF_MS));
+    const pending = this.drainTimers.get(key);
+    if (pending) {
+      if (delay >= DRAIN_BASE_BACKOFF_MS) return;
+      clearTimeout(pending);
+      this.drainTimers.delete(key);
+    }
+    const timer = setTimeout(() => {
+      this.drainTimers.delete(key);
+      if (this.closed) return;
+      void this.enqueueDrain(session).then(() => {
+        this.drainBackoffMs.delete(key);
+        if ((this.pendingTurns.get(key)?.length ?? 0) > 0) {
+          this.scheduleDrain(session, DRAIN_BASE_BACKOFF_MS);
+        }
+      }, () => {
+        const backoff = this.drainBackoffMs.get(key) ?? DRAIN_BASE_BACKOFF_MS;
+        this.drainBackoffMs.set(key, Math.min(backoff * 2, DRAIN_MAX_BACKOFF_MS));
+        const pendingRetry = this.drainTimers.get(key);
+        if (pendingRetry) clearTimeout(pendingRetry);
+        this.drainTimers.delete(key);
+        this.scheduleDrain(session);
+      });
+    }, delay);
+    timer.unref?.();
+    this.drainTimers.set(key, timer);
+  }
+  /**
+   * Persist one detached batch. On failure, the failed and unvisited turns are
+   * restored ahead of turns that arrived meanwhile, preserving original order.
+   */
+  async drain(session) {
+    const key = String(session.id);
+    const turns = this.pendingTurns.get(key);
+    if (!turns || turns.length === 0) return;
+    this.pendingTurns.delete(key);
+    let completed = 0;
+    let memory;
+    try {
+      memory = await this.space(session);
+      for (const turn of turns) {
+        const result = await memory.appendTurn(turn, { deferDerivation: true });
+        completed += 1;
+        if (result.sealedBlock) this.scheduleBlockDerivation(session, memory);
+      }
+    } catch (error) {
+      const remaining = turns.slice(completed);
+      if (remaining.length > 0) {
+        this.pendingTurns.set(key, [...remaining, ...this.pendingTurns.get(key) ?? []]);
+      }
+      throw error;
+    } finally {
+      if (memory) await this.persistSuccessfulResponses(memory);
+    }
   }
   async searchEvents(session, query, options = {}) {
     await this.flush();
@@ -5996,9 +6107,18 @@ var StrataGateRuntime = class {
   }
   // Keep the ingestion error for callers that explicitly require a flushed run.
   async settleIngestion() {
-    await this.ingestTail;
-    const error = this.ingestError;
-    this.ingestError = void 0;
+    do {
+      for (const [key, session] of this.sessionsById) {
+        if ((this.pendingTurns.get(key)?.length ?? 0) === 0) continue;
+        const timer = this.drainTimers.get(key);
+        if (timer) clearTimeout(timer);
+        this.drainTimers.delete(key);
+        this.enqueueDrain(session);
+      }
+      await Promise.allSettled(this.drainTails.values());
+    } while (this.drainErrors.size === 0 && [...this.pendingTurns.values()].some((turns) => turns.length > 0));
+    const error = this.drainErrors.values().next().value;
+    this.drainErrors.clear();
     return error;
   }
   async close() {
@@ -6006,6 +6126,8 @@ var StrataGateRuntime = class {
     this.closed = true;
     for (const timer of this.migrationTimers.values()) clearTimeout(timer);
     this.migrationTimers.clear();
+    for (const timer of this.drainTimers.values()) clearTimeout(timer);
+    this.drainTimers.clear();
     for (const timer of this.derivationTimers.values()) clearTimeout(timer);
     this.derivationTimers.clear();
     let flushError;
@@ -6018,6 +6140,7 @@ var StrataGateRuntime = class {
     await Promise.allSettled(this.derivationRuns.values());
     await Promise.allSettled(this.externalImportRuns.values());
     await Promise.all(settled.flatMap((result) => result.status === "fulfilled" ? [result.value.close()] : []));
+    this.sessionsById.clear();
     if (flushError !== void 0) throw flushError;
   }
   namespaceFor(session) {
@@ -6890,8 +7013,9 @@ function renderMessages(messages) {
 }
 function dshTurnAtBlockEnd(session, block) {
   const blockEnd = Date.parse(block.createdAt);
-  for (let index = session.events.length - 1; index >= 0; index -= 1) {
-    const event = session.events[index];
+  const events = session.snapshotEvents();
+  for (let index = events.length - 1; index >= 0; index -= 1) {
+    const event = events[index];
     if (event?.type === "turn/end" && event.time === blockEnd) return event.data.turn;
   }
   throw new Error(`Cannot match StrataGate block ${block.id} to its completed DSH turn`);
@@ -6901,13 +7025,14 @@ function sealedSurfaceSeqs(session, endTurn, turnCount) {
   const currentSet = new Set(currentSurface);
   const completed = [];
   let open;
-  for (const event of session.events) {
+  const events = session.snapshotEvents();
+  for (const event of events) {
     if (event.type === "turn/start") {
       open = { turn: event.data.turn, start: event.seq };
       continue;
     }
     if (event.type !== "turn/end" || !open || event.data.turn !== open.turn) continue;
-    const turnEvents = session.events.slice(open.start + 1, event.seq);
+    const turnEvents = events.slice(open.start + 1, event.seq);
     const hasHumanMessage = turnEvents.some((candidate) => candidate.type === "user/message" && candidate.data.source.kind === "user");
     if (hasHumanMessage && event.data.turn <= endTurn) {
       completed.push({
@@ -7026,7 +7151,7 @@ function currentBlockSurfaceMessages(session) {
   const blocks = /* @__PURE__ */ new Map();
   if (!session.surface?.nodes) return blocks;
   for (const seq of session.surface.nodes) {
-    const event = session.events[seq];
+    const event = session.eventAt(seq);
     if (event?.type !== "user/message" || event.data.source.kind !== "plugin" || event.data.source.plugin !== COMPACTION_SOURCE_PLUGIN) continue;
     const text3 = event.data.content.flatMap((block) => block.type === "text" ? [block.text] : []).join("\n");
     const blockId = text3.match(/^\[StrataGate conversation block\]\nBlock: ([^\n]+)/u)?.[1] ?? text3.match(/^\[StrataGate compressed conversation\]\nBlock ([^;\n]+);/u)?.[1];
@@ -7126,8 +7251,9 @@ KnowledgeGraph:
   return lines.join("\n");
 }
 function activeTurn(session) {
-  for (let index = session.events.length - 1; index >= 0; index -= 1) {
-    const event = session.events[index];
+  const events = session.snapshotEvents();
+  for (let index = events.length - 1; index >= 0; index -= 1) {
+    const event = events[index];
     if (event?.type === "turn/start") return event.data.turn;
   }
   return void 0;
@@ -8299,6 +8425,7 @@ function registerAdminRoutes(ctx, runtime) {
 // src/index.ts
 var name = "stratagate-memory";
 var inject = ["tools", "systemPrompt", "llm", "agentDefaultModel"];
+var STRATAGATE_SETTINGS_NAMESPACE = "stratagate-memory";
 var MEMORY_PROTOCOL = `[StrataGate memory protocol]
 StrataGate provides durable, evidence-gated memory through memory_* tools.
 
@@ -8336,6 +8463,24 @@ async function apply(ctx, config) {
     await ctx.sessions.flush(session);
   }, () => feedbackWebOrigin(ctx));
   await runtime.syncConfiguredSettings();
+  const effortEntry = {
+    structuredReasoningEffort: resolved.structuredReasoningEffort ?? "auto"
+  };
+  let effortSource = () => effortEntry;
+  ctx.inject(["settings"], (settingsCtx) => {
+    settingsCtx.settings.installSection(
+      ctx,
+      STRATAGATE_SETTINGS_NAMESPACE,
+      StructuredReasoningEffortSettings,
+      effortEntry,
+      {
+        setSource: (current) => {
+          effortSource = current;
+        },
+        onChange: () => models.setStructuredReasoningEffort(effortSource().structuredReasoningEffort)
+      }
+    );
+  });
   ctx.systemPrompt.section({ name: "tool:stratagate-memory", order: 113, text: MEMORY_PROTOCOL });
   ctx.systemPrompt.section({ name: "tool:stratagate-feedback", order: 114, text: FEEDBACK_PROTOCOL });
   ctx.on("system-prompt/assemble", async (_assembly, context, next) => {
@@ -8381,6 +8526,7 @@ async function apply(ctx, config) {
 }
 export {
   Config,
+  STRATAGATE_SETTINGS_NAMESPACE,
   apply,
   inject,
   name