@adaptiqai/deepseek-harness 0.2.2 → 0.2.3

package/lib/index.js

@@ -699,6 +699,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;
@@ -1516,8 +1534,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. */
@@ -2049,6 +2069,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,
@@ -2090,6 +2114,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,
@@ -2322,6 +2347,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 +2387,11 @@ var Workspace = class {
     const session = this.session(sessionId2);
     session.onAdaptiq = true;
     session.model = model2;
-    this.setPhase(session, "preparing");
+    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,13 +2401,25 @@ 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");
+    const session = this.session(sessionId2);
+    session.laneHeld = true;
+    session.retry = null;
+    this.setPhase(session, "responding");
     this.clearNotices("busy", "preparing", "offline");
   }
   usage(sessionId2, model2, usage2) {
@@ -2382,8 +2455,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) {
@@ -2436,8 +2514,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 {};

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

@@ -3,11 +3,15 @@ import { type ReactNode } from 'react';
 import { formatTokens } from '@adaptiqai/core/format';
 /** Translate with the plugin's dictionary. */
 export type T = (key: string, params?: Record<string, unknown>) => string;
-/** The cairn: three coral stones under one ink stone. */
-export declare function Cairn({ size, alive, onDark }: {
+/**
+ * The cairn: three coral stones under one ink stone. `settle` stacks them as
+ * it appears, bottom stone first (about 600 ms in all).
+ */
+export declare function Cairn({ size, alive, onDark, settle }: {
     size?: number;
     alive?: boolean;
     onDark?: boolean;
+    settle?: boolean;
 }): import("react").JSX.Element;
 /** The AdaptiqAI wordmark in the current text colour. */
 export declare function Wordmark({ height }: {
@@ -25,13 +29,15 @@ export declare function Ring({ fraction, size, stroke }: {
     size?: number;
     stroke?: number;
 }): import("react").JSX.Element;
-/** A segmented usage bar. */
-export declare function UsageBar({ segments, warn, thin }: {
+/** How full a meter reads; the bar and the percentage chip share it. */
+export type MeterTone = 'ok' | 'filling' | 'full';
+/** A segmented usage bar, coloured by how full it is. */
+export declare function UsageBar({ segments, tone, thin }: {
     segments: readonly {
         cls: string;
         fraction: number;
     }[];
-    warn?: boolean;
+    tone: MeterTone;
     thin?: boolean;
 }): import("react").JSX.Element;
 /** Compact token text. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adaptiqai/deepseek-harness",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "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.2"
+    "@adaptiqai/core": "0.2.3"
   },
   "repository": {
     "type": "git",