@adaptiqai/deepseek-harness 0.2.2 → 0.2.4

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;
@@ -699,6 +713,24 @@ function formatPercent(fraction) {
     return "<1%";
   return `${Math.min(100, Math.round(fraction * 100))}%`;
 }
+var QUIET_START_MS = 2e3;
+var LANES_FRESH_MS = 3e4;
+function waitKind(request, lanes, refreshedAt, now) {
+  if (request.phase === "preparing")
+    return "preparing";
+  if (request.phase === "queued")
+    return "lane";
+  if (request.phase !== "starting")
+    return null;
+  if (request.since !== null && now - request.since < QUIET_START_MS)
+    return null;
+  const total = lanes?.lanes ?? null;
+  const running = lanes?.runningNow ?? null;
+  const fresh = refreshedAt !== null && now - refreshedAt <= LANES_FRESH_MS;
+  if (request.laneHeld !== true && fresh && total !== null && total > 0 && running !== null && running >= total)
+    return "lane";
+  return "starting";
+}
 
 // ../core/lib/catalog.js
 var obj = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
@@ -1243,6 +1275,11 @@ 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 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 ?? ""}`;
 }
@@ -1418,6 +1455,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). */
@@ -1516,8 +1557,10 @@ var Workspace = class {
     this.purchases.dispose();
     clearTimeout(this.timer);
     clearTimeout(this.attachTimer);
-    for (const session of this.sessions.values())
+    for (const session of this.sessions.values()) {
       clearTimeout(session.timer);
+      clearTimeout(session.waitTimer);
+    }
     this.listeners.clear();
   }
   /** Record that the provider route belongs to someone else. */
@@ -1635,7 +1678,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?.();
@@ -1670,8 +1714,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) {
@@ -1688,19 +1741,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();
@@ -1713,8 +1780,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() {
@@ -2049,6 +2121,10 @@ var Workspace = class {
         onAdaptiq: route === void 0 ? null : route.provider === this.deps.route,
         phase: "idle",
         phaseSince: null,
+        inflight: 0,
+        laneHeld: false,
+        retry: null,
+        failedNow: false,
         model: route?.provider === this.deps.route ? route.model : null,
         selected: null,
         lastUsed: null,
@@ -2061,6 +2137,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);
@@ -2090,6 +2169,7 @@ var Workspace = class {
       remember: this.remember(id),
       phase: session.phase,
       phaseSince: session.phaseSince,
+      waiting: this.waiting(session),
       model: session.model,
       modelName: this.modelName(session.model),
       selectedModel: session.selected,
@@ -2137,13 +2217,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.
@@ -2230,42 +2326,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;
@@ -2289,6 +2366,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;
@@ -2304,6 +2382,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.
@@ -2322,6 +2477,38 @@ var Workspace = class {
     session.phase = phase;
     session.phaseSince = this.now();
     this.emitSession(session);
+    this.watchWait(session);
+  }
+  /** What the conversation's request waits for, as the composer says it. */
+  waiting(session) {
+    const entry = this.catalog.find((item) => item.id === session.model);
+    return waitKind({ phase: session.phase, since: session.phaseSince, laneHeld: session.laneHeld }, entry ?? null, this.refreshedAt, this.now());
+  }
+  /**
+   * A request that stays quiet past {@link QUIET_START_MS} gets a word: look
+   * again then, with the lane counts read fresh when they are older than that.
+   */
+  watchWait(session) {
+    clearTimeout(session.waitTimer);
+    if (session.phase !== "starting" || this.disposed)
+      return;
+    const check = () => {
+      if (session.phase !== "starting" || this.disposed)
+        return;
+      this.emitSession(session);
+      const stale = this.refreshedAt === null || this.now() - this.refreshedAt > 1e4;
+      if (stale && !session.laneHeld && this.deps.auth.phase() === "connected") {
+        void this.refresh().then(() => {
+          if (session.phase === "starting")
+            this.emitSession(session);
+        }, () => {
+        });
+      }
+      session.waitTimer = setTimeout(check, 15e3);
+      session.waitTimer.unref?.();
+    };
+    session.waitTimer = setTimeout(check, QUIET_START_MS);
+    session.waitTimer.unref?.();
   }
   // RequestEvents — the adapter reports each request here.
   started(sessionId2, model2) {
@@ -2330,7 +2517,13 @@ var Workspace = class {
     const session = this.session(sessionId2);
     session.onAdaptiq = true;
     session.model = model2;
-    this.setPhase(session, "preparing");
+    session.notOn.delete(model2);
+    session.backoff = null;
+    session.inflight++;
+    session.laneHeld = false;
+    session.failedNow = false;
+    const retry = session.retry !== null && session.retry.until > this.now() ? session.retry : null;
+    this.setPhase(session, retry?.phase ?? "starting");
   }
   progress(sessionId2, stage) {
     if (sessionId2 === void 0)
@@ -2340,14 +2533,26 @@ var Workspace = class {
       return;
     if (stage === "inference.queued")
       this.setPhase(session, "queued");
-    else if (stage === "context.preparing" || stage === "request.accepted")
+    else if (stage === "context.preparing")
       this.setPhase(session, "preparing");
+    else if (stage === "context.ready" || stage === "inference.ready") {
+      if (stage === "inference.ready")
+        session.laneHeld = true;
+      session.retry = null;
+      if (session.phase === "starting")
+        this.emitSession(session);
+      else
+        this.setPhase(session, "starting");
+    }
   }
   output(sessionId2) {
     if (sessionId2 === void 0)
       return;
-    this.setPhase(this.session(sessionId2), "responding");
-    this.clearNotices("busy", "preparing", "offline");
+    const session = this.session(sessionId2);
+    session.laneHeld = true;
+    session.retry = null;
+    this.setPhase(session, "responding");
+    this.clearNotices("busy", "preparing", "offline", "retrying");
   }
   usage(sessionId2, model2, usage2) {
     if (sessionId2 === void 0)
@@ -2382,8 +2587,13 @@ var Workspace = class {
       message: failure.message
     });
     this.failures.length = Math.min(this.failures.length, 12);
-    if (sessionId2 !== void 0)
-      this.setPhase(this.session(sessionId2), "interrupted");
+    if (sessionId2 !== void 0) {
+      const session = this.session(sessionId2);
+      session.failedNow = true;
+      const waits = RETRYABLE_CODES.includes(failure.code) && (failure.notice === "busy" || failure.notice === "preparing");
+      session.retry = waits ? { phase: failure.notice === "busy" ? "queued" : "preparing", until: this.now() + (failure.retryAfterMs ?? 3e4) + 15e3 } : null;
+      this.setPhase(session, session.retry?.phase ?? "interrupted");
+    }
     const entry = this.catalog.find((item) => item.id === model2);
     const name2 = entry?.name ?? model2;
     switch (failure.notice) {
@@ -2425,8 +2635,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;
@@ -2436,8 +2658,23 @@ var Workspace = class {
     if (sessionId2 === void 0)
       return;
     const session = this.session(sessionId2);
-    if (session.phase !== "interrupted")
-      this.setPhase(session, "idle");
+    session.inflight = Math.max(0, session.inflight - 1);
+    if (session.failedNow && session.retry !== null) {
+      const retry = session.retry;
+      clearTimeout(session.waitTimer);
+      session.waitTimer = setTimeout(() => {
+        if (session.inflight === 0 && session.retry === retry) {
+          session.retry = null;
+          this.setPhase(session, "interrupted");
+        }
+      }, Math.max(0, retry.until - this.now()));
+      session.waitTimer.unref?.();
+    } else {
+      if (!session.failedNow)
+        session.retry = null;
+      if (session.phase !== "interrupted")
+        this.setPhase(session, "idle");
+    }
     if (session.listeners.size > 0) {
       setTimeout(() => {
         void this.loadSession(session);

package/lib/types/client/Connect.d.ts

@@ -1,18 +1,39 @@
-import type { AccountSnapshot } from '@adaptiqai/core/types';
+import type { AccountPhase, AccountSnapshot } from '@adaptiqai/core/types';
 import type { Kit } from './actions.ts';
 import { type T } from './ui.tsx';
+/** How long "Connected" stays before the card moves on by itself. */
+export declare const CONNECTED_MOMENT_MS = 1500;
+/**
+ * The moment right after the browser approval: true from the switch
+ * signing-in → connected until {@link CONNECTED_MOMENT_MS} later or dismiss.
+ * @param phase - the account phase, or null before it is known.
+ * @returns whether to show it, and how to end it early.
+ */
+export declare function useConnectedMoment(phase: AccountPhase | null, ms?: number): {
+    show: boolean;
+    dismiss: () => void;
+};
+/** "Connected to <workspace>": the stones settle, a check lands. Clicking anywhere ends it. */
+export declare function ConnectedMoment({ t, workspace, onClose }: {
+    t: T;
+    workspace: string | null;
+    onClose: () => void;
+}): import("react").JSX.Element;
 /** The code split in two halves of boxed characters. */
 export declare function DeviceCode({ code }: {
     code: string;
 }): import("react").JSX.Element;
 /**
  * Hero content for each sign-in state. Lives on a navy hero surface.
- * @param props - account snapshot, kit, translate.
+ * @param props - account snapshot, kit, translate, and a quiet second action (Later, Cancel).
  * @returns the hero body.
  */
-export declare function ConnectHero({ account, kit, t, compact }: {
+export declare function ConnectHero({ account, kit, t, aside }: {
     account: AccountSnapshot | null;
     kit: Kit;
     t: T;
-    compact?: boolean;
+    aside?: {
+        label: string;
+        onClick: () => void;
+    };
 }): import("react").JSX.Element;

package/lib/types/client/SettingsPage.d.ts

@@ -1,4 +1,4 @@
-import type { AccountSnapshot, ModelView } from '@adaptiqai/core/types';
+import type { AccountSnapshot, MemoryView, ModelView } from '@adaptiqai/core/types';
 import type { Kit } from './actions.ts';
 import { type T } from './ui.tsx';
 type Hook<S> = <R>(select: (snapshot: S) => R) => R;
@@ -7,6 +7,15 @@ export interface SettingsProps {
     kit: Kit;
     useAqAccount: Hook<AccountSnapshot | null>;
 }
+/** The fullness chip: green below 70 %, amber to 90 %, red above. */
+export declare function MemoryChip({ store }: {
+    store: MemoryView;
+}): import("react").JSX.Element;
+/** The store's bar, in the same colour as its chip. */
+export declare function MemoryBar({ store, thin }: {
+    store: MemoryView;
+    thin?: boolean;
+}): import("react").JSX.Element;
 /**
  * A model's facts, the same fields in the same order for every model:
  * memory, thinking levels, region. A field is left out only when unknown.

package/lib/types/client/pill.d.ts

@@ -0,0 +1,59 @@
+/** The composer pill's words and timing, kept apart from React so they can be tested. */
+import type { WaitKind } from '@adaptiqai/core/types';
+type T = (key: string, params?: Record<string, unknown>) => string;
+/** How long "+24.6k from memory" stays after a reply. */
+export declare const AFTER_REPLY_MS = 4000;
+/** How long the count-up to that figure takes. */
+export declare const COUNT_UP_MS = 900;
+/**
+ * The pill's words while a request waits.
+ * @param t - translate.
+ * @param kind - what the request waits for.
+ * @returns e.g. "Waiting for a free lane".
+ */
+export declare function waitText(t: T, kind: WaitKind): string;
+/**
+ * The pill's words after a reply, split around the figure so it can be set heavier.
+ * @param t - translate.
+ * @param fromMemory - tokens the reply read from memory (shown so far, while counting up).
+ * @returns e.g. { before: '', figure: '+24.6k', after: ' from memory' }.
+ */
+export declare function afterReplyParts(t: T, fromMemory: number): {
+    before: string;
+    figure: string;
+    after: string;
+};
+/**
+ * The pill's words after a reply.
+ * @param t - translate.
+ * @param fromMemory - tokens the reply read from memory.
+ * @returns e.g. "+24.6k from memory".
+ */
+export declare function afterReplyText(t: T, fromMemory: number): string;
+/**
+ * The figure partway through the count-up: fast at first, settling softly.
+ * @param target - the final figure.
+ * @param elapsed - ms since the count-up began.
+ * @param duration - ms the count-up takes.
+ * @returns the figure to show now.
+ */
+export declare function countUp(target: number, elapsed: number, duration?: number): number;
+/**
+ * Follows a conversation's last turn and reports a new reply that read from
+ * memory for {@link AFTER_REPLY_MS}. The turn already there when the view
+ * first arrives is history, not news.
+ */
+export declare class AfterReply {
+    private readonly onChange;
+    private readonly ms;
+    private baseline;
+    private timer;
+    constructor(onChange: (fromMemory: number | null) => void, ms?: number);
+    /** The conversation's view arrived or changed. */
+    seen(turn: {
+        readonly at: number;
+        readonly fromMemory: number;
+    } | null): void;
+    dispose(): void;
+}
+export {};