akanjs 3.0.0-alpha.43 → 3.0.0-alpha.44

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akanjs",
-  "version": "3.0.0-alpha.43",
+  "version": "3.0.0-alpha.44",
   "sourceType": "module",
   "type": "module",
   "publishConfig": {

package/store/agent/StoreSurfaceSource.ts

@@ -4,7 +4,6 @@ import { AgentBridge } from "./AgentBridge";
 import { ScreenReader } from "./ScreenReader";
 import { ScreenSettle } from "./ScreenSettle";
 import { ScreenTarget } from "./ScreenTarget";
-import { StateWait } from "./StateWait";
 
 /**
  * The tools every akan screen has whatever it declares: where it can go, what it is rendering, what one of the
@@ -39,7 +38,6 @@ export class StoreSurfaceSource implements SurfaceSource {
         StoreSurfaceSource.#goBack(),
         StoreSurfaceSource.#readScreen(viewKey),
         this.#readState(viewKey),
-        this.#waitFor(viewKey),
         StoreSurfaceSource.#highlight(viewKey),
       ];
       this.#builtins.set(viewKey, builtins);
@@ -192,65 +190,6 @@ export class StoreSurfaceSource implements SurfaceSource {
     };
   }
 
-  /**
-   * The wait that costs no model turns.
-   *
-   * An agent that started something slow has one way to learn it finished: ask again, and again, a full round trip
-   * per look. That burns the turn budget in seconds and reads to the user as a loop. This parks the call instead —
-   * the session already awaits `run`, so the turn simply takes as long as the work does, and the change report
-   * that follows carries whatever landed while it waited.
-   *
-   * It watches a published state key rather than sleeping for a fixed span. A bare sleep would only make the
-   * polling slower, and a screen that can report progress at all reports it into the store; a screen that reports
-   * none publishes a key with `st.expose`, which is worth doing anyway, since the key is then readable too.
-   */
-  #waitFor(viewKey: string): ToolEntry {
-    return {
-      name: "waitFor",
-      description:
-        "Wait here until one of this page's state keys settles, instead of asking again and again. Use it after starting something slow — a generation, an upload, a long job — whenever a state key reports how it is going: the turn pauses with no model round trip and resumes the moment the key moves. Keys are listed in the state context block. Returns what the key holds when the wait ends.",
-      parameters: {
-        type: "object",
-        properties: {
-          key: { type: "string", description: "The state key to watch, spelled as the state context block lists it." },
-          equals: {
-            type: "string",
-            description:
-              "Wait until the key reads exactly this, compared as text. Omit to wait until it changes from whatever it holds now.",
-          },
-          timeoutSeconds: {
-            type: "number",
-            description: `How long to wait before answering with the key's current value. Default ${StateWait.defaultSeconds}, maximum ${StateWait.maxSeconds}. Running out is not a failure — call waitFor again to keep waiting.`,
-          },
-        },
-        required: ["key"],
-        additionalProperties: false,
-      },
-
-      effect: "state",
-      run: async (args) => {
-        this.#bridge ??= AgentBridge.of();
-        const key = typeof args.key === "string" ? args.key.trim() : "";
-        if (!key) throw new Error("waitFor needs a key to watch.");
-        const live = this.#bridge.readableKeys(viewKey);
-        if (!live.includes(key))
-          throw new Error(
-            `No state key named ${key} is read by this screen. ${
-              live.length
-                ? `Keys here: ${live.join(", ")}.`
-                : "This screen reads no state keys, so there is nothing to wait for."
-            }`,
-          );
-        return await new StateWait(this.#bridge, {
-          key,
-          viewKey,
-          equals: typeof args.equals === "string" ? args.equals : null,
-          seconds: args.timeoutSeconds,
-        }).run();
-      },
-    };
-  }
-
   /**
    * The ring goes on once the scroll lands, not when it starts: a smooth scroll across a long page takes most of a
    * second, and a flash begun at the top is already fading by the time the user's eye arrives. Settles on the

package/store/agent/index.ts

@@ -7,7 +7,6 @@ export * from "./AgentPrompts";
 export * from "./ScreenReader";
 export * from "./ScreenSettle";
 export * from "./ScreenTarget";
-export * from "./StateWait";
 export * from "./StoreCatalogue";
 export * from "./StoreSurfaceSource";
 export * from "./storeSurface";

package/types/store/agent/index.d.ts

@@ -5,7 +5,6 @@ export * from "./AgentPrompts.d.ts";
 export * from "./ScreenReader.d.ts";
 export * from "./ScreenSettle.d.ts";
 export * from "./ScreenTarget.d.ts";
-export * from "./StateWait.d.ts";
 export * from "./StoreCatalogue.d.ts";
 export * from "./StoreSurfaceSource.d.ts";
 export * from "./storeSurface.d.ts";

package/ui/Agent/useDraftRecall.ts

@@ -18,8 +18,8 @@ const asked = (messages: readonly ChatMessage[], cap: number) =>
 export const useDraftRecall = (messages: readonly ChatMessage[]) => {
   const cap = 30;
   const sent = useRef<string[] | null>(null);
-  
-  const walked = (sent.current ??= asked(messages, cap));
+  if (!sent.current) sent.current = asked(messages, cap);
+  const walked = sent.current;
   const stashed = useRef("");
   const [at, setAt] = useState(0);
   return {

package/store/agent/StateWait.ts

@@ -1,139 +0,0 @@
-import { AgentAbort, AgentProgress } from "../../vendor/use-agentic";
-
-/** The reading half of the store an in-page wait needs. `AgentBridge` is one; a test can be another. */
-export interface StateSource {
-  read(key: string, viewKey?: string): unknown;
-  subscribe(listener: () => void): () => void;
-}
-
-export interface StateWaitOptions {
-  key: string;
-  viewKey?: string;
-  /** Settle when the key reads exactly this. Null waits for it to change from whatever it holds now. */
-  equals?: string | null;
-  /** Straight off the tool argument, so it may be anything; `StateWait.seconds` is what makes it a number. */
-  seconds?: unknown;
-}
-
-/**
- * One `waitFor` call: park until a published state key settles, or until the timeout says how it is going.
- *
- * Two clocks, because neither covers the other. The store's own subscription catches the value changing, which is
- * the whole point of the tool and has to land immediately. The tick catches what the store never announces —
- * `retainLive` / `releaseLive` mutate the live-key map without notifying any listener, so a page navigated away
- * from mid-wait would otherwise hold the turn until the timeout — and the countdown row needs a tick anyway.
- *
- * Nothing here throws on a wait that ran out. A key still reading `generating` after two minutes is an answer, not
- * a failure, and the model is the one that decides whether to wait again.
- */
-export class StateWait {
-  static readonly tickMs = 1000;
-  static readonly defaultSeconds = 120;
-  static readonly maxSeconds = 600;
-
-  /** Clamped rather than refused: a model that asks for an hour gets the longest wait on offer and reads how long. */
-  static seconds(value: unknown): number {
-    if (typeof value !== "number" || !Number.isFinite(value)) return StateWait.defaultSeconds;
-    return Math.min(Math.max(Math.round(value), 1), StateWait.maxSeconds);
-  }
-
-  /** A string is itself; everything else is JSON, so a number, a boolean and null each compare as they are written. */
-  static print(value: unknown): string {
-    if (typeof value === "string") return value;
-    try {
-      return JSON.stringify(value) ?? String(value);
-    } catch {
-      return String(value);
-    }
-  }
-
-  readonly #source: StateSource;
-  readonly #key: string;
-  readonly #viewKey: string;
-  readonly #equals: string | null;
-  readonly #seconds: number;
-  #was = "";
-  #now = "";
-  #elapsed = 0;
-  #settled: boolean = false;
-  #ticker: ReturnType<typeof setInterval> | undefined;
-  #unsubscribe: (() => void) | undefined;
-  #signal: AbortSignal | null = null;
-  #resolve: ((message: string) => void) | null = null;
-  #reject: ((error: Error) => void) | null = null;
-
-  constructor(source: StateSource, { key, viewKey = "", equals = null, seconds }: StateWaitOptions) {
-    this.#source = source;
-    this.#key = key;
-    this.#viewKey = viewKey;
-    this.#equals = equals;
-    this.#seconds = StateWait.seconds(seconds);
-  }
-
-  run(): Promise<string> {
-    this.#was = StateWait.print(this.#source.read(this.#key, this.#viewKey));
-    this.#now = this.#was;
-    if (this.#equals !== null && this.#was === this.#equals)
-      return Promise.resolve(`${this.#key} is already ${this.#was}.`);
-    return new Promise<string>((resolve, reject) => {
-      this.#resolve = resolve;
-      this.#reject = reject;
-      this.#signal = AgentAbort.current;
-      if (this.#signal?.aborted) {
-        this.#abort();
-        return;
-      }
-      this.#signal?.addEventListener("abort", this.#abort);
-      this.#unsubscribe = this.#source.subscribe(this.#check);
-      this.#ticker = setInterval(this.#tick, StateWait.tickMs);
-      AgentProgress.report("", { done: 0, total: this.#seconds });
-    });
-  }
-
-  /** The session races every call against the same signal; honouring it here is what stops the timer. */
-  #abort = () => {
-    this.#stop();
-    this.#reject?.(new Error("The user aborted the turn."));
-  };
-
-  #check = () => {
-    if (this.#settled) return;
-    let now: string;
-    try {
-      now = StateWait.print(this.#source.read(this.#key, this.#viewKey));
-    } catch (error) {
-      
-      this.#end(`Stopped waiting: ${error instanceof Error ? error.message : String(error)}`);
-      return;
-    }
-    this.#now = now;
-    if (this.#equals === null ? now !== this.#was : now === this.#equals) this.#end(`${this.#key} is now ${now}.`);
-  };
-
-  #tick = () => {
-    this.#check();
-    if (this.#settled) return;
-    this.#elapsed += 1;
-    if (this.#elapsed >= this.#seconds) {
-      this.#end(
-        `${this.#key} is still ${this.#now} after ${this.#seconds}s. Call waitFor again to keep waiting, or tell the user it is taking longer than expected.`,
-      );
-      return;
-    }
-    AgentProgress.report("", { done: this.#elapsed, total: this.#seconds });
-  };
-
-  #end(message: string) {
-    this.#stop();
-    this.#resolve?.(message);
-  }
-
-  #stop() {
-    this.#settled = true;
-    clearInterval(this.#ticker);
-    this.#ticker = undefined;
-    this.#unsubscribe?.();
-    this.#unsubscribe = undefined;
-    this.#signal?.removeEventListener("abort", this.#abort);
-  }
-}

package/types/store/agent/StateWait.d.ts

@@ -1,36 +0,0 @@
-/** The reading half of the store an in-page wait needs. `AgentBridge` is one; a test can be another. */
-export interface StateSource {
-    read(key: string, viewKey?: string): unknown;
-    subscribe(listener: () => void): () => void;
-}
-export interface StateWaitOptions {
-    key: string;
-    viewKey?: string;
-    /** Settle when the key reads exactly this. Null waits for it to change from whatever it holds now. */
-    equals?: string | null;
-    /** Straight off the tool argument, so it may be anything; `StateWait.seconds` is what makes it a number. */
-    seconds?: unknown;
-}
-/**
- * One `waitFor` call: park until a published state key settles, or until the timeout says how it is going.
- *
- * Two clocks, because neither covers the other. The store's own subscription catches the value changing, which is
- * the whole point of the tool and has to land immediately. The tick catches what the store never announces —
- * `retainLive` / `releaseLive` mutate the live-key map without notifying any listener, so a page navigated away
- * from mid-wait would otherwise hold the turn until the timeout — and the countdown row needs a tick anyway.
- *
- * Nothing here throws on a wait that ran out. A key still reading `generating` after two minutes is an answer, not
- * a failure, and the model is the one that decides whether to wait again.
- */
-export declare class StateWait {
-    #private;
-    static readonly tickMs = 1000;
-    static readonly defaultSeconds = 120;
-    static readonly maxSeconds = 600;
-    /** Clamped rather than refused: a model that asks for an hour gets the longest wait on offer and reads how long. */
-    static seconds(value: unknown): number;
-    /** A string is itself; everything else is JSON, so a number, a boolean and null each compare as they are written. */
-    static print(value: unknown): string;
-    constructor(source: StateSource, { key, viewKey, equals, seconds }: StateWaitOptions);
-    run(): Promise<string>;
-}