@buoy-gg/ask-buoy 7.0.38 → 7.0.40

package/lib/commonjs/store/useAskBuoy.js

@@ -1 +1,651 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.useAskBuoy=useAskBuoy,exports.useAskBuoyState=useAskBuoyState;var _sharedUi=require("@buoy-gg/shared-ui"),_react=require("react"),_reactNative=require("react-native"),_agentCore=require("@buoy-gg/agent-core"),_askBuoyStore=require("./askBuoyStore"),_resetConversation=require("./resetConversation"),_transcriptPersistence=require("./transcriptPersistence"),_useAskBuoySettings=require("./useAskBuoySettings");const isRelease="undefined"!=typeof __DEV__&&!__DEV__;function questionBehind(e){for(const t of _askBuoyStore.askBuoyStore.getState().messages)if(t.restored)for(const o of t.blocks){const t=o.block;if(t?.id!==e)continue;const s=t.question??t.label??t.title;return"string"==typeof s&&s.trim()?s.trim():void 0}}function readAvailableActions(){try{const e=(0,_sharedUi.listToolActions)();for(const t of(0,_sharedUi.listSnapshotToolIds)())e[t]||(e[t]=[]),e[t].includes(_agentCore.SNAPSHOT_ACTION)||(e[t]=[_agentCore.SNAPSHOT_ACTION,...e[t]]);return e}catch{return{}}}const SAVE_DEBOUNCE_MS=600;function useAskBuoyState(){return(0,_react.useSyncExternalStore)(_askBuoyStore.askBuoyStore.subscribe,_askBuoyStore.askBuoyStore.getState,_askBuoyStore.askBuoyStore.getState)}function useAskBuoy(e){const t=useAskBuoyState(),o=(0,_sharedUi.getUseIsPro)()(),s=(0,_react.useRef)(o);s.current=o;const r=(0,_react.useCallback)((...e)=>(0,_sharedUi.hasAccountAccess)()&&s.current?(0,_sharedUi.dispatchToolAction)(...e):Promise.reject(new Error("Ask Buoy requires Pro access.")),[]),a=(0,_react.useRef)(null),n=(0,_react.useRef)(!1),u=(0,_react.useRef)(null),i=(0,_react.useRef)(e);i.current=e;const c=!!e?.endpoint&&!!e?.model,l=!1!==e?.persistTranscript,{bypassApprovals:d,readOnly:y}=(0,_useAskBuoySettings.useAskBuoySettings)(),k=(0,_react.useRef)(d);k.current=d;const p=(0,_react.useRef)(y);p.current=y;const S=(0,_react.useCallback)(()=>p.current?{...e?.policy??{},readOnly:!0}:e?.policy??{},[e]),[_,B]=(0,_react.useState)(0);(0,_react.useEffect)(()=>{let e=!1;return(0,_sharedUi.waitForToolRegistry)().then(()=>{e||B(e=>e+1)}),()=>{e=!0}},[]);const g=(0,_react.useMemo)(()=>readAvailableActions(),[_]),h=Object.keys(g).sort().join(",");(0,_react.useEffect)(()=>{if(_askBuoyStore.askBuoyStore.setConfigured(c),_askBuoyStore.askBuoyStore.setMeta({model:e?.model,protocol:e?.protocol??(e?"anthropic":void 0),appName:e?.appName,platform:_reactNative.Platform.OS,build:isRelease?"release":"development"}),!c||!e)return a.current=null,void _askBuoyStore.askBuoyStore.setNotice("Ask Buoy isn't set up in this app yet. A developer needs to point it at your team's AI endpoint.");const t=e.protocol??"anthropic";isRelease&&e.apiKey?_askBuoyStore.askBuoyStore.setNotice("This build carries a plaintext apiKey — that's dev-only and it ships to every install. Use the headers callback with your own gateway for distributed builds."):"anthropic"===t&&/^https?:\/\/api\.openai\.com\//i.test(e.endpoint)?_askBuoyStore.askBuoyStore.setNotice('This endpoint is api.openai.com but the protocol is "anthropic". Set protocol: "openai" in the askBuoy config.'):"openai"===t&&/^https?:\/\/api\.anthropic\.com\//i.test(e.endpoint)?_askBuoyStore.askBuoyStore.setNotice('This endpoint is api.anthropic.com but the protocol is "openai". Remove protocol or set it to "anthropic".'):_askBuoyStore.askBuoyStore.setNotice(null);const o=[e.endpoint,e.protocol??"anthropic",e.model].join("|"),s=_askBuoyStore.askBuoyStore.getHeldSession();if(s&&s.signature===o)return a.current=s.session,s.session.setAvailableActions(g),s.session.setApprovalBypass(k.current),s.session.setReadOnly(p.current),void _askBuoyStore.askBuoyStore.setLedger(s.session.ledger);const u=(0,_agentCore.createAskBuoySession)({endpoint:e.endpoint,protocol:e.protocol??"anthropic",model:e.model,headers:e.headers,apiKey:e.apiKey,maxTokens:e.maxTokens,anthropicVersion:e.anthropicVersion,requestOverrides:e.requestOverrides,catalog:e.tools?.length?[..._agentCore.CATALOG,...e.tools]:void 0,dispatch:r,readSnapshot:_sharedUi.readToolSnapshot,availableActions:g,policy:e.policy,context:e.context,isRelease:isRelease,appName:e.appName,platform:_reactNative.Platform.OS,requestApproval:e=>_askBuoyStore.askBuoyStore.askApproval(e)});a.current=u,u.setApprovalBypass(k.current),u.setReadOnly(p.current),_askBuoyStore.askBuoyStore.holdSession(u,o),_askBuoyStore.askBuoyStore.setLedger(u.ledger);let i=!1;return(0,_sharedUi.waitForToolRegistry)().then(e=>{e&&!i&&u.prime()}),l&&!n.current&&(n.current=!0,(0,_transcriptPersistence.readTranscript)().then(e=>{e&&_askBuoyStore.askBuoyStore.hydrate({messages:e.messages,answers:e.answers,usage:e.usage,queued:e.queued})&&(a.current?.restore(e.history),e.ledger?.length&&a.current?.ledger.restore(e.ledger),e.pending&&_askBuoyStore.askBuoyStore.restorePending(e.pending))})),()=>{i=!0}},[c,e,g,h,l]),(0,_react.useEffect)(()=>{a.current?.setApprovalBypass(d)},[d]),(0,_react.useEffect)(()=>{a.current?.setReadOnly(y)},[y]);const f=t.messages,A=t.answers,b=t.usage,v=t.busy,m=t.pending,C=t.queued;(0,_react.useEffect)(()=>{if(!l)return;if(0===f.length)return;const e=()=>{(0,_transcriptPersistence.writeTranscript)((0,_transcriptPersistence.buildPayload)({messages:f,history:a.current?.messages??[],answers:A,usage:b,pending:m,ledger:_askBuoyStore.askBuoyStore.getLedger()?.list(),queued:C}))};if(!v)return void e();const t=setTimeout(e,SAVE_DEBOUNCE_MS);return()=>clearTimeout(t)},[l,v,f,A,b,m,C]);const w=(0,_react.useCallback)(e=>{if(!(0,_sharedUi.hasAccountAccess)()||!s.current)return;const t=a.current;if(!t)return;_askBuoyStore.askBuoyStore.beginTurn();const o=_askBuoyStore.askBuoyStore.startAssistant(),r=new AbortController;u.current=r,t.setAvailableActions(readAvailableActions());const n=i.current?.onEvent;(async()=>{try{for await(const s of t.send(e,r.signal))if(_askBuoyStore.askBuoyStore.applyEvent(o,s),n)try{n(s)}catch{}}catch(e){r.signal.aborted||_askBuoyStore.askBuoyStore.applyEvent(o,{type:"error",message:e instanceof Error?e.message:"Something went wrong talking to your AI endpoint."})}finally{r.signal.aborted&&_askBuoyStore.askBuoyStore.markStopped(o),_askBuoyStore.askBuoyStore.finishAssistant(o),u.current=null}})()},[]),T=(0,_react.useCallback)(e=>{if(!(0,_sharedUi.hasAccountAccess)()||!s.current)return;const t=e.trim();if(!a.current||!t)return;if(_askBuoyStore.askBuoyStore.getState().busy)return void _askBuoyStore.askBuoyStore.enqueue(t);const o=_askBuoyStore.askBuoyStore.getState().awaitingBlockId;o&&_askBuoyStore.askBuoyStore.recordAnswer({blockId:o,kind:"skipped"}),_askBuoyStore.askBuoyStore.addUser(t),w(t)},[w]),N=(0,_react.useCallback)(()=>{const{messages:e,busy:t}=_askBuoyStore.askBuoyStore.getState();if(t||!a.current)return;const o=[...e].reverse().find(e=>"user"===e.role);o&&w(o.text)},[w]),q=(0,_react.useCallback)(()=>{_askBuoyStore.askBuoyStore.requestStop(),_askBuoyStore.askBuoyStore.getState().pending&&_askBuoyStore.askBuoyStore.answerApproval(!1),u.current?.abort(),u.current=null},[]);(0,_react.useEffect)(()=>{const e=(0,_sharedUi.subscribeAccountAccess)(()=>{(0,_sharedUi.hasAccountAccess)()||q()});return()=>{e(),q()}},[q]),(0,_react.useEffect)(()=>{o||q()},[o,q]),(0,_react.useEffect)(()=>{if(0===t.queued.length)return;if("idle"!==(0,_askBuoyStore.turnPhaseOf)(t))return;if(null!==(0,_askBuoyStore.queuePauseReason)(t))return;const e=_askBuoyStore.askBuoyStore.shiftQueued();e&&T(e.text)},[t,T]);const R=(0,_react.useCallback)(e=>_askBuoyStore.askBuoyStore.takeQueuedToDraft(e),[]),O=(0,_react.useCallback)(e=>_askBuoyStore.askBuoyStore.removeQueued(e),[]),E=(0,_react.useCallback)(()=>{u.current?.abort(),u.current=null,(0,_resetConversation.clearConversation)()},[]),U=(0,_react.useCallback)(()=>(0,_resetConversation.resetConversation)({dispatch:_sharedUi.dispatchToolAction,undoFirst:!0}),[]),P=(0,_react.useCallback)(async t=>{const o=_askBuoyStore.askBuoyStore.getLedger();if(!o)return void _askBuoyStore.askBuoyStore.setNotice(`${t.label} couldn't run — no active Ask Buoy session.`);const s=e?.tools?.length?[..._agentCore.CATALOG,...e.tools]:void 0;if(t.targetDigest){const e=await(0,_agentCore.readTargetDigest)({toolId:t.toolId,action:t.action,params:t.params??{},dispatch:r,catalog:s});if(void 0!==e&&e!==t.targetDigest)return void _askBuoyStore.askBuoyStore.addNote(`“${t.label}” wasn't applied — what it would change has moved on since the app restarted. Nothing was written. Ask again if you still want it.`)}const a=await(0,_agentCore.runGatedAction)({toolId:t.toolId,action:t.action,params:t.params??{},dispatch:r,ledger:o,policy:S(),isRelease:isRelease,catalog:s});a.ok?_askBuoyStore.askBuoyStore.addNote(`Applied “${t.label}”, which was still waiting when the app restarted. Whatever else that answer was going to do is gone — ask again if there was more to it.`):_askBuoyStore.askBuoyStore.setNotice(`${t.label} failed — ${a.error}`)},[e,S]),I=(0,_react.useCallback)(e=>{const t=_askBuoyStore.askBuoyStore.getState().pending,o="boolean"==typeof e?e:e.approved;_askBuoyStore.askBuoyStore.answerApproval(e),t?.restored&&(o?P(t):_askBuoyStore.askBuoyStore.addNote(`Skipped “${t.label}”. Nothing was changed.`))},[P]),x=(0,_react.useCallback)(e=>{_askBuoyStore.askBuoyStore.recordAnswer(e);const t=questionBehind(e.blockId);T(t?`${t} — ${(0,_agentCore.answerToText)(e)}`:(0,_agentCore.answerToText)(e))},[T]),$=(0,_react.useCallback)(async(t,o)=>{if(!(0,_sharedUi.hasAccountAccess)()||!s.current)return void _askBuoyStore.askBuoyStore.setNotice("Ask Buoy requires Pro access.");if(t.send)return void T(t.send);if(!t.dispatch)return;const a=`${o}:${t.label}`,n=_askBuoyStore.askBuoyStore.getLedger();if(!n)return void _askBuoyStore.askBuoyStore.setNotice(`${t.label} failed — no active Ask Buoy session.`);_askBuoyStore.askBuoyStore.setActionState(a,"running");const u=await(0,_agentCore.runGatedAction)({toolId:t.dispatch.toolId,action:t.dispatch.action,params:t.dispatch.params??{},dispatch:r,ledger:n,policy:S(),isRelease:isRelease,catalog:e?.tools?.length?[..._agentCore.CATALOG,...e.tools]:void 0});u.ok?_askBuoyStore.askBuoyStore.setActionState(a,"done"):(_askBuoyStore.askBuoyStore.setActionState(a,"failed"),_askBuoyStore.askBuoyStore.setNotice(`${t.label} failed — ${u.error}`))},[T,e,S]);return{state:t,send:T,stop:q,reset:E,undoThenReset:U,approve:I,retry:N,answer:x,runAction:$,editQueued:R,removeQueued:O,configured:c,toolCount:Object.keys(g).length,availableToolIds:Object.keys(g)}}
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useAskBuoy = useAskBuoy;
+exports.useAskBuoyState = useAskBuoyState;
+var _sharedUi = require("@buoy-gg/shared-ui");
+var _react = require("react");
+var _reactNative = require("react-native");
+var _agentCore = require("@buoy-gg/agent-core");
+var _askBuoyStore = require("./askBuoyStore");
+var _resetConversation = require("./resetConversation");
+var _transcriptPersistence = require("./transcriptPersistence");
+var _useAskBuoySettings = require("./useAskBuoySettings");
+/**
+ * Wire the sheet to the agent.
+ *
+ * Two things here are load-bearing:
+ *
+ * 1. DISPATCH GOES THROUGH `dispatchToolAction`, the same on-device seam a
+ *    Scenario step and a desktop click use. No second adapter map, nothing
+ *    that can drift from what the broker sees.
+ * 2. THE SESSION IS REBUILT WHEN THE TOOL LIST CHANGES. The adapter map is a
+ *    memo whose contents depend on which packages resolved and whether a
+ *    QueryClientProvider is above FloatingDevTools — it is per-app and per
+ *    render, never a constant. A session that cached the tool list at open
+ *    would offer the model tools that are no longer there.
+ */
+
+const isRelease = typeof __DEV__ !== "undefined" && !__DEV__;
+
+/**
+ * What this device can dispatch, right now.
+ *
+ * `getSnapshot` is folded in because half of Buoy's read surface is not an
+ * action at all — console entries, network events, routes and env live only in
+ * the adapter's snapshot. Without it the model is offered a console tool whose
+ * sole action wipes the logs, and no way to read them.
+ *
+ * READ FRESH, never cached. Packages register over the first frames, and some
+ * only once the thing they wrap exists — route-events publishes its actions
+ * when the navigation container is up, long after this hook first runs. A
+ * snapshot taken at mount froze that: the agent was handed a route tool that
+ * could only `getSnapshot`, so asked to navigate it guessed three tool names
+ * that do not exist, spent 41 seconds, and told the user this build cannot
+ * move between screens. It can.
+ */
+/**
+ * The question a block asked, but ONLY when the model can no longer remember
+ * asking it — i.e. the bubble came back from disk. In a live conversation the
+ * model has the question in its own history and repeating it would put the
+ * words in the user's mouth twice.
+ *
+ * The wording field differs by block kind: `question` on choice and
+ * multiSelect, `label` on input / select / slider / dateTime, `title` on
+ * confirm and form.
+ */
+function questionBehind(blockId) {
+  for (const m of _askBuoyStore.askBuoyStore.getState().messages) {
+    if (!m.restored) continue;
+    for (const placed of m.blocks) {
+      const b = placed.block;
+      if (b?.id !== blockId) continue;
+      const asked = b.question ?? b.label ?? b.title;
+      return typeof asked === "string" && asked.trim() ? asked.trim() : undefined;
+    }
+  }
+  return undefined;
+}
+function readAvailableActions() {
+  try {
+    const actions = (0, _sharedUi.listToolActions)();
+    for (const toolId of (0, _sharedUi.listSnapshotToolIds)()) {
+      if (!actions[toolId]) actions[toolId] = [];
+      if (!actions[toolId].includes(_agentCore.SNAPSHOT_ACTION)) {
+        actions[toolId] = [_agentCore.SNAPSHOT_ACTION, ...actions[toolId]];
+      }
+    }
+    return actions;
+  } catch {
+    return {};
+  }
+}
+
+/** Long enough to coalesce a streaming answer's deltas, short enough to beat a crash. */
+const SAVE_DEBOUNCE_MS = 600;
+function useAskBuoyState() {
+  return (0, _react.useSyncExternalStore)(_askBuoyStore.askBuoyStore.subscribe, _askBuoyStore.askBuoyStore.getState, _askBuoyStore.askBuoyStore.getState);
+}
+function useAskBuoy(config) {
+  const state = useAskBuoyState();
+  const hasProAccess = (0, _sharedUi.getUseIsPro)()();
+  const proAccessRef = (0, _react.useRef)(hasProAccess);
+  proAccessRef.current = hasProAccess;
+  const dispatchAgentAction = (0, _react.useCallback)((...args) => {
+    if (!(0, _sharedUi.hasAccountAccess)() || !proAccessRef.current) return Promise.reject(new Error("Ask Buoy requires Pro access."));
+    return (0, _sharedUi.dispatchToolAction)(...args);
+  }, []);
+  const sessionRef = (0, _react.useRef)(null);
+  /** One restore attempt per mount — see the note at the read. */
+  const restoredRef = (0, _react.useRef)(false);
+  const abortRef = (0, _react.useRef)(null);
+  // Read through a ref where a stable callback needs the LATEST config (the
+  // onEvent tap) without re-creating the callback per render.
+  const configRef = (0, _react.useRef)(config);
+  configRef.current = config;
+  const configured = !!config?.endpoint && !!config?.model;
+  /**
+   * On by default. The conversation surviving a reload is what makes the tool
+   * usable while iterating, and it is the only thing that survives a crash —
+   * but it puts the chat on disk, so a host handling regulated data can say no.
+   */
+  const persist = config?.persistTranscript !== false;
+  /**
+   * The device's "don't ask me" toggle, read here rather than only in the
+   * settings view so it is loaded off disk before the first turn — a
+   * preference that only took effect once you had opened Settings would ask
+   * once, every launch, which is the thing it exists to stop.
+   */
+  const {
+    bypassApprovals,
+    readOnly
+  } = (0, _useAskBuoySettings.useAskBuoySettings)();
+  // Through refs where the session is BUILT: the flags are not session
+  // identity, and putting them in that effect's deps would rebuild the
+  // conversation on a toggle. The effects below push changes instead.
+  const bypassRef = (0, _react.useRef)(bypassApprovals);
+  bypassRef.current = bypassApprovals;
+  const readOnlyRef = (0, _react.useRef)(readOnly);
+  readOnlyRef.current = readOnly;
+
+  /**
+   * The policy a human-initiated dispatch runs under — block buttons and a
+   * restored approval. The session applies the device toggles itself; these
+   * two paths take `config.policy` directly, so without this the Read only
+   * toggle governed the model's calls and not the buttons the model drew.
+   * App OR device: the toggle narrows, never widens.
+   */
+  const effectivePolicy = (0, _react.useCallback)(() => readOnlyRef.current ? {
+    ...(config?.policy ?? {}),
+    readOnly: true
+  } : config?.policy ?? {}, [config]);
+
+  /**
+   * Re-read once the registry says it is up. This is what the surrounding code
+   * has always assumed happens — the session effect's note about `toolKey`
+   * changing "a frame or two after open" was describing a recomputation that,
+   * with an empty dependency list, never actually ran.
+   */
+  const [registryTick, setRegistryTick] = (0, _react.useState)(0);
+  (0, _react.useEffect)(() => {
+    let cancelled = false;
+    void (0, _sharedUi.waitForToolRegistry)().then(() => {
+      if (!cancelled) setRegistryTick(n => n + 1);
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, []);
+  const availableActions = (0, _react.useMemo)(() => readAvailableActions(), [registryTick]);
+  const toolKey = Object.keys(availableActions).sort().join(",");
+  (0, _react.useEffect)(() => {
+    _askBuoyStore.askBuoyStore.setConfigured(configured);
+    // Stamped on the store so an exported run says what it ran against.
+    _askBuoyStore.askBuoyStore.setMeta({
+      model: config?.model,
+      protocol: config?.protocol ?? (config ? "anthropic" : undefined),
+      appName: config?.appName,
+      platform: _reactNative.Platform.OS,
+      build: isRelease ? "release" : "development"
+    });
+    if (!configured || !config) {
+      sessionRef.current = null;
+      _askBuoyStore.askBuoyStore.setNotice("Ask Buoy isn't set up in this app yet. A developer needs to point it at your team's AI endpoint.");
+      return;
+    }
+    // The classic first-run mistake, caught statically: a provider's own URL
+    // with the wrong protocol fails with a raw error that says nothing about
+    // the one-line fix. ONLY the canonical provider hosts are checked — a
+    // gateway may legitimately speak either protocol on any path (our own dev
+    // gateway serves OpenAI framing on /v1/messages, and a path-based version
+    // of this check flagged it on the first device run).
+    const protocol = config.protocol ?? "anthropic";
+    if (isRelease && config.apiKey) {
+      _askBuoyStore.askBuoyStore.setNotice("This build carries a plaintext apiKey — that's dev-only and it ships to every install. Use the headers callback with your own gateway for distributed builds.");
+    } else if (protocol === "anthropic" && /^https?:\/\/api\.openai\.com\//i.test(config.endpoint)) {
+      _askBuoyStore.askBuoyStore.setNotice('This endpoint is api.openai.com but the protocol is "anthropic". Set protocol: "openai" in the askBuoy config.');
+    } else if (protocol === "openai" && /^https?:\/\/api\.anthropic\.com\//i.test(config.endpoint)) {
+      _askBuoyStore.askBuoyStore.setNotice('This endpoint is api.anthropic.com but the protocol is "openai". Remove protocol or set it to "anthropic".');
+    } else {
+      _askBuoyStore.askBuoyStore.setNotice(null);
+    }
+
+    // Reuse the held session while nothing material changed. The transcript
+    // already survives close/reopen in the module store; without this the
+    // session and ledger did not — reopening the sheet swapped in an empty
+    // ledger (undo bar gone, agent changes still live in the app) and a blank
+    // model memory behind a transcript that still showed the conversation.
+    // The tool list is deliberately NOT part of this signature. Packages
+    // register a frame or two apart, so `toolKey` legitimately changes right
+    // after open — and keying on it silently rebuilt the session mid-chat,
+    // throwing away the conversation, the model's memory and the undo ledger
+    // while the transcript (a separate store) kept rendering as if nothing
+    // happened. Verified on device: a destructive change went unrecorded
+    // because it landed in a ledger that had just been replaced.
+    const signature = [config.endpoint, config.protocol ?? "anthropic", config.model].join("|");
+    const held = _askBuoyStore.askBuoyStore.getHeldSession();
+    if (held && held.signature === signature) {
+      sessionRef.current = held.session;
+      held.session.setAvailableActions(availableActions);
+      held.session.setApprovalBypass(bypassRef.current);
+      held.session.setReadOnly(readOnlyRef.current);
+      _askBuoyStore.askBuoyStore.setLedger(held.session.ledger);
+      return;
+    }
+    const session = (0, _agentCore.createAskBuoySession)({
+      endpoint: config.endpoint,
+      protocol: config.protocol ?? "anthropic",
+      model: config.model,
+      headers: config.headers,
+      apiKey: config.apiKey,
+      maxTokens: config.maxTokens,
+      anthropicVersion: config.anthropicVersion,
+      requestOverrides: config.requestOverrides,
+      // Host-declared custom tools join the built-in catalog. toProviderTools
+      // still filters against the live registry, so a descriptor whose
+      // `custom:<id>` adapter never registered is simply not offered.
+      catalog: config.tools?.length ? [..._agentCore.CATALOG, ...config.tools] : undefined,
+      dispatch: dispatchAgentAction,
+      readSnapshot: _sharedUi.readToolSnapshot,
+      availableActions,
+      policy: config.policy,
+      context: config.context,
+      isRelease,
+      appName: config.appName,
+      platform: _reactNative.Platform.OS,
+      requestApproval: input => _askBuoyStore.askBuoyStore.askApproval(input)
+    });
+    sessionRef.current = session;
+    session.setApprovalBypass(bypassRef.current);
+    session.setReadOnly(readOnlyRef.current);
+    _askBuoyStore.askBuoyStore.holdSession(session, signature);
+    _askBuoyStore.askBuoyStore.setLedger(session.ledger);
+
+    /**
+     * Bring the last conversation back — both halves of it.
+     *
+     * The transcript and the model's memory are separate things (the store and
+     * the session), and restoring only the first is worse than restoring
+     * neither: the user reads a conversation the agent has no recollection of,
+     * and "undo that" or "now do the same for Pikachu" lands on an empty
+     * history. So the session is restored in the same pass, and only into a
+     * session this effect just built.
+     */
+    // The registry publishes on mount, a frame or two after first paint. Warm
+    // the grounding once it is there so the first question does not pay for it.
+    let cancelled = false;
+    void (0, _sharedUi.waitForToolRegistry)().then(ready => {
+      if (ready && !cancelled) void session.prime();
+    });
+
+    /**
+     * NOT gated on `cancelled`, and once per mount.
+     *
+     * The disk read races the tool registry, and it was losing about half the
+     * time. `availableActions` legitimately changes a frame or two after open
+     * (see the note above) — that re-runs this effect, whose cleanup sets
+     * `cancelled`, and the in-flight restore then threw its result away. The
+     * second pass takes the held-session branch and returns early, so nothing
+     * ever retried: the conversation was on disk, read correctly, and dropped
+     * on the floor. Caught by the e2e, where one test restored and the next
+     * did not, with no difference between them.
+     *
+     * Safe to leave running: `hydrate` refuses if anything has been said since,
+     * and `restore` refuses a session that already has history. Resolved
+     * against `sessionRef.current` rather than the captured `session` so a
+     * genuine reconfiguration mid-read restores into the session in use.
+     */
+    if (persist && !restoredRef.current) {
+      restoredRef.current = true;
+      void (0, _transcriptPersistence.readTranscript)().then(saved => {
+        if (!saved) return;
+        const hydrated = _askBuoyStore.askBuoyStore.hydrate({
+          messages: saved.messages,
+          answers: saved.answers,
+          usage: saved.usage,
+          queued: saved.queued
+        });
+        if (!hydrated) return;
+        sessionRef.current?.restore(saved.history);
+        // The undo bar, back with the transcript that promised it.
+        if (saved.ledger?.length) sessionRef.current?.ledger.restore(saved.ledger);
+        // A question the user never answered comes back with the conversation.
+        // Losing it silently reads as consent they never gave: nothing was
+        // tapped, so the change is still waiting as far as they know.
+        if (saved.pending) _askBuoyStore.askBuoyStore.restorePending(saved.pending);
+      });
+    }
+    return () => {
+      cancelled = true;
+    };
+  }, [configured, config, availableActions, toolKey, persist]);
+
+  /**
+   * Push a toggle made mid-conversation. Declared after the effect that builds
+   * the session, so on mount it lands on a session that already exists, and on
+   * a later flip it reaches the held one without disturbing the transcript.
+   */
+  (0, _react.useEffect)(() => {
+    sessionRef.current?.setApprovalBypass(bypassApprovals);
+  }, [bypassApprovals]);
+  (0, _react.useEffect)(() => {
+    sessionRef.current?.setReadOnly(readOnly);
+  }, [readOnly]);
+
+  /**
+   * Save on change: coalesced while a turn streams, immediate the moment it ends.
+   *
+   * The debounce exists because a streaming answer changes the store on every
+   * delta, and writing a whole transcript per token would cost more than the
+   * turn does. But applying it to the END of a turn as well left a window
+   * where the finished answer was on screen and not yet on disk — a crash or a
+   * fast reload inside it lost the whole turn, which is precisely the case
+   * this feature exists for. An e2e that relaunched as soon as the answer
+   * rendered lost it every time, and that is a real user doing a fast reload,
+   * not a harness artefact.
+   *
+   * Saving still happens DURING a turn as well, which is what lets a bubble
+   * the app died in come back marked interrupted rather than blank.
+   */
+  const messages = state.messages;
+  const answers = state.answers;
+  const usage = state.usage;
+  const busy = state.busy;
+  /**
+   * In the deps because an approval is the one thing that changes nothing
+   * else. `approval-required` adds no bubble and no tool row — the engine
+   * yields it and then parks — so without this the save that carries the card
+   * to disk never fires, and the reload it is meant to survive loses it.
+   */
+  const pending = state.pending;
+  const queued = state.queued;
+  (0, _react.useEffect)(() => {
+    if (!persist) return;
+    if (messages.length === 0) return;
+    const write = () => {
+      void (0, _transcriptPersistence.writeTranscript)((0, _transcriptPersistence.buildPayload)({
+        messages,
+        history: sessionRef.current?.messages ?? [],
+        answers,
+        usage,
+        pending,
+        ledger: _askBuoyStore.askBuoyStore.getLedger()?.list(),
+        queued
+      }));
+    };
+    if (!busy) {
+      write();
+      return;
+    }
+    const timer = setTimeout(write, SAVE_DEBOUNCE_MS);
+    return () => clearTimeout(timer);
+  }, [persist, busy, messages, answers, usage, pending, queued]);
+
+  /** Stream one turn into a fresh assistant bubble. Callers set up the user side. */
+  const runTurn = (0, _react.useCallback)(text => {
+    if (!(0, _sharedUi.hasAccountAccess)() || !proAccessRef.current) return;
+    const session = sessionRef.current;
+    if (!session) return;
+    _askBuoyStore.askBuoyStore.beginTurn();
+    const messageId = _askBuoyStore.askBuoyStore.startAssistant();
+    const controller = new AbortController();
+    abortRef.current = controller;
+
+    // The truth about this device, re-read at the top of every turn. A tool
+    // that registered since the sheet opened is dispatchable NOW, and the
+    // model is only offered what this list says it has.
+    session.setAvailableActions(readAvailableActions());
+    const onEvent = configRef.current?.onEvent;
+    void (async () => {
+      try {
+        for await (const ev of session.send(text, controller.signal)) {
+          _askBuoyStore.askBuoyStore.applyEvent(messageId, ev);
+          if (onEvent) {
+            try {
+              onEvent(ev);
+            } catch {
+              // The audit tap must never take the chat down.
+            }
+          }
+        }
+      } catch (err) {
+        // Stop is not a failure. The abort comes back as a cancelled fetch,
+        // and reporting that as an error told the user "couldn't reach your AI
+        // endpoint, check the connection" about the thing they had just asked
+        // for — with `FetchRequestCanceledException` printed underneath.
+        if (!controller.signal.aborted) {
+          _askBuoyStore.askBuoyStore.applyEvent(messageId, {
+            type: "error",
+            message: err instanceof Error ? err.message : "Something went wrong talking to your AI endpoint."
+          });
+        }
+      } finally {
+        // Marked HERE, not only in the catch. The engine now reads the abort
+        // between calls and returns cleanly, so most stops never throw — and
+        // a turn that ended because the user pressed Stop must say so either
+        // way, or the bubble just trails off as if the model ran out of words.
+        if (controller.signal.aborted) _askBuoyStore.askBuoyStore.markStopped(messageId);
+        _askBuoyStore.askBuoyStore.finishAssistant(messageId);
+        abortRef.current = null;
+      }
+    })();
+  }, []);
+  const send = (0, _react.useCallback)(text => {
+    if (!(0, _sharedUi.hasAccountAccess)() || !proAccessRef.current) return;
+    const trimmed = text.trim();
+    if (!sessionRef.current || !trimmed) return;
+
+    // Typed mid-turn: park it behind whatever is already parked. The
+    // composer already cleared the field, and silently dropping the words
+    // was the worst of all outcomes — the single slot this replaced did
+    // exactly that to every message but the last.
+    if (_askBuoyStore.askBuoyStore.getState().busy) {
+      _askBuoyStore.askBuoyStore.enqueue(trimmed);
+      return;
+    }
+
+    // Typing past an Ask block IS an answer: the block is skipped and locks.
+    // Without this the composer stayed on "Pick an option above…" forever and
+    // a stale choice sat tappable in the history.
+    const awaiting = _askBuoyStore.askBuoyStore.getState().awaitingBlockId;
+    if (awaiting) _askBuoyStore.askBuoyStore.recordAnswer({
+      blockId: awaiting,
+      kind: "skipped"
+    });
+    _askBuoyStore.askBuoyStore.addUser(trimmed);
+    runTurn(trimmed);
+  }, [runTurn]);
+  const retry = (0, _react.useCallback)(() => {
+    const {
+      messages,
+      busy
+    } = _askBuoyStore.askBuoyStore.getState();
+    if (busy || !sessionRef.current) return;
+    const lastUser = [...messages].reverse().find(m => m.role === "user");
+    if (!lastUser) return;
+    // The failed bubble is kept — see the note on `retry` in the interface.
+    runTurn(lastUser.text);
+  }, [runTurn]);
+  const stop = (0, _react.useCallback)(() => {
+    _askBuoyStore.askBuoyStore.requestStop();
+    // A pending approval parks an unresolved promise inside the engine; the
+    // abort signal is only read between calls, so Stop must also answer the
+    // approval (as declined) or the generator hangs forever.
+    if (_askBuoyStore.askBuoyStore.getState().pending) _askBuoyStore.askBuoyStore.answerApproval(false);
+    // Parked messages stay parked. The queue holds after a stop (see
+    // `queuePauseReason`), so ending the turn no longer flushes them — and
+    // they are not dumped into the composer either: three 4,000-character
+    // requests concatenated into one input lose their boundaries.
+    abortRef.current?.abort();
+    abortRef.current = null;
+  }, []);
+  (0, _react.useEffect)(() => {
+    const off = (0, _sharedUi.subscribeAccountAccess)(() => {
+      if (!(0, _sharedUi.hasAccountAccess)()) stop();
+    });
+    return () => {
+      off();
+      stop();
+    };
+  }, [stop]);
+
+  // Paid expiry and Weekend Pass ending keep the Free account admitted, but
+  // must still abort a paid-only turn that was already streaming.
+  (0, _react.useEffect)(() => {
+    if (!hasProAccess) stop();
+  }, [hasProAccess, stop]);
+
+  /**
+   * Deliver the next parked message — only when the chat is genuinely idle.
+   *
+   * `turnPhaseOf` + `queuePauseReason` decide, not `!busy`: the old check
+   * fired after an error (into the same dead connection), after Stop, and into
+   * an open Ask block as the answer to a question. See the store for the
+   * rules; this effect just obeys them.
+   */
+  (0, _react.useEffect)(() => {
+    if (state.queued.length === 0) return;
+    if ((0, _askBuoyStore.turnPhaseOf)(state) !== "idle") return;
+    if ((0, _askBuoyStore.queuePauseReason)(state) !== null) return;
+    const next = _askBuoyStore.askBuoyStore.shiftQueued();
+    if (next) send(next.text);
+  }, [state, send]);
+  const editQueued = (0, _react.useCallback)(id => _askBuoyStore.askBuoyStore.takeQueuedToDraft(id), []);
+  const removeQueued = (0, _react.useCallback)(id => _askBuoyStore.askBuoyStore.removeQueued(id), []);
+  const reset = (0, _react.useCallback)(() => {
+    abortRef.current?.abort();
+    abortRef.current = null;
+    // "New conversation" means gone, not hidden. Leaving the last chat on disk
+    // after the user asked for a clean one is the opposite of what they said.
+    (0, _resetConversation.clearConversation)();
+  }, []);
+  const undoThenReset = (0, _react.useCallback)(() => (0, _resetConversation.resetConversation)({
+    dispatch: _sharedUi.dispatchToolAction,
+    undoFirst: true
+  }), []);
+
+  /**
+   * Run a call whose approval outlived its turn.
+   *
+   * Through `runGatedAction` — the same gate a block button uses, where the
+   * human's tap IS the approval — rather than `dispatchToolAction` raw, so the
+   * deny list, read-only mode, the release refusals and the effect ledger all
+   * still apply to a change made this way. Undo works on it afterwards for
+   * exactly the same reason.
+   */
+  const applyRestoredApproval = (0, _react.useCallback)(async pending => {
+    const ledger = _askBuoyStore.askBuoyStore.getLedger();
+    if (!ledger) {
+      _askBuoyStore.askBuoyStore.setNotice(`${pending.label} couldn't run — no active Ask Buoy session.`);
+      return;
+    }
+    const catalog = config?.tools?.length ? [..._agentCore.CATALOG, ...config.tools] : undefined;
+    // Freshness before action. The card was asked in a run of the app that
+    // no longer exists; if what it would overwrite has moved since, writing
+    // the saved params is a change nobody approved. Re-read, compare, refuse.
+    if (pending.targetDigest) {
+      const now = await (0, _agentCore.readTargetDigest)({
+        toolId: pending.toolId,
+        action: pending.action,
+        params: pending.params ?? {},
+        dispatch: dispatchAgentAction,
+        catalog
+      });
+      if (now !== undefined && now !== pending.targetDigest) {
+        _askBuoyStore.askBuoyStore.addNote(`“${pending.label}” wasn't applied — what it would change has moved on since the app restarted. Nothing was written. Ask again if you still want it.`);
+        return;
+      }
+    }
+    const outcome = await (0, _agentCore.runGatedAction)({
+      toolId: pending.toolId,
+      action: pending.action,
+      params: pending.params ?? {},
+      dispatch: dispatchAgentAction,
+      ledger,
+      policy: effectivePolicy(),
+      isRelease,
+      catalog
+    });
+    if (outcome.ok) {
+      _askBuoyStore.askBuoyStore.addNote(`Applied “${pending.label}”, which was still waiting when the app restarted. Whatever else that answer was going to do is gone — ask again if there was more to it.`);
+    } else {
+      _askBuoyStore.askBuoyStore.setNotice(`${pending.label} failed — ${outcome.error}`);
+    }
+  }, [config, effectivePolicy]);
+  const approve = (0, _react.useCallback)(answer => {
+    const pending = _askBuoyStore.askBuoyStore.getState().pending;
+    const approved = typeof answer === "boolean" ? answer : answer.approved;
+    // Clear the card first either way: the tap is answered, and the dispatch
+    // below is slow enough to leave it sitting there looking unanswered.
+    _askBuoyStore.askBuoyStore.answerApproval(answer);
+    // A live card resolves the promise the engine is parked on, and the turn
+    // carries on from there. A RESTORED one has no turn behind it — that
+    // generator died with the process — so Allow has to run the call itself.
+    if (!pending?.restored) return;
+    if (!approved) {
+      _askBuoyStore.askBuoyStore.addNote(`Skipped “${pending.label}”. Nothing was changed.`);
+      return;
+    }
+    void applyRestoredApproval(pending);
+  }, [applyRestoredApproval]);
+  const answer = (0, _react.useCallback)(a => {
+    _askBuoyStore.askBuoyStore.recordAnswer(a);
+    // Plain words to the model, never JSON: "Business checkout", "Yes, go ahead."
+    //
+    // Unless the question came back from disk. A restored history is rewound
+    // to the last COMPLETE round, and an Ask block ends its turn with a
+    // `buoy_ui` call — so the turn that asked is always rewound out of the
+    // model's memory while its buttons stay tappable. A bare "Quantity" then
+    // arrives with nothing behind it, and the model answers "that could mean
+    // a couple of different things". Carry the question with the answer.
+    const asked = questionBehind(a.blockId);
+    send(asked ? `${asked} — ${(0, _agentCore.answerToText)(a)}` : (0, _agentCore.answerToText)(a));
+  }, [send]);
+
+  /**
+   * Block buttons. `send` is a chat reply; `dispatch` runs the action through
+   * `runGatedAction` — the SAME validation, policy and ledger path a model
+   * call takes, minus the model. The first version called `dispatchToolAction`
+   * raw, which made a model-authored button an invisible, ungoverned,
+   * unundoable mutation while the `buoy_ui` schema promised the opposite.
+   * The human's tap satisfies `requireApproval`; deny lists, read-only mode
+   * and release refusals still stand. Button state is tracked so a tap shows
+   * running → done and can't double-fire.
+   * (`minimize` / `openTool` are the sheet's to handle; see AskBuoyModal.)
+   */
+  const runAction = (0, _react.useCallback)(async (action, blockId) => {
+    if (!(0, _sharedUi.hasAccountAccess)() || !proAccessRef.current) {
+      _askBuoyStore.askBuoyStore.setNotice("Ask Buoy requires Pro access.");
+      return;
+    }
+    if (action.send) {
+      send(action.send);
+      return;
+    }
+    if (!action.dispatch) return;
+    const key = `${blockId}:${action.label}`;
+    const ledger = _askBuoyStore.askBuoyStore.getLedger();
+    if (!ledger) {
+      _askBuoyStore.askBuoyStore.setNotice(`${action.label} failed — no active Ask Buoy session.`);
+      return;
+    }
+    _askBuoyStore.askBuoyStore.setActionState(key, "running");
+    const outcome = await (0, _agentCore.runGatedAction)({
+      toolId: action.dispatch.toolId,
+      action: action.dispatch.action,
+      params: action.dispatch.params ?? {},
+      dispatch: dispatchAgentAction,
+      ledger,
+      policy: effectivePolicy(),
+      isRelease,
+      // Same merged catalog the session offers, so a button on a custom
+      // tool's block is not refused as unknown.
+      catalog: config?.tools?.length ? [..._agentCore.CATALOG, ...config.tools] : undefined
+    });
+    if (outcome.ok) {
+      _askBuoyStore.askBuoyStore.setActionState(key, "done");
+    } else {
+      _askBuoyStore.askBuoyStore.setActionState(key, "failed");
+      _askBuoyStore.askBuoyStore.setNotice(`${action.label} failed — ${outcome.error}`);
+    }
+  }, [send, config, effectivePolicy]);
+  return {
+    state,
+    send,
+    stop,
+    reset,
+    undoThenReset,
+    approve,
+    retry,
+    answer,
+    runAction,
+    editQueued,
+    removeQueued,
+    configured,
+    toolCount: Object.keys(availableActions).length,
+    availableToolIds: Object.keys(availableActions)
+  };
+}
+//# sourceMappingURL=useAskBuoy.js.map