@buoy-gg/ask-buoy 7.0.41 → 7.0.43

package/lib/module/store/askBuoyStore.js

@@ -1,583 +1,3 @@
-"use strict";
+"use strict";import{idFactory as p}from"@buoy-gg/agent-core";import{realNow as i}from"@buoy-gg/shared-ui";const l=p("m");const f=400;function b(t){if(!t||Object.keys(t).length===0)return void 0;try{const e=JSON.stringify(t);return e.length>f?`${e.slice(0,f)}\u2026`:e}catch{return void 0}}const h=p("q");let s={messages:[],busy:false,stopping:false,pending:null,trusted:[],notice:null,configured:false,answers:{},awaitingBlockId:null,actionState:{},queued:[],draft:null,usage:{input:0,output:0,requests:0},meta:{}};const d=new Set;let c=null;let g=null;function r(t){s={...s,...t};for(const e of d){try{e()}catch{}}}export const askBuoyStore={getState:()=>s,subscribe(t){d.add(t);return()=>d.delete(t)},setLedger(t){c=t},getLedger(){return c},holdSession(t,e){g={session:t,signature:e}},getHeldSession(){return g},setNotice(t){r({notice:t})},setConfigured(t){if(t!==s.configured)r({configured:t})},setMeta(t){const e=Object.keys(t).every(a=>s.meta[a]===t[a]);if(!e)r({meta:{...s.meta,...t}})},addUser(t){r({messages:[...s.messages,{id:l(),role:"user",text:t,toolCalls:[],blocks:[]}],busy:true})},beginTurn(){r({busy:true})},enqueue(t){const e={id:h(),text:t};r({queued:[...s.queued,e]});return e},removeQueued(t){if(!s.queued.some(e=>e.id===t))return;r({queued:s.queued.filter(e=>e.id!==t)})},shiftQueued(){const[t,...e]=s.queued;if(!t)return void 0;r({queued:e});return t},takeQueuedToDraft(t){const e=s.queued.find(a=>a.id===t);if(!e)return;r({queued:s.queued.filter(a=>a.id!==t),draft:e.text})},requestStop(){if(!s.busy||s.stopping)return;r({stopping:true})},clearDraft(){if(s.draft===null)return;r({draft:null})},removeMessage(t){r({messages:s.messages.filter(e=>e.id!==t)})},recordAnswer(t){r({answers:{...s.answers,[t.blockId]:t},awaitingBlockId:s.awaitingBlockId===t.blockId?null:s.awaitingBlockId})},setActionState(t,e){const a={...s.actionState};if(e===null)delete a[t];else a[t]=e;r({actionState:a})},startAssistant(){const t=l();r({messages:[...s.messages,{id:t,role:"assistant",text:"",toolCalls:[],blocks:[],streaming:true,startedAt:i()}]});return t},applyEvent(t,e){if(e.type==="history-trimmed"){const n=s.messages.findIndex(m=>m.id===t);const o={id:l(),role:"assistant",system:true,text:`Older messages were trimmed from the agent's memory (${e.droppedRounds} exchange${e.droppedRounds===1?"":"s"}).`+(e.droppedPinned?` ${e.droppedPinned===1?"One of them made a change that is":`${e.droppedPinned} of them made changes that are`} still applied \u2014 the changes bar still lists ${e.droppedPinned===1?"it":"them"}, but the agent no longer remembers making ${e.droppedPinned===1?"it":"them"}.`:" It may not recall setup from earlier in this chat \u2014 the changes bar still lists what is applied."),toolCalls:[],blocks:[],endedAt:i()};const u=[...s.messages];u.splice(n<0?u.length:n,0,o);r({messages:u});return}const a=s.messages.map(n=>{if(n.id!==t)return n;switch(e.type){case"retrying":{const o=Math.max(1,Math.round(e.inMs/1e3));return{...n,waiting:e.reason==="throttled"?`Endpoint busy \u2014 retrying in ${o}s (${e.attempt} of ${e.maxAttempts})`:`Request too large \u2014 trimming older messages and retrying`}}case"text":return{...n,waiting:void 0,text:(n.breakBeforeNextText||e.breakBefore)&&n.text?`${n.text.trimEnd()}
 
-/**
- * Conversation state for the sheet.
- *
- * A module-level store rather than component state for two reasons: the sheet
- * is unmounted whenever the tool is closed or minimised (and a conversation
- * that vanished because someone tapped away would be maddening), and the sync
- * adapter needs to read the same transcript to show it on the desktop.
- *
- * Persisted across restarts, on purpose, with the payloads left out — see
- * `transcriptPersistence.ts` for what is written and what that costs. The
- * store itself stays a plain in-memory store; saving is a subscriber, and
- * `hydrate` is the one way anything comes back in.
- */
-import { idFactory } from "@buoy-gg/agent-core";
-
-/** A block in a message, and (for receipts) the tool call that produced it. */
-
-/**
- * A stretch of the model's own reasoning, and where it fell.
- *
- * `afterCalls` is how many tool calls this message had already made when the
- * thought arrived, so the thinking view can lay reasoning and steps out in the
- * order they actually happened. One assistant bubble spans every turn of a
- * multi-step run, so "think, act, think, act" is the normal shape and showing
- * all the thoughts in a lump at the top would misreport it.
- */
-
-/**
- * A message typed while a turn was running.
- *
- * A list with ids, not a string: the single slot it replaced OVERWROTE — type
- * two things mid-turn and the first vanished, which is precisely the loss the
- * queue exists to prevent. Ids so two identical requests stay distinguishable
- * and the list can be edited by row.
- */
-
-/**
- * The one word every component reads to know what the chat is doing.
- *
- * Presentation state (minimised, settings open) is NOT in here on purpose —
- * it sits on top. This exists because the header, the composer, the queue
- * flush and the modal each used to derive their own answer from five
- * overlapping booleans, and disagreed: the queue fired after an error because
- * "not busy" looked like "idle" to it.
- */
-
-/**
- * Message ids carry this run's token — see agent-core's `runId`. A plain `m1`
- * collided head-on with the `m1` in a restored transcript, and the message
- * list keys on it.
- */
-const nextId = idFactory("m");
-
-/**
- * Params, as one readable line. Capped because a step can carry a whole
- * response body or a store's full state, and this is chrome inside a chat
- * bubble — the full value is a tool read away.
- */
-const MAX_PARAM_CHARS = 400;
-function encodeParams(params) {
-  if (!params || Object.keys(params).length === 0) return undefined;
-  try {
-    const json = JSON.stringify(params);
-    return json.length > MAX_PARAM_CHARS ? `${json.slice(0, MAX_PARAM_CHARS)}…` : json;
-  } catch {
-    return undefined;
-  }
-}
-
-/** Queue ids carry the run token too — a restored queue keys on them. */
-const nextQueuedId = idFactory("q");
-let state = {
-  messages: [],
-  busy: false,
-  stopping: false,
-  pending: null,
-  trusted: [],
-  notice: null,
-  configured: false,
-  answers: {},
-  awaitingBlockId: null,
-  actionState: {},
-  queued: [],
-  draft: null,
-  usage: {
-    input: 0,
-    output: 0,
-    requests: 0
-  },
-  meta: {}
-};
-const listeners = new Set();
-let ledgerRef = null;
-
-/**
- * The session outlives the sheet the same way the transcript does. Session and
- * ledger used to be per-mount: closing and reopening the tool kept the visible
- * conversation but silently swapped in an empty ledger and a blank model
- * memory — the undo bar vanished while the agent's changes stayed live in the
- * app. Held here, keyed by a config signature so a real reconfiguration
- * (different endpoint/model/tool set) still rebuilds.
- */
-let heldSession = null;
-function set(next) {
-  state = {
-    ...state,
-    ...next
-  };
-  for (const fn of listeners) {
-    try {
-      fn();
-    } catch {
-      // A throwing subscriber must not take the transcript down mid-answer.
-    }
-  }
-}
-export const askBuoyStore = {
-  getState: () => state,
-  subscribe(fn) {
-    listeners.add(fn);
-    return () => listeners.delete(fn);
-  },
-  setLedger(ledger) {
-    ledgerRef = ledger;
-  },
-  getLedger() {
-    return ledgerRef;
-  },
-  holdSession(session, signature) {
-    heldSession = {
-      session,
-      signature
-    };
-  },
-  getHeldSession() {
-    return heldSession;
-  },
-  setNotice(notice) {
-    set({
-      notice
-    });
-  },
-  setConfigured(configured) {
-    if (configured !== state.configured) set({
-      configured
-    });
-  },
-  setMeta(meta) {
-    const same = Object.keys(meta).every(k => state.meta[k] === meta[k]);
-    if (!same) set({
-      meta: {
-        ...state.meta,
-        ...meta
-      }
-    });
-  },
-  addUser(text) {
-    set({
-      messages: [...state.messages, {
-        id: nextId(),
-        role: "user",
-        text,
-        toolCalls: [],
-        blocks: []
-      }],
-      busy: true
-    });
-  },
-  /** Mark a turn as running without adding a bubble — the retry path. */
-  beginTurn() {
-    set({
-      busy: true
-    });
-  },
-  /** Park a message typed mid-turn, behind whatever is already parked. */
-  enqueue(text) {
-    const item = {
-      id: nextQueuedId(),
-      text
-    };
-    set({
-      queued: [...state.queued, item]
-    });
-    return item;
-  },
-  /** Drop one parked message — the ✕ on its row. */
-  removeQueued(id) {
-    if (!state.queued.some(q => q.id === id)) return;
-    set({
-      queued: state.queued.filter(q => q.id !== id)
-    });
-  },
-  /** Take the FIRST parked message off the queue — the flush path. */
-  shiftQueued() {
-    const [next, ...rest] = state.queued;
-    if (!next) return undefined;
-    set({
-      queued: rest
-    });
-    return next;
-  },
-  /** Hand one parked message back to the composer to edit. See `draft`. */
-  takeQueuedToDraft(id) {
-    const item = state.queued.find(q => q.id === id);
-    if (!item) return;
-    set({
-      queued: state.queued.filter(q => q.id !== id),
-      draft: item.text
-    });
-  },
-  /**
-   * The user pressed Stop. The turn is still winding down — the abort is only
-   * read between calls — so the phase is `stopping`, not `idle`, until
-   * `finishAssistant` lands.
-   */
-  requestStop() {
-    if (!state.busy || state.stopping) return;
-    set({
-      stopping: true
-    });
-  },
-  /** The composer has taken the draft into its input. */
-  clearDraft() {
-    if (state.draft === null) return;
-    set({
-      draft: null
-    });
-  },
-  /** Drop one message — the failed assistant bubble a retry replaces. */
-  removeMessage(id) {
-    set({
-      messages: state.messages.filter(m => m.id !== id)
-    });
-  },
-  /** The user answered (or skipped) an Ask block. */
-  recordAnswer(answer) {
-    set({
-      answers: {
-        ...state.answers,
-        [answer.blockId]: answer
-      },
-      awaitingBlockId: state.awaitingBlockId === answer.blockId ? null : state.awaitingBlockId
-    });
-  },
-  setActionState(key, value) {
-    const next = {
-      ...state.actionState
-    };
-    if (value === null) delete next[key];else next[key] = value;
-    set({
-      actionState: next
-    });
-  },
-  /** Open a new assistant bubble for the turn that is about to stream. */
-  startAssistant() {
-    const id = nextId();
-    set({
-      messages: [...state.messages, {
-        id,
-        role: "assistant",
-        text: "",
-        toolCalls: [],
-        blocks: [],
-        streaming: true,
-        startedAt: Date.now()
-      }]
-    });
-    return id;
-  },
-  /**
-   * Fold one engine event into the open assistant message.
-   *
-   * Tool calls render as rows inside the bubble rather than as raw payloads:
-   * the label is already domain-flavoured ("Set points to 1500"), which is the
-   * only form a non-developer can actually check.
-   */
-  applyEvent(messageId, ev) {
-    if (ev.type === "history-trimmed") {
-      // Before the answer it affects, so it reads as a caption on the gap
-      // rather than as part of the reply.
-      const at = state.messages.findIndex(m => m.id === messageId);
-      const line = {
-        id: nextId(),
-        role: "assistant",
-        system: true,
-        text: `Older messages were trimmed from the agent's memory (${ev.droppedRounds} exchange${ev.droppedRounds === 1 ? "" : "s"}).` + (ev.droppedPinned ? ` ${ev.droppedPinned === 1 ? "One of them made a change that is" : `${ev.droppedPinned} of them made changes that are`} still applied — the changes bar still lists ${ev.droppedPinned === 1 ? "it" : "them"}, but the agent no longer remembers making ${ev.droppedPinned === 1 ? "it" : "them"}.` : " It may not recall setup from earlier in this chat — the changes bar still lists what is applied."),
-        toolCalls: [],
-        blocks: [],
-        endedAt: Date.now()
-      };
-      const next = [...state.messages];
-      next.splice(at < 0 ? next.length : at, 0, line);
-      set({
-        messages: next
-      });
-      return;
-    }
-    const messages = state.messages.map(m => {
-      if (m.id !== messageId) return m;
-      switch (ev.type) {
-        case "retrying":
-          {
-            const secs = Math.max(1, Math.round(ev.inMs / 1000));
-            return {
-              ...m,
-              waiting: ev.reason === "throttled" ? `Endpoint busy — retrying in ${secs}s (${ev.attempt} of ${ev.maxAttempts})` : `Request too large — trimming older messages and retrying`
-            };
-          }
-        case "text":
-          return {
-            ...m,
-            waiting: undefined,
-            text: (m.breakBeforeNextText || ev.breakBefore) && m.text ? `${m.text.trimEnd()}\n\n${ev.delta}` : m.text + ev.delta,
-            breakBeforeNextText: false
-          };
-        case "reasoning":
-          return {
-            ...m,
-            breakBeforeNextText: true,
-            reasoning: [...(m.reasoning ?? []), {
-              text: ev.text,
-              afterCalls: m.toolCalls.length
-            }]
-          };
-        case "tool-start":
-          return {
-            ...m,
-            waiting: undefined,
-            toolCalls: [...m.toolCalls, {
-              id: ev.id,
-              toolId: ev.toolId,
-              action: ev.action,
-              label: ev.label,
-              description: ev.description,
-              status: "running",
-              params: encodeParams(ev.params),
-              effect: ev.effect,
-              startedAt: Date.now()
-            }]
-          };
-        case "tool-end":
-          return {
-            ...m,
-            breakBeforeNextText: true,
-            toolCalls: m.toolCalls.map(c => c.id === ev.id ? {
-              ...c,
-              status: !ev.ok && ev.summary === "refused" ? "refused" : !ev.ok && ev.summary === "declined" ? "declined" : !ev.ok && ev.summary === "stopped" ? "stopped" : ev.ok ? "ok" : "failed",
-              summary: ev.summary,
-              durationMs: ev.durationMs,
-              result: ev.result
-            } : c)
-          };
-        case "tool-verified":
-          return {
-            ...m,
-            toolCalls: m.toolCalls.map(c => c.id === ev.id ? {
-              ...c,
-              verification: ev.verification
-            } : c)
-          };
-        case "block":
-          return {
-            ...m,
-            breakBeforeNextText: true,
-            blocks: [...m.blocks, {
-              block: ev.block,
-              forToolCallId: ev.forToolCallId
-            }]
-          };
-        case "usage":
-          // Also folded into the session total below. Per MESSAGE as well,
-          // because "which answer cost 40k tokens" is the question you ask
-          // when a bill looks wrong, and a session total cannot answer it.
-          return {
-            ...m,
-            usage: {
-              input: (m.usage?.input ?? 0) + ev.input,
-              output: (m.usage?.output ?? 0) + ev.output,
-              requests: (m.usage?.requests ?? 0) + 1
-            }
-          };
-        case "error":
-          return {
-            ...m,
-            waiting: undefined,
-            error: ev.message
-          };
-        default:
-          return m;
-      }
-    });
-    set({
-      messages,
-      ...(ev.type === "awaiting-user" ? {
-        awaitingBlockId: ev.blockId
-      } : {}),
-      ...(ev.type === "usage" ? {
-        usage: {
-          input: state.usage.input + ev.input,
-          output: state.usage.output + ev.output,
-          requests: state.usage.requests + 1
-        }
-      } : {})
-    });
-  },
-  /** The user pressed Stop on this turn. See `ChatMessage.stopped`. */
-  markStopped(messageId) {
-    set({
-      messages: state.messages.map(m => m.id === messageId ? {
-        ...m,
-        stopped: true
-      } : m)
-    });
-  },
-  finishAssistant(messageId) {
-    set({
-      messages: state.messages.map(m => m.id === messageId ? {
-        ...m,
-        streaming: false,
-        endedAt: Date.now()
-      } : m),
-      busy: false,
-      stopping: false
-    });
-  },
-  askApproval(input) {
-    return new Promise(resolve => {
-      set({
-        pending: {
-          ...input,
-          resolve
-        }
-      });
-    });
-  },
-  /**
-   * The user's answer, in full: yes/no, an optional note on a no (it goes to
-   * the model verbatim), and on a yes whether to stop asking about this
-   * action for the rest of the conversation. A bare boolean still works.
-   */
-  answerApproval(answer) {
-    const pending = state.pending;
-    const approved = typeof answer === "boolean" ? answer : answer.approved;
-    const trust = typeof answer !== "boolean" && answer.trust === true && approved;
-    const key = pending ? `${pending.toolId}.${pending.action}` : "";
-    set({
-      pending: null,
-      ...(trust && pending && !state.trusted.some(t => t.key === key) ? {
-        trusted: [...state.trusted, {
-          key,
-          label: pending.label
-        }]
-      } : {})
-    });
-    pending?.resolve(answer);
-  },
-  /** Ask again for this action. Removes it from the session's waiver set too. */
-  untrust(key) {
-    heldSession?.session.untrust(key);
-    set({
-      trusted: state.trusted.filter(t => t.key !== key)
-    });
-  },
-  /**
-   * Put an unanswered approval back after a restart.
-   *
-   * A question the app asked and then forgot is worse than not asking: the
-   * user tapped nothing, so as far as they are concerned the change is still
-   * waiting for them. `resolve` is a no-op because nothing is waiting on this
-   * one any more; `restored` is what tells the sheet to run the call rather
-   * than answer a dead promise.
-   *
-   * Refused once a turn is under way, for the same reason `hydrate` is: a slow
-   * disk read must not shove an old question in front of a live conversation.
-   */
-  restorePending(input) {
-    if (state.pending || state.busy) return false;
-    set({
-      pending: {
-        ...input,
-        restored: true,
-        resolve: () => {}
-      }
-    });
-    return true;
-  },
-  /**
-   * A line in the transcript from Buoy itself rather than from the model.
-   *
-   * It wears the assistant's bubble because that is the only shape the list
-   * renders, but nothing is sent to the model and nothing lands in its
-   * history — it exists so an approval answered after a restart leaves a
-   * trace, instead of the card silently vanishing a second time.
-   */
-  addNote(text) {
-    set({
-      messages: [...state.messages, {
-        id: nextId(),
-        role: "assistant",
-        text,
-        toolCalls: [],
-        blocks: [],
-        endedAt: Date.now()
-      }]
-    });
-  },
-  /**
-   * Put a saved conversation back, once, at open.
-   *
-   * Refuses if anything has been said already: a slow disk read landing after
-   * the user has started typing must not shove an old chat in front of them.
-   */
-  hydrate(input) {
-    if (state.messages.length > 0 || state.busy) return false;
-    set({
-      messages: input.messages.map(m => ({
-        ...m,
-        restored: true
-      })),
-      answers: input.answers,
-      usage: input.usage,
-      queued: input.queued ?? []
-    });
-    return true;
-  },
-  reset() {
-    // Reject anything still waiting, or the turn hangs forever on a promise
-    // whose only resolver just left the screen.
-    state.pending?.resolve(false);
-    set({
-      messages: [],
-      busy: false,
-      stopping: false,
-      pending: null,
-      trusted: [],
-      notice: null,
-      answers: {},
-      awaitingBlockId: null,
-      actionState: {},
-      queued: [],
-      draft: null,
-      usage: {
-        input: 0,
-        output: 0,
-        requests: 0
-      }
-      // `meta` survives: it describes the app and the endpoint, not the
-      // conversation, and re-deriving it would need another render pass.
-    });
-  }
-};
-
-/** See TurnPhase. Pure, so every component and the flush effect agree. */
-export function turnPhaseOf(s) {
-  if (s.pending) return "awaitingApproval";
-  if (s.busy) return s.stopping ? "stopping" : "running";
-  if (s.awaitingBlockId) return "awaitingAnswer";
-  return "idle";
-}
-
-/**
- * Why parked messages are NOT being sent right now, in the user's words — or
- * null when the queue may deliver.
- *
- * A queued message is a next TASK, not an answer. It used to go the moment
- * `busy` dropped: after an error it fired into the same dead connection, and
- * with a choice block open it was sent as the reply to the question. So the
- * queue holds on error, Stop, an approval and an unanswered Ask block, and
- * says which.
- */
-export function queuePauseReason(s) {
-  const phase = turnPhaseOf(s);
-  if (phase === "running" || phase === "stopping") return null;
-  if (phase === "awaitingApproval") return "Paused — answer the approval above first.";
-  if (phase === "awaitingAnswer") return "Paused — answer the question above first.";
-  const last = s.messages[s.messages.length - 1];
-  if (last?.role === "assistant" && last.error) return "Paused — the last turn failed.";
-  if (last?.role === "assistant" && last.stopped) return "Paused — you stopped the last turn.";
-  return null;
-}
-//# sourceMappingURL=askBuoyStore.js.map
+${e.delta}`:n.text+e.delta,breakBeforeNextText:false};case"reasoning":return{...n,breakBeforeNextText:true,reasoning:[...n.reasoning??[],{text:e.text,afterCalls:n.toolCalls.length}]};case"tool-start":return{...n,waiting:void 0,toolCalls:[...n.toolCalls,{id:e.id,toolId:e.toolId,action:e.action,label:e.label,description:e.description,status:"running",params:b(e.params),effect:e.effect,startedAt:i()}]};case"tool-end":return{...n,breakBeforeNextText:true,toolCalls:n.toolCalls.map(o=>o.id===e.id?{...o,status:!e.ok&&e.summary==="refused"?"refused":!e.ok&&e.summary==="declined"?"declined":!e.ok&&e.summary==="stopped"?"stopped":e.ok?"ok":"failed",summary:e.summary,durationMs:e.durationMs,result:e.result}:o)};case"tool-verified":return{...n,toolCalls:n.toolCalls.map(o=>o.id===e.id?{...o,verification:e.verification}:o)};case"block":return{...n,breakBeforeNextText:true,blocks:[...n.blocks,{block:e.block,forToolCallId:e.forToolCallId}]};case"usage":return{...n,usage:{input:(n.usage?.input??0)+e.input,output:(n.usage?.output??0)+e.output,requests:(n.usage?.requests??0)+1}};case"error":return{...n,waiting:void 0,error:e.message};default:return n}});r({messages:a,...e.type==="awaiting-user"?{awaitingBlockId:e.blockId}:{},...e.type==="usage"?{usage:{input:s.usage.input+e.input,output:s.usage.output+e.output,requests:s.usage.requests+1}}:{}})},markStopped(t){r({messages:s.messages.map(e=>e.id===t?{...e,stopped:true}:e)})},finishAssistant(t){r({messages:s.messages.map(e=>e.id===t?{...e,streaming:false,endedAt:i()}:e),busy:false,stopping:false})},askApproval(t){return new Promise(e=>{r({pending:{...t,resolve:e}})})},answerApproval(t){const e=s.pending;const a=typeof t==="boolean"?t:t.approved;const n=typeof t!=="boolean"&&t.trust===true&&a;const o=e?`${e.toolId}.${e.action}`:"";r({pending:null,...n&&e&&!s.trusted.some(u=>u.key===o)?{trusted:[...s.trusted,{key:o,label:e.label}]}:{}});e?.resolve(t)},untrust(t){g?.session.untrust(t);r({trusted:s.trusted.filter(e=>e.key!==t)})},restorePending(t){if(s.pending||s.busy)return false;r({pending:{...t,restored:true,resolve:()=>{}}});return true},addNote(t){r({messages:[...s.messages,{id:l(),role:"assistant",text:t,toolCalls:[],blocks:[],endedAt:i()}]})},hydrate(t){if(s.messages.length>0||s.busy)return false;r({messages:t.messages.map(e=>({...e,restored:true})),answers:t.answers,usage:t.usage,queued:t.queued??[]});return true},reset(){s.pending?.resolve(false);r({messages:[],busy:false,stopping:false,pending:null,trusted:[],notice:null,answers:{},awaitingBlockId:null,actionState:{},queued:[],draft:null,usage:{input:0,output:0,requests:0}})}};export function turnPhaseOf(t){if(t.pending)return"awaitingApproval";if(t.busy)return t.stopping?"stopping":"running";if(t.awaitingBlockId)return"awaitingAnswer";return"idle"}export function queuePauseReason(t){const e=turnPhaseOf(t);if(e==="running"||e==="stopping")return null;if(e==="awaitingApproval")return"Paused \u2014 answer the approval above first.";if(e==="awaitingAnswer")return"Paused \u2014 answer the question above first.";const a=t.messages[t.messages.length-1];if(a?.role==="assistant"&&a.error)return"Paused \u2014 the last turn failed.";if(a?.role==="assistant"&&a.stopped)return"Paused \u2014 you stopped the last turn.";return null}

package/lib/module/store/blockPlacement.js

@@ -1,59 +1 @@
-"use strict";
-
-/**
- * Where each block of a turn is drawn: inside a step row, after the prose as
- * the answer itself, or last of all as the thing being asked.
- *
- * Pure and separate from MessageList because the rule is subtle and the cost
- * of getting it wrong is silent — a block that lands in no bucket renders
- * nowhere at all, and nothing in the UI says so. That is exactly what
- * happened: "show me the shop as pictures" built its imageGrid, the engine
- * accepted it, and the sheet dropped it on the floor twice while the model
- * narrated the artwork in prose.
- */
-import { isAskBlock } from "@buoy-gg/agent-core";
-/**
- * A receipt that belongs inside its step row rather than in the answer: it
- * came from a tool call, and it reports what was READ, not what was changed.
- *
- * ONLY a receipt nests, which is why this tests for the receipt provenances
- * rather than for "not changed". A model-authored block (`buoy_ui`, source
- * "model") also carries the id of the call that produced it — but `buoy_ui`
- * emits no activity row, so there was no step for it to nest under.
- */
-function nestsUnderStep({
-  block,
-  forToolCallId
-}) {
-  if (!forToolCallId) return false;
-  const source = "source" in block ? block.source : undefined;
-  return source === "live" || source === "mocked";
-}
-export function placeBlocks(blocks, stepIds) {
-  const steps = new Set(stepIds);
-  const nested = new Map();
-  const afterText = [];
-  const ask = [];
-  for (const placed of blocks) {
-    if (isAskBlock(placed.block)) {
-      ask.push(placed);
-      continue;
-    }
-    // A block may only nest under a step that actually has a row. Anything
-    // pointing at a call the activity list never drew renders with the answer
-    // — never nowhere.
-    if (nestsUnderStep(placed) && steps.has(placed.forToolCallId)) {
-      const list = nested.get(placed.forToolCallId) ?? [];
-      list.push(placed.block);
-      nested.set(placed.forToolCallId, list);
-    } else {
-      afterText.push(placed);
-    }
-  }
-  return {
-    nested,
-    afterText,
-    ask
-  };
-}
-//# sourceMappingURL=blockPlacement.js.map
+"use strict";import{isAskBlock as f}from"@buoy-gg/agent-core";function u({block:o,forToolCallId:t}){if(!t)return false;const s="source"in o?o.source:void 0;return s==="live"||s==="mocked"}export function placeBlocks(o,t){const s=new Set(t);const n=new Map;const c=[];const r=[];for(const e of o){if(f(e.block)){r.push(e);continue}if(u(e)&&s.has(e.forToolCallId)){const l=n.get(e.forToolCallId)??[];l.push(e.block);n.set(e.forToolCallId,l)}else{c.push(e)}}return{nested:n,afterText:c,ask:r}}