stratagate-dsh 0.2.78 → 0.2.79

package/dist/plugin.js

@@ -5751,6 +5751,7 @@ var DshModelBridge = class {
     this.structuredReasoningEffort = config.structuredReasoningEffort ?? "auto";
     this.ctx.on?.("llm/adapters-updated", () => {
       this.offCapabilities.clear();
+      for (const listener of this.adaptersUpdatedListeners) listener();
     });
   }
   ctx;
@@ -5759,7 +5760,24 @@ var DshModelBridge = class {
   successfulResponses = [];
   offCapabilities = /* @__PURE__ */ new Map();
   warnedOffFallbackRoutes = /* @__PURE__ */ new Set();
+  adaptersUpdatedListeners = /* @__PURE__ */ new Set();
   structuredReasoningEffort;
+  /** True only when the exact provider route has a registered DSH adapter. */
+  isReady(session) {
+    try {
+      const { provider } = this.resolveRoute(session);
+      return this.ctx.llm.listProviders().some(({ id }) => id === provider);
+    } catch {
+      return false;
+    }
+  }
+  /** Wake durable workers when DSH changes the adapter registry. */
+  onAdaptersUpdated(listener) {
+    this.adaptersUpdatedListeners.add(listener);
+    return () => {
+      this.adaptersUpdatedListeners.delete(listener);
+    };
+  }
   setStructuredReasoningEffort(mode) {
     this.structuredReasoningEffort = mode;
   }
@@ -5970,6 +5988,7 @@ var DshModelBridge = class {
     let lastError;
     let lastResponse = "";
     let attemptsUsed = 0;
+    let noAdapterRetried = false;
     for (let attempt = 1; attempt <= JSON_RESPONSE_ATTEMPTS; attempt += 1) {
       attemptsUsed = attempt;
       const message = createUserMessage({
@@ -6000,6 +6019,11 @@ ${JSON_RETRY_INSTRUCTION}`,
       try {
         await this.consumeStructuredStream(request, assembler);
       } catch (error) {
+        if (!noAdapterRetried && isNoAdapter(error)) {
+          noAdapterRetried = true;
+          attempt -= 1;
+          continue;
+        }
         if (useOff && isOffRejection(error)) {
           this.offCapabilities.set(routeKey, "unsupported");
           useOff = false;
@@ -6012,6 +6036,11 @@ ${JSON_RETRY_INSTRUCTION}`,
       const finish = assembler.finish;
       if (finish.kind === "error" || finish.kind === "aborted") {
         const failure = new Error(`StrataGate model call failed [${finish.failure.code}]: ${finish.failure.message}`);
+        if (!noAdapterRetried && isNoAdapter(finish.failure)) {
+          noAdapterRetried = true;
+          attempt -= 1;
+          continue;
+        }
         if (useOff && isOffRejection(finish.failure)) {
           this.offCapabilities.set(routeKey, "unsupported");
           useOff = false;
@@ -6177,6 +6206,17 @@ ${JSON_RETRY_INSTRUCTION}`,
     return { provider: fallback.provider, model: fallback.model };
   }
 };
+function isNoAdapter(error) {
+  const seen = /* @__PURE__ */ new Set();
+  let current = error;
+  while (current && typeof current === "object" && !seen.has(current)) {
+    seen.add(current);
+    const candidate = current;
+    if (candidate.code === "NO_ADAPTER") return true;
+    current = candidate.cause;
+  }
+  return false;
+}
 function isOffRejection(error) {
   let detail;
   try {
@@ -6618,6 +6658,7 @@ var StrataGateRuntime = class {
     this.openPath = openPath;
     this.blockTurnSize = config.blockTurnSize;
     this.blockDecayLambda = config.blockDecayLambda;
+    this.disposeAdaptersUpdated = this.models.onAdaptersUpdated(() => this.wakeModelWorkers());
     this.scheduleBackgroundWorker(BACKGROUND_WORKER_INITIAL_DELAY_MS);
   }
   config;
@@ -6632,6 +6673,7 @@ var StrataGateRuntime = class {
   latestBatchIds = /* @__PURE__ */ new Map();
   workspaceNames = /* @__PURE__ */ new Map();
   migrationTimers = /* @__PURE__ */ new Map();
+  migrationRuns = /* @__PURE__ */ new Map();
   derivationTimers = /* @__PURE__ */ new Map();
   derivationRuns = /* @__PURE__ */ new Map();
   knownSessions = /* @__PURE__ */ new Map();
@@ -6650,6 +6692,8 @@ var StrataGateRuntime = class {
   backgroundNamespaceRuns = /* @__PURE__ */ new Map();
   backgroundWorkerTimer;
   backgroundWorkerRun;
+  backgroundWorkerWakePending = false;
+  disposeAdaptersUpdated;
   settingsTail = Promise.resolve();
   batchSequence = 0;
   closed = false;
@@ -6665,13 +6709,15 @@ var StrataGateRuntime = class {
       this.backgroundWorkerRun = run;
       void run.finally(() => {
         if (this.backgroundWorkerRun === run) this.backgroundWorkerRun = void 0;
-        this.scheduleBackgroundWorker(BACKGROUND_WORKER_INTERVAL_MS);
+        const delay = this.backgroundWorkerWakePending ? 0 : BACKGROUND_WORKER_INTERVAL_MS;
+        this.backgroundWorkerWakePending = false;
+        this.scheduleBackgroundWorker(delay);
       });
     }, delayMs);
     this.backgroundWorkerTimer.unref?.();
   }
   async runBackgroundWorker() {
-    if (this.closed) return;
+    if (this.closed || !this.models.isReady()) return;
     let namespaces;
     try {
       namespaces = await this.adminNamespaces();
@@ -6689,6 +6735,7 @@ var StrataGateRuntime = class {
     }
   }
   async runBackgroundNamespace(namespace) {
+    if (this.closed || !this.models.isReady()) return;
     const existing = this.backgroundNamespaceRuns.get(namespace);
     if (existing) return existing;
     const run = (async () => {
@@ -6704,9 +6751,11 @@ var StrataGateRuntime = class {
         const hasActiveSessionWork = [
           ...this.derivationTimers.keys(),
           ...this.derivationRuns.keys(),
-          ...this.migrationTimers.keys()
+          ...this.migrationTimers.keys(),
+          ...this.migrationRuns.keys()
         ].some((key) => key.startsWith(`${namespace}\0`) || key === namespace);
         if (hasActiveSessionWork) return;
+        if (!this.models.isReady()) return;
         const resumed = await this.models.runDetached(
           `stratagate-worker:${namespace}`,
           () => memory.resumePendingWork()
@@ -6734,6 +6783,33 @@ var StrataGateRuntime = class {
       if (this.backgroundNamespaceRuns.get(namespace) === run) this.backgroundNamespaceRuns.delete(namespace);
     }
   }
+  wakeBackgroundWorker() {
+    if (this.closed) return;
+    if (this.backgroundWorkerTimer) {
+      clearTimeout(this.backgroundWorkerTimer);
+      this.backgroundWorkerTimer = void 0;
+    }
+    if (this.backgroundWorkerRun) {
+      this.backgroundWorkerWakePending = true;
+      return;
+    }
+    this.scheduleBackgroundWorker(0);
+  }
+  wakeModelWorkers() {
+    if (this.closed) return;
+    this.wakeBackgroundWorker();
+    for (const reference of this.knownSessions.values()) {
+      const session = reference.deref();
+      if (!session || !this.models.isReady(session)) continue;
+      const opening = this.spaces.get(this.namespaceFor(session));
+      if (!opening) continue;
+      void opening.then((memory) => {
+        if (this.closed || !this.models.isReady(session)) return;
+        this.scheduleGraphMigration(session, memory);
+        this.scheduleBlockDerivation(session, memory);
+      }).catch((error) => this.onIngestError(error));
+    }
+  }
   acceptEvent(session, event) {
     if (this.closed) return;
     if (!this.config.ingestSubagents && session.header.origin === "subagent") return;
@@ -7217,6 +7293,7 @@ var StrataGateRuntime = class {
   async close() {
     if (this.closed) return;
     this.closed = true;
+    this.disposeAdaptersUpdated();
     if (this.backgroundWorkerTimer) clearTimeout(this.backgroundWorkerTimer);
     this.backgroundWorkerTimer = void 0;
     for (const timer of this.migrationTimers.values()) clearTimeout(timer);
@@ -7234,6 +7311,7 @@ var StrataGateRuntime = class {
     const settled = await Promise.allSettled(this.spaces.values());
     await Promise.allSettled(this.backgroundNamespaceRuns.values());
     if (this.backgroundWorkerRun) await Promise.allSettled([this.backgroundWorkerRun]);
+    await Promise.allSettled(this.migrationRuns.values());
     await Promise.allSettled(this.derivationRuns.values());
     await Promise.allSettled(this.externalImportRuns.values());
     await Promise.all(settled.flatMap((result) => result.status === "fulfilled" ? [result.value.close()] : []));
@@ -7770,6 +7848,9 @@ var StrataGateRuntime = class {
           if (kind === "event-extraction") return memory.retryEventExtraction(jobId);
           return memory.retryGraphProjection(jobId);
         };
+        if (!this.models.isReady(session)) {
+          throw new Error("StrataGate model adapter is not ready; retry after DSH finishes registering adapters");
+        }
         const result = session && this.namespaceFor(session) === key ? await this.models.run(session, retry) : await this.models.runDetached(threadId, retry);
         await this.persistSuccessfulResponses(memory);
         const currentBlock = blockId ? memory.listBlocks().find(({ id: candidateId }) => candidateId === blockId) : void 0;
@@ -7969,7 +8050,7 @@ var StrataGateRuntime = class {
   scheduleBlockDerivation(session, memory) {
     const threadId = String(session.id);
     const key = `${this.namespaceFor(session)}\0${threadId}`;
-    if (this.closed || this.derivationTimers.has(key) || this.derivationRuns.has(key)) return;
+    if (this.closed || !this.models.isReady(session) || this.derivationTimers.has(key) || this.derivationRuns.has(key)) return;
     const pendingBlockIds = new Set(memory.listBlocks().filter((block) => block.threadId === threadId && block.processingStatus === "pending").map((block) => block.id));
     if (pendingBlockIds.size === 0) return;
     const retryTimes = [
@@ -7980,7 +8061,7 @@ var StrataGateRuntime = class {
     const delay = Math.max(0, Math.min(...retryTimes) - Date.now());
     const timer = setTimeout(() => {
       this.derivationTimers.delete(key);
-      if (this.closed) return;
+      if (this.closed || !this.models.isReady(session)) return;
       const failedBefore = this.failedCoreJobs(memory);
       const run = this.models.run(session, () => memory.resumePendingWork({ threadId })).then(async (resumed) => {
         await this.persistSuccessfulResponses(memory);
@@ -8008,24 +8089,29 @@ var StrataGateRuntime = class {
   }
   scheduleGraphMigration(session, memory) {
     const namespace = this.namespaceFor(session);
-    if (this.closed || this.migrationTimers.has(namespace)) return;
+    if (this.closed || !this.models.isReady(session) || this.migrationTimers.has(namespace) || this.migrationRuns.has(namespace)) return;
     if (typeof memory.listGraphProjectionJobs !== "function") return;
     const pending = memory.listGraphProjectionJobs().some((job) => graphProjectionCanRun(job));
     if (!pending) return;
     const timer = setTimeout(() => {
       this.migrationTimers.delete(namespace);
-      if (this.closed) return;
+      if (this.closed || !this.models.isReady(session)) return;
       const failedBefore = this.failedCoreJobs(memory);
       const completedBefore = memory.listGraphProjectionJobs().filter(({ status }) => status === "completed").length;
-      void this.models.run(session, () => memory.resumePendingWork()).then(async () => {
+      let madeProgress = false;
+      const run = this.models.run(session, () => memory.resumePendingWork()).then(async () => {
         await this.persistSuccessfulResponses(memory);
         this.noteNewCoreJobFailures(session, failedBefore, memory);
         const completedAfter = memory.listGraphProjectionJobs().filter(({ status }) => status === "completed").length;
-        if (completedAfter > completedBefore) this.scheduleGraphMigration(session, memory);
+        madeProgress = completedAfter > completedBefore;
       }).catch((error) => {
         this.notePluginError(session, error);
         this.onIngestError(error);
+      }).finally(() => {
+        if (this.migrationRuns.get(namespace) === run) this.migrationRuns.delete(namespace);
+        if (madeProgress) this.scheduleGraphMigration(session, memory);
       });
+      this.migrationRuns.set(namespace, run);
     }, 1500);
     timer.unref?.();
     this.migrationTimers.set(namespace, timer);