@adaptiqai/deepseek-harness 0.2.3 → 0.2.5

package/lib/index.js

@@ -140,7 +140,10 @@ function classifyFailure(status, raw, headers, model2) {
     return make(CODES.invalidRequest, `AdaptiqAI couldn't accept this request${said}.`, null);
   }
   if (effective !== null && effective >= 500) {
-    return make(CODES.server, "AdaptiqAI couldn't answer just now. It will retry automatically.", "offline");
+    const who = model2 ?? "AdaptiqAI";
+    if (effective === 503)
+      return make(CODES.server, `${model2 ?? "This model"} is offline right now. It will retry automatically.`, "retrying");
+    return make(CODES.server, `${who} didn't answer just now. It will retry automatically.`, "retrying");
   }
   if (effective === null) {
     return make(CODES.server, detail.message !== null ? `AdaptiqAI stopped the reply: ${detail.message.slice(0, 200)}` : "AdaptiqAI stopped the reply.", null);
@@ -149,18 +152,29 @@ function classifyFailure(status, raw, headers, model2) {
 }
 function transportFailure(error) {
   const name2 = error instanceof Error ? error.name : "";
-  const timeout = name2 === "TimeoutError";
+  const cause = error instanceof Error ? error.cause?.code : void 0;
+  const timeout = name2 === "TimeoutError" || cause === "UND_ERR_HEADERS_TIMEOUT" || cause === "UND_ERR_BODY_TIMEOUT";
   return {
     code: timeout ? CODES.timeout : CODES.transport,
-    message: timeout ? "AdaptiqAI took too long to answer. It will retry automatically." : "AdaptiqAI couldn't be reached. Check your internet connection; the request will retry automatically.",
+    message: timeout ? "AdaptiqAI took too long to answer. It will retry automatically." : "AdaptiqAI can't be reached right now. It will retry automatically.",
     status: null,
     requestId: null,
     retryAfterMs: null,
     serverType: null,
     serverCode: null,
-    notice: "offline"
+    notice: timeout ? "retrying" : "offline"
   };
 }
+function failureReach(failure) {
+  if (failure.code === CODES.transport)
+    return "unreachable";
+  if (failure.code === CODES.timeout)
+    return "transient";
+  return failure.status !== null && failure.status >= 500 && failure.status !== 507 ? "transient" : null;
+}
+function errorReach(error) {
+  return error instanceof AdaptiqHttpError ? failureReach(error.failure) : null;
+}
 var AdaptiqHttpError = class extends Error {
   failure;
   body;
@@ -1261,6 +1275,27 @@ var str4 = (value) => typeof value === "string" && value.trim() !== "" ? value.t
 var count2 = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : null;
 var DEFAULT_PREFERENCES = { rememberByDefault: true, welcomed: false };
 var PAGE = 50;
+var ATTACH_POLL_MS = 15e3;
+var ATTACH_BACKOFF_MAX_MS = 10 * 6e4;
+var ATTACH_DEADLINE_MS = 6 * 36e5;
+var MODEL_ROUTE_CODES = /* @__PURE__ */ new Set(["memory_route_required", "model_required", "model_mismatch"]);
+function attachBackoffMs(failures) {
+  return Math.min(ATTACH_BACKOFF_MAX_MS, ATTACH_POLL_MS * 2 ** Math.min(Math.max(failures - 1, 0), 10));
+}
+function routeChoices(detail) {
+  if (!Array.isArray(detail.models))
+    return null;
+  return detail.models.flatMap((raw) => {
+    const entry = obj4(raw);
+    const id = typeof raw === "string" ? raw : str4(entry?.id) ?? str4(entry?.model);
+    return id === null || id === "" ? [] : [id];
+  });
+}
+var TROUBLE_QUIET_MS = 6e4;
+var SESSION_BACKOFF_MAX_MS = 5 * 6e4;
+function sessionBackoffMs(failures) {
+  return Math.min(SESSION_BACKOFF_MAX_MS, 3e4 * 2 ** Math.max(1, failures));
+}
 function copyKey(source, target) {
   return `${source}\0${target ?? ""}`;
 }
@@ -1436,6 +1471,10 @@ var Workspace = class {
   catalog = [];
   catalogKey = "";
   catalogAt = 0;
+  /** The last `/v1/models` rows read: one stalled engine can fail the list for a while. */
+  modelRows = [];
+  /** Background reads have failed for a passing reason since `since`. */
+  trouble = null;
   offers = [];
   checkoutMode = null;
   /** Offer id → what the account summary says about it (model id, console link). */
@@ -1655,7 +1694,8 @@ var Workspace = class {
       return;
     this.timer = setTimeout(() => {
       void this.refresh().finally(() => {
-        this.schedule(this.listeners.size > 0 ? this.deps.watchedRefreshMs : this.deps.refreshMs);
+        const normal = this.listeners.size > 0 ? this.deps.watchedRefreshMs : this.deps.refreshMs;
+        this.schedule(this.trouble === null ? normal : Math.min(normal, 15e3 * 2 ** Math.min(this.trouble.failures - 1, 6)));
       });
     }, ms);
     this.timer.unref?.();
@@ -1690,8 +1730,17 @@ var Workspace = class {
         this.setCatalog([]);
         return;
       }
-      const rows = await this.deps.api.json("/v1/models");
-      const data = Array.isArray(rows?.data) ? rows.data : [];
+      let data;
+      try {
+        const rows = await this.deps.api.json("/v1/models");
+        data = Array.isArray(rows?.data) ? rows.data : [];
+        this.modelRows = data;
+      } catch (error) {
+        if (errorReach(error) === null || this.modelRows.length === 0)
+          throw error;
+        this.deps.log?.("warn", `adaptiq: model list unavailable, keeping the last one: ${error instanceof Error ? error.message : String(error)}`);
+        data = this.modelRows;
+      }
       const summary2 = await this.loadSummary();
       let availability;
       if (summary2 !== null) {
@@ -1708,19 +1757,33 @@ var Workspace = class {
       if (this.memory === null || !this.memory.available)
         await this.loadFallbackMemory();
       this.lastError = null;
+      this.trouble = null;
       this.refreshedAt = this.now();
       this.evaluateNotices();
     } catch (error) {
       const failure = error instanceof AdaptiqHttpError ? error.failure : null;
       this.lastError = { code: failure?.code ?? "UNKNOWN", message: failure?.message ?? (error instanceof Error ? error.message : String(error)), at: this.now() };
-      if (failure?.notice === "offline")
-        this.raise({ kind: "offline", tone: "warning", title: "AdaptiqAI can't be reached", body: "Your models stay listed; requests will work again once the connection is back.", actions: [{ id: "refresh", label: "Try again" }] });
+      const reach = failure === null ? null : failureReach(failure);
+      if (reach !== null) {
+        const since = this.trouble?.since ?? this.now();
+        this.trouble = { since, reach, failures: (this.trouble?.failures ?? 0) + 1 };
+        if (this.now() - since >= TROUBLE_QUIET_MS)
+          this.raiseTrouble(reach);
+      }
       this.deps.log?.("warn", `adaptiq: refresh failed: ${this.lastError.message}`);
     } finally {
       this.loading = false;
       this.publish();
     }
   }
+  /**
+   * Say, calmly, that background reads keep failing: "busy" while AdaptiqAI
+   * answers with errors, "can't be reached" only when there is no connection.
+   * @param reach - the kind of trouble.
+   */
+  raiseTrouble(reach) {
+    this.raise(reach === "unreachable" ? { kind: "offline", tone: "warning", title: "AdaptiqAI can't be reached", body: "Retrying automatically. Your models and conversations stay as they are.", actions: [{ id: "refresh", label: "Try again" }] } : { kind: "offline", tone: "info", title: "AdaptiqAI is busy \u2014 retrying", body: "Your models and conversations stay as they are. This usually clears by itself.", actions: [] });
+  }
   setCatalog(models) {
     const key = JSON.stringify(models);
     this.catalogAt = this.now();
@@ -1733,8 +1796,13 @@ var Workspace = class {
       if (session.listeners.size === 0)
         continue;
       this.emitSession(session);
-      if (!session.exists)
+      const awaited = session.backoff?.model ?? null;
+      if (awaited !== null && !this.modelDown(awaited)) {
+        session.backoff = null;
         this.pollSession(session, 0);
+      } else if (!session.exists && session.remoteAt === 0) {
+        this.pollSession(session, 0);
+      }
     }
   }
   async loadSummary() {
@@ -2085,6 +2153,9 @@ var Workspace = class {
         knowledge: [],
         conversations: [],
         remoteAt: 0,
+        home: null,
+        notOn: /* @__PURE__ */ new Set(),
+        backoff: null,
         listeners: /* @__PURE__ */ new Set()
       };
       this.sessions.set(id, session);
@@ -2162,13 +2233,29 @@ var Workspace = class {
     clearTimeout(session.timer);
     if (this.disposed || session.listeners.size === 0)
       return;
+    const wait = session.backoff === null ? 0 : session.backoff.until - this.now();
     session.timer = setTimeout(() => {
       void this.loadSession(session).finally(() => {
         this.pollSession(session, sessionPollDelay(session));
       });
-    }, ms);
+    }, Math.max(ms, wait));
     session.timer.unref?.();
   }
+  /** @returns whether a model's instance is offline or disabled (not asked about conversations). */
+  modelDown(id) {
+    const status = this.catalog.find((entry) => entry.id === id)?.status;
+    return status === "offline" || status === "disabled";
+  }
+  /**
+   * Read a conversation less often after a failed read or while its model is
+   * offline: 1, 2, 4, then every 5 minutes.
+   * @param session - the conversation.
+   * @param model - the offline model it waits for, or null after a failed read.
+   */
+  backOff(session, model2) {
+    const failures = (session.backoff?.failures ?? 0) + 1;
+    session.backoff = { failures, until: this.now() + sessionBackoffMs(failures), model: model2 };
+  }
   /**
    * The memory store a conversation's knowledge and memory live in: where it is
    * stored once it exists, otherwise the model selected for it.
@@ -2255,42 +2342,23 @@ var Workspace = class {
             return;
           session.model = route.model;
         }
-        const path = `/v1/sessions/${encodeURIComponent(session.id)}`;
-        let body = null;
-        let routed = false;
-        let suggested = [];
-        try {
-          body = await this.deps.api.json(path, { allow: [404] });
-          routed = true;
-        } catch (error) {
-          if (!(error instanceof AdaptiqHttpError) || error.status !== 409 && error.status !== 400)
-            throw error;
-          const models = obj4(obj4(error.body)?.detail)?.models;
-          if (Array.isArray(models))
-            suggested = models.filter((model2) => typeof model2 === "string" && model2 !== "");
-        }
-        const candidates = routed ? [] : session.model !== null ? [session.model] : suggested.length > 0 ? suggested.slice(0, 6) : [...this.catalog].sort((a, b) => Number(b.status === "running") - Number(a.status === "running")).map((entry) => entry.id).slice(0, 6);
-        for (const model2 of candidates) {
-          body = await this.deps.api.json(path, { headers: { "x-adaptiq-model": model2 }, allow: [404] });
-          if (body !== null) {
-            if (session.model === null) {
-              session.model = model2;
-              session.onAdaptiq ??= true;
-            }
-            break;
-          }
-        }
-        if (routed && body !== null) {
-          const served = str4(obj4(body.session)?.model) ?? str4(body.model);
-          if (served !== null)
-            session.model = served;
-          else if (session.model === null && session.lastUsed !== null)
-            session.model = session.lastUsed;
-          session.onAdaptiq ??= true;
+        const found = await this.findSession(session);
+        if (found === void 0) {
+          session.remoteAt = this.now();
+          return;
         }
-        if (routed || candidates.length > 0)
+        session.backoff = null;
+        if (found.asked)
           session.remoteAt = this.now();
+        const body = found.body;
         if (body === null) {
+          if (session.exists) {
+            session.memoryTokens = null;
+            session.saved = null;
+            session.optimizing = false;
+            session.revision = null;
+            session.conversations = [];
+          }
           session.exists = false;
           session.knowledge = [];
           return;
@@ -2314,6 +2382,7 @@ var Workspace = class {
           session.conversations = await this.attachedConversations(session).catch(() => session.conversations);
       } catch (error) {
         session.remoteAt = this.now();
+        this.backOff(session, null);
         this.deps.log?.("warn", `adaptiq: could not read conversation ${session.id}: ${error instanceof Error ? error.message : String(error)}`);
         if (!(error instanceof AdaptiqHttpError))
           throw error;
@@ -2329,6 +2398,83 @@ var Workspace = class {
         session.loading = void 0;
     }
   }
+  /**
+   * Find a conversation on the server. Once a model has answered for it, only
+   * that model is asked. Before that, the session-aware route (which needs no
+   * model), then, on gateways that want one, the conversation's model or the
+   * models the gateway names: never a model that is offline or that already
+   * said the conversation is not there.
+   * @param session - the conversation.
+   * @returns its body (null when the server does not have it) and whether
+   *   anything could be asked, or undefined when its model is offline (backed off).
+   */
+  async findSession(session) {
+    const path = `/v1/sessions/${encodeURIComponent(session.id)}`;
+    const ask = async (model2) => {
+      try {
+        return await this.deps.api.json(path, { headers: { "x-adaptiq-model": model2 }, allow: [404] });
+      } catch (error) {
+        if (error instanceof AdaptiqHttpError && error.status === 409)
+          return null;
+        throw error;
+      }
+    };
+    if (session.home !== null) {
+      const home = session.home;
+      if (this.modelDown(home)) {
+        this.backOff(session, home);
+        return void 0;
+      }
+      const body = await ask(home);
+      if (body === null) {
+        session.home = null;
+        session.notOn.add(home);
+      } else
+        session.model = home;
+      return { body, asked: true };
+    }
+    let suggested = [];
+    try {
+      const body = await this.deps.api.json(path, { allow: [404] });
+      if (body !== null) {
+        const served = str4(obj4(body.session)?.model) ?? str4(body.model);
+        if (served !== null) {
+          session.model = served;
+          session.home = served;
+        } else if (session.model === null && session.lastUsed !== null)
+          session.model = session.lastUsed;
+        session.onAdaptiq ??= true;
+      }
+      return { body, asked: true };
+    } catch (error) {
+      if (!(error instanceof AdaptiqHttpError) || error.status !== 409 && error.status !== 400)
+        throw error;
+      const models = obj4(obj4(error.body)?.detail)?.models;
+      if (Array.isArray(models))
+        suggested = models.filter((model2) => typeof model2 === "string" && model2 !== "");
+    }
+    const listed = session.model !== null ? [session.model] : suggested.length > 0 ? suggested : [...this.catalog].sort((a, b) => Number(b.status === "running") - Number(a.status === "running")).map((entry) => entry.id);
+    const open = listed.filter((model2) => !session.notOn.has(model2)).slice(0, 6);
+    const candidates = open.filter((model2) => !this.modelDown(model2));
+    for (const model2 of candidates) {
+      const body = await ask(model2);
+      if (body !== null) {
+        session.home = model2;
+        if (session.model === null) {
+          session.model = model2;
+          session.onAdaptiq ??= true;
+        }
+        return { body, asked: true };
+      }
+      session.notOn.add(model2);
+    }
+    const offline = open.find((model2) => this.modelDown(model2));
+    if (offline !== void 0) {
+      this.backOff(session, offline);
+      return void 0;
+    }
+    return { body: null, asked: candidates.length > 0 };
+  }
   /**
    * Choose whether new messages of a conversation are saved.
    * @param id - harness session id.
@@ -2387,6 +2533,8 @@ var Workspace = class {
     const session = this.session(sessionId2);
     session.onAdaptiq = true;
     session.model = model2;
+    session.notOn.delete(model2);
+    session.backoff = null;
     session.inflight++;
     session.laneHeld = false;
     session.failedNow = false;
@@ -2420,7 +2568,7 @@ var Workspace = class {
     session.laneHeld = true;
     session.retry = null;
     this.setPhase(session, "responding");
-    this.clearNotices("busy", "preparing", "offline");
+    this.clearNotices("busy", "preparing", "offline", "retrying");
   }
   usage(sessionId2, model2, usage2) {
     if (sessionId2 === void 0)
@@ -2503,8 +2651,20 @@ var Workspace = class {
       case "model-unavailable":
         this.raise({ kind: "model-unavailable", tone: "warning", title: `${name2} isn't available`, body: failure.message, actions: [{ id: "open-models", label: "See your models", url: this.links.models }] });
         break;
+      case "retrying": {
+        const offline = entry?.status === "offline";
+        this.raise({
+          kind: "retrying",
+          tone: "info",
+          title: offline ? `${name2} is offline` : `${name2} didn't answer just now`,
+          body: offline ? "Your request retries by itself. Your other AdaptiqAI models still work; pick one to continue now." : "Your request retries by itself.",
+          actions: [],
+          ...sessionId2 === void 0 ? {} : { sessionId: sessionId2 }
+        });
+        break;
+      }
       case "offline":
-        this.raise({ kind: "offline", tone: "warning", title: "AdaptiqAI can't be reached", body: failure.message, actions: [] });
+        this.raise({ kind: "offline", tone: "warning", title: "AdaptiqAI can't be reached", body: "Your request retries by itself once the connection is back.", actions: [], ...sessionId2 === void 0 ? {} : { sessionId: sessionId2 } });
         break;
       default:
         break;
@@ -2555,7 +2715,10 @@ var Workspace = class {
     if (session !== void 0 && this.now() - session.remoteAt > 1e4)
       await this.loadSession(session).catch(() => {
       });
-    const target = model2 !== void 0 && this.catalog.some((entry) => entry.id === model2) ? model2 : this.targetModel(session) ?? null;
+    const named = model2 !== void 0 && model2 !== "" && (this.catalog.length === 0 || this.catalog.some((entry) => entry.id === model2));
+    const target = named ? model2 : this.targetModel(session) ?? null;
+    if (target === null)
+      return { model: null, modelName: null, items: [], nextCursor: null, hasMore: false, summary: null };
     const attached = new Set(session?.knowledge.map((item) => item.id) ?? []);
     const name2 = (id) => this.modelName(id);
     const read = async (store, limit, after) => {
@@ -2564,7 +2727,7 @@ var Workspace = class {
         params.set("query", query.trim().slice(0, 200));
       if (after !== void 0 && after !== "")
         params.set("cursor", after);
-      const body = await this.deps.api.json(`/v1/memories?${params}`, { headers: store === null ? {} : { "x-adaptiq-model": store } });
+      const body = await this.deps.api.json(`/v1/memories?${params}`, { headers: { "x-adaptiq-model": store } });
       const items = (Array.isArray(body?.data) ? body.data : []).flatMap((raw) => {
         const memory = obj4(raw);
         return memory === null ? [] : [knowledgeItem(memory, store === target && attached.has(String(memory.memory_id)), { store, target, name: name2 })];
@@ -2574,13 +2737,13 @@ var Workspace = class {
     const here = await read(target, PAGE, cursor);
     await this.followCopies(target);
     let elsewhere = [];
-    if ((cursor === void 0 || cursor === "") && target !== null) {
+    if (cursor === void 0 || cursor === "") {
       const others = this.catalog.filter((entry) => entry.id !== target && entry.status !== "disabled").slice(0, 3);
       const pages = await Promise.all(others.map((entry) => read(entry.id, 20).catch(() => ({ items: [], pagination: null }))));
       const seen = new Set(here.items.map((item) => item.id));
       const copied = new Set([...this.copies.values()].filter((copy) => copy.target === target && copy.status === "ready").map((copy) => copy.source));
       const names = new Set(here.items.filter((item) => item.fits).map((item) => item.name));
-      const copyable = target !== null && this.catalog.some((entry) => entry.id === target);
+      const copyable = this.catalog.some((entry) => entry.id === target);
       elsewhere = pages.flatMap((page) => page.items).filter((item) => !seen.has(item.id) && !copied.has(item.id) && !names.has(item.name)).map((item) => {
         const copy = this.copies.get(copyKey(item.id, target));
         return { ...item, fits: false, attached: false, convertible: copyable && item.kind === "collection", copying: copy === void 0 || copy.status === "ready" ? null : copy.status };
@@ -2591,7 +2754,7 @@ var Workspace = class {
     const misfits = here.items.filter((item) => !item.fits);
     return {
       model: target,
-      modelName: target === null ? null : this.modelName(target),
+      modelName: this.modelName(target),
       items: [...fitting, ...misfits, ...elsewhere],
       nextCursor: str4(here.pagination?.next_cursor),
       hasMore: here.pagination?.has_more === true,
@@ -2790,7 +2953,8 @@ var Workspace = class {
         await this.setKnowledge(input.attachToSession, id, true).catch(() => {
         });
       else {
-        this.pendingAttach.set(id, { sessionId: input.attachToSession, at: this.now() });
+        const model2 = str4(memory.model) ?? this.memoryModel(session) ?? null;
+        this.pendingAttach.set(id, { sessionId: input.attachToSession, at: this.now(), model: model2, failures: 0, next: this.now() });
         this.scheduleAttach(1e4);
       }
     }
@@ -2805,25 +2969,102 @@ var Workspace = class {
     }, ms);
     this.attachTimer.unref?.();
   }
+  /**
+   * Read the collections waiting to be attached, each in its own model's store,
+   * and attach the ones that are ready.
+   */
   async attachReady() {
+    const groups = /* @__PURE__ */ new Map();
+    for (const [id, pending] of [...this.pendingAttach]) {
+      if (this.now() - pending.at > ATTACH_DEADLINE_MS) {
+        this.pendingAttach.delete(id);
+        continue;
+      }
+      if (pending.next > this.now())
+        continue;
+      const model2 = pending.model ?? this.targetModel(this.session(pending.sessionId));
+      if (model2 === void 0)
+        continue;
+      groups.set(model2, [...groups.get(model2) ?? [], [id, pending]]);
+    }
+    for (const [model2, entries] of groups) {
+      try {
+        await this.attachCheck(model2, entries);
+      } catch {
+      }
+    }
+    if (this.pendingAttach.size === 0)
+      return;
+    const now = this.now();
+    this.scheduleAttach(Math.min(...[...this.pendingAttach.values()].map((pending) => pending.next > now ? pending.next - now : ATTACH_POLL_MS)));
+  }
+  async attachCheck(model2, entries) {
+    let items = null;
     try {
-      const page = await this.listKnowledge();
-      for (const [id, pending] of [...this.pendingAttach]) {
-        const item = page.items.find((candidate) => candidate.id === id);
-        if (this.now() - pending.at > 6 * 36e5 || item?.status === "failed") {
-          this.pendingAttach.delete(id);
-          continue;
-        }
-        if (item?.status === "ready") {
+      items = await this.waitingKnowledge(model2);
+    } catch (error) {
+      const detail = error instanceof AdaptiqHttpError && error.status === 409 ? obj4(obj4(error.body)?.detail) : null;
+      const code = str4(detail?.code);
+      if (detail === null || code === null || !MODEL_ROUTE_CODES.has(code)) {
+        for (const [, pending] of entries)
+          pending.next = this.now() + ATTACH_POLL_MS;
+        return;
+      }
+      const choices = routeChoices(detail);
+      if (choices !== null && choices.length > 0 && !choices.includes(model2)) {
+        const name2 = this.modelName(model2) ?? model2;
+        for (const [id, pending] of entries) {
           this.pendingAttach.delete(id);
-          await this.setKnowledge(pending.sessionId, id, true).catch(() => {
+          this.raise({
+            kind: "model-unavailable",
+            tone: "info",
+            title: `${name2} isn't available`,
+            body: `Your new collection is saved. Add it from Knowledge once ${name2} is available again.`,
+            actions: [{ id: "open-models", label: "See your models", url: this.links.models }],
+            sessionId: pending.sessionId
           });
-          this.raise({ kind: "connected", tone: "success", title: `${item.name} is ready`, body: "It is now used in your conversation.", actions: [], sessionId: pending.sessionId });
         }
+        return;
+      }
+      const pick = choices?.find((choice) => choice === model2);
+      if (pick !== void 0)
+        items = await this.waitingKnowledge(pick).catch(() => null);
+      if (items === null) {
+        for (const [, pending] of entries) {
+          pending.failures += 1;
+          pending.next = this.now() + attachBackoffMs(pending.failures);
+        }
+        return;
       }
-    } catch {
     }
-    this.scheduleAttach(15e3);
+    for (const [id, pending] of entries) {
+      const item = items.find((candidate) => candidate.id === id);
+      pending.failures = 0;
+      pending.next = this.now() + ATTACH_POLL_MS;
+      if (item?.status === "failed") {
+        this.pendingAttach.delete(id);
+        continue;
+      }
+      if (item?.status === "ready") {
+        this.pendingAttach.delete(id);
+        await this.setKnowledge(pending.sessionId, id, true).catch(() => {
+        });
+        this.raise({ kind: "connected", tone: "success", title: `${item.name} is ready`, body: "It is now used in your conversation.", actions: [], sessionId: pending.sessionId });
+      }
+    }
+  }
+  /**
+   * One model's collections, for the ones waiting to be attached.
+   * @param model - the store to read.
+   * @returns the collections.
+   */
+  async waitingKnowledge(model2) {
+    const params = new URLSearchParams({ limit: String(PAGE), status: "all" });
+    const body = await this.deps.api.json(`/v1/memories?${params}`, { headers: { "x-adaptiq-model": model2 } });
+    return (Array.isArray(body?.data) ? body.data : []).flatMap((raw) => {
+      const memory = obj4(raw);
+      return memory === null ? [] : [knowledgeItem(memory, false)];
+    });
   }
   // ---------------------------------------------------------------- conversations as knowledge
   /** False once the server answered that it has no conversation routes. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adaptiqai/deepseek-harness",
-  "version": "0.2.3",
+  "version": "0.2.5",
   "description": "AdaptiqAI for DeepSeek Harness: models with 5M-token native memory and Knowledge. Sign up, get a model and work without leaving the harness",
   "keywords": [
     "dsh-plugin",
@@ -89,7 +89,7 @@
     "react-dom": "~18.3.1",
     "typescript": "~5.9.3",
     "vitest": "~3.2.7",
-    "@adaptiqai/core": "0.2.3"
+    "@adaptiqai/core": "0.2.5"
   },
   "repository": {
     "type": "git",