@athenaintel/react 0.23.3 → 0.24.0

package/dist/dictation/use-dictation.js

@@ -2,7 +2,7 @@ import { useMemo, useReducer, useState, useRef, useEffect, useCallback } from "r
 import { athenaDiagnostics } from "../diagnostics/athena-diagnostics.js";
 import { createWebSpeechDictationEngine, DICTATION_ENGINE_ERROR_KINDS } from "./dictation-engine.js";
 import { dictationReducer, INITIAL_DICTATION_STATE, DICTATION_STATUSES, spokenText, joinSpeech } from "./dictation-state.js";
-const STOP_FLUSH_TIMEOUT_MS = 1500;
+const DEFAULT_STOP_FLUSH_TIMEOUT_MS = 1500;
 const EMPTY_TRANSCRIPT = { final: "", interim: "" };
 function documentLanguage() {
   if (typeof document !== "undefined" && document.documentElement.lang) {
@@ -34,6 +34,7 @@ function useDictation(options = {}) {
   const onAutoEndRef = useRef(onAutoEnd);
   onAutoEndRef.current = onAutoEnd;
   const stopWaitersRef = useRef([]);
+  const sessionErrorRef = useRef(null);
   const generationRef = useRef(0);
   useEffect(() => {
     setIsSupported(engine.isSupported());
@@ -41,7 +42,8 @@ function useDictation(options = {}) {
   const settleWaiters = useCallback((spoken) => {
     const waiters = stopWaitersRef.current;
     stopWaitersRef.current = [];
-    for (const resolve of waiters) resolve(spoken);
+    const result = { text: spoken, error: sessionErrorRef.current };
+    for (const resolve of waiters) resolve(result);
   }, []);
   const releaseSession = useCallback(() => {
     sessionRef.current = null;
@@ -63,6 +65,7 @@ function useDictation(options = {}) {
         level: "warn",
         data: { phase: "error", engine: engine.id, kind: engineError.kind }
       });
+      sessionErrorRef.current = engineError;
       dispatch({ type: "error", error: engineError });
     },
     [engine.id]
@@ -72,6 +75,7 @@ function useDictation(options = {}) {
     const generation = generationRef.current + 1;
     generationRef.current = generation;
     transcriptRef.current = EMPTY_TRANSCRIPT;
+    sessionErrorRef.current = null;
     dispatch({ type: "start" });
     athenaDiagnostics.emit("composer.dictation", {
       level: "debug",
@@ -160,25 +164,31 @@ function useDictation(options = {}) {
       if (stateRef.current.status === DICTATION_STATUSES.starting) {
         teardown();
         dispatch({ type: "cancel" });
-        return Promise.resolve("");
+        return Promise.resolve({ text: "", error: null });
       }
-      return Promise.resolve(spokenText(transcriptRef.current));
+      return Promise.resolve({ text: spokenText(transcriptRef.current), error: sessionErrorRef.current });
     }
     dispatch({ type: "stop" });
     const flushed = new Promise((resolve) => {
       stopWaitersRef.current.push(resolve);
       window.setTimeout(() => {
         if (sessionRef.current === session) {
+          if (!spokenText(transcriptRef.current)) {
+            reportEngineError({
+              kind: DICTATION_ENGINE_ERROR_KINDS.connection,
+              message: "Transcription timed out. Try again."
+            });
+          }
           session.abort();
           dispatch({ type: "ended" });
           releaseSession();
           settleWaiters(spokenText(transcriptRef.current));
         }
-      }, STOP_FLUSH_TIMEOUT_MS);
+      }, engine.flushTimeoutMs ?? DEFAULT_STOP_FLUSH_TIMEOUT_MS);
     });
     session.stop();
     return flushed;
-  }, [releaseSession, settleWaiters, teardown]);
+  }, [engine.flushTimeoutMs, releaseSession, reportEngineError, settleWaiters, teardown]);
   const cancel = useCallback(() => {
     teardown();
     dispatch({ type: "cancel" });
@@ -193,6 +203,7 @@ function useDictation(options = {}) {
     error: state.error,
     stream,
     isSupported,
+    engine,
     start,
     stop,
     cancel

package/dist/dictation/use-dictation.js.map

@@ -1 +1 @@
-{"version":3,"file":"use-dictation.js","sources":["../../src/dictation/use-dictation.ts"],"sourcesContent":["import { useCallback, useEffect, useMemo, useReducer, useRef, useState } from 'react';\nimport { athenaDiagnostics } from '../diagnostics/athena-diagnostics';\nimport {\n  createWebSpeechDictationEngine,\n  DICTATION_ENGINE_ERROR_KINDS,\n  type DictationEngine,\n  type DictationEngineError,\n  type DictationEngineSession,\n} from './dictation-engine';\nimport {\n  DICTATION_STATUSES,\n  dictationReducer,\n  INITIAL_DICTATION_STATE,\n  joinSpeech,\n  spokenText,\n  type DictationStatus,\n  type DictationTranscript,\n} from './dictation-state';\n\nexport interface UseDictationOptions {\n  /** Speech engine. Defaults to the browser's Web Speech API. */\n  engine?: DictationEngine;\n  /** BCP-47 language tag. Defaults to the document language, else `en-US`. */\n  lang?: string;\n  /**\n   * Open the microphone through `getUserMedia` so callers get a `stream` for\n   * a waveform. Web Speech opens its own capture; this second capture is\n   * what the level meter reads. Defaults to true.\n   */\n  captureStream?: boolean;\n  /**\n   * The engine ended on its own (silence window, recognizer timeout) while\n   * listening, without `stop()` or `cancel()`. Receives the spoken text so\n   * the words are not lost; the composer puts them into the draft.\n   */\n  onAutoEnd?: (spoken: string) => void;\n}\n\nexport interface DictationController {\n  status: DictationStatus;\n  /** True while starting, listening or stopping. */\n  isActive: boolean;\n  transcript: DictationTranscript;\n  /** `final` plus the interim tail, ready to hand to the composer. */\n  text: string;\n  error: DictationEngineError | null;\n  /** The microphone stream while active (for a waveform), else null. */\n  stream: MediaStream | null;\n  /** Whether the engine can run here. Hide the control when false. */\n  isSupported: boolean;\n  start: () => void;\n  /**\n   * Finish recording. Resolves with the spoken text once the engine has\n   * flushed (bounded wait), so trailing words are not lost.\n   */\n  stop: () => Promise<string>;\n  /** Discard the session and its transcript. */\n  cancel: () => void;\n}\n\n/** How long `stop()` waits for the engine's final flush before giving up. */\nconst STOP_FLUSH_TIMEOUT_MS = 1500;\n\ntype StopResolver = (spoken: string) => void;\n\nconst EMPTY_TRANSCRIPT: DictationTranscript = { final: '', interim: '' };\n\nfunction documentLanguage(): string {\n  if (typeof document !== 'undefined' && document.documentElement.lang) {\n    return document.documentElement.lang;\n  }\n  if (typeof navigator !== 'undefined' && navigator.language) return navigator.language;\n  return 'en-US';\n}\n\nasync function openMicrophone(): Promise<MediaStream | null> {\n  if (typeof navigator === 'undefined' || !navigator.mediaDevices?.getUserMedia) return null;\n  return navigator.mediaDevices.getUserMedia({ audio: true });\n}\n\nfunction releaseStream(stream: MediaStream | null): void {\n  if (!stream) return;\n  for (const track of stream.getTracks()) track.stop();\n}\n\n/**\n * Drive a dictation session: microphone, speech engine, and the transcript\n * state machine. The composer renders the waveform from `stream` and the\n * live caption from `transcript`; on `stop()` it appends `text` to the draft.\n */\nexport function useDictation(options: UseDictationOptions = {}): DictationController {\n  const engine = useMemo(() => options.engine ?? createWebSpeechDictationEngine(), [options.engine]);\n  const { lang, captureStream = true, onAutoEnd } = options;\n  const [state, dispatch] = useReducer(dictationReducer, INITIAL_DICTATION_STATE);\n  const [stream, setStream] = useState<MediaStream | null>(null);\n  const [isSupported, setIsSupported] = useState(false);\n\n  const sessionRef = useRef<DictationEngineSession | null>(null);\n  const streamRef = useRef<MediaStream | null>(null);\n  const stateRef = useRef(state);\n  stateRef.current = state;\n  // The authoritative transcript, updated synchronously as the engine reports\n  // it. The reducer's copy renders the caption; this one is what `stop()` and\n  // `onAutoEnd` hand over, so an engine that flushes its last words and ends\n  // in the same tick — before React has rendered — loses nothing.\n  const transcriptRef = useRef<DictationTranscript>(EMPTY_TRANSCRIPT);\n  const onAutoEndRef = useRef(onAutoEnd);\n  onAutoEndRef.current = onAutoEnd;\n  // stop() callers waiting for the engine's final flush.\n  const stopWaitersRef = useRef<StopResolver[]>([]);\n  // Distinguishes a fresh session from the callbacks of a torn-down one.\n  const generationRef = useRef(0);\n\n  useEffect(() => {\n    setIsSupported(engine.isSupported());\n  }, [engine]);\n\n  const settleWaiters = useCallback((spoken: string) => {\n    const waiters = stopWaitersRef.current;\n    stopWaitersRef.current = [];\n    for (const resolve of waiters) resolve(spoken);\n  }, []);\n\n  const releaseSession = useCallback(() => {\n    sessionRef.current = null;\n    releaseStream(streamRef.current);\n    streamRef.current = null;\n    setStream(null);\n  }, []);\n\n  const teardown = useCallback(() => {\n    generationRef.current += 1;\n    sessionRef.current?.abort();\n    releaseSession();\n    transcriptRef.current = EMPTY_TRANSCRIPT;\n    settleWaiters('');\n  }, [releaseSession, settleWaiters]);\n\n  const reportEngineError = useCallback(\n    (engineError: DictationEngineError) => {\n      athenaDiagnostics.emit('composer.dictation', {\n        level: 'warn',\n        data: { phase: 'error', engine: engine.id, kind: engineError.kind },\n      });\n      dispatch({ type: 'error', error: engineError });\n    },\n    [engine.id],\n  );\n\n  const start = useCallback(() => {\n    if (sessionRef.current) return;\n    const generation = generationRef.current + 1;\n    generationRef.current = generation;\n    transcriptRef.current = EMPTY_TRANSCRIPT;\n    dispatch({ type: 'start' });\n    athenaDiagnostics.emit('composer.dictation', {\n      level: 'debug',\n      data: { phase: 'start', engine: engine.id },\n    });\n\n    const run = async () => {\n      let microphone: MediaStream | null = null;\n      if (captureStream) {\n        try {\n          microphone = await openMicrophone();\n        } catch (error) {\n          if (generationRef.current !== generation) {\n            releaseStream(microphone);\n            return;\n          }\n          dispatch({\n            type: 'error',\n            error: {\n              kind: DICTATION_ENGINE_ERROR_KINDS.permission,\n              message:\n                error instanceof DOMException && error.name === 'NotFoundError'\n                  ? 'No microphone was found.'\n                  : 'Microphone access was denied. Allow the microphone for this site and try again.',\n            },\n          });\n          return;\n        }\n      }\n      if (generationRef.current !== generation) {\n        releaseStream(microphone);\n        return;\n      }\n      streamRef.current = microphone;\n      setStream(microphone);\n\n      // An engine may fail synchronously inside start() (Web Speech throws\n      // when recognition.start() is refused) and run onError/onEnd before we\n      // hold the session. Those callbacks flip this flag so a dead session is\n      // never stored, which would make every later mic click return early.\n      let terminated = false;\n      const endSession = () => {\n        terminated = true;\n        const current = stateRef.current;\n        const spoken = spokenText(transcriptRef.current);\n        // No stop() is waiting: the engine gave up on its own. Hand the\n        // words over so they land in the draft instead of vanishing.\n        const endedOnItsOwn =\n          stopWaitersRef.current.length === 0 && current.status === DICTATION_STATUSES.listening;\n        // The reducer keeps an error status through 'ended', so an error\n        // reported just before the engine closed stays on screen.\n        dispatch({ type: 'ended' });\n        releaseSession();\n        settleWaiters(spoken);\n        if (endedOnItsOwn) onAutoEndRef.current?.(spoken);\n      };\n      let session: DictationEngineSession;\n      try {\n        session = engine.start({\n          stream: microphone,\n          lang: lang ?? documentLanguage(),\n          callbacks: {\n            onTranscript: (update) => {\n              if (generationRef.current !== generation) return;\n              transcriptRef.current = {\n                final: joinSpeech(transcriptRef.current.final, update.final),\n                interim: update.interim,\n              };\n              dispatch({ type: 'transcript', update });\n            },\n            onError: (engineError) => {\n              if (generationRef.current !== generation) return;\n              // A silence timeout is the engine giving up politely; keep the\n              // words we have instead of showing an error.\n              if (engineError.kind === DICTATION_ENGINE_ERROR_KINDS.noSpeech) return;\n              reportEngineError(engineError);\n            },\n            onEnd: () => {\n              if (generationRef.current !== generation) return;\n              endSession();\n            },\n          },\n        });\n      } catch (error) {\n        // A relay engine that cannot build its session must not strand the\n        // microphone or leave the composer in `starting`.\n        releaseSession();\n        reportEngineError({\n          kind: DICTATION_ENGINE_ERROR_KINDS.connection,\n          message: error instanceof Error ? error.message : 'Dictation could not start.',\n        });\n        return;\n      }\n      if (terminated) return;\n      sessionRef.current = session;\n      dispatch({ type: 'listening' });\n    };\n    void run();\n  }, [captureStream, engine, lang, releaseSession, reportEngineError, settleWaiters]);\n\n  const stop = useCallback((): Promise<string> => {\n    const session = sessionRef.current;\n    if (!session) {\n      // Stopped while the microphone prompt was still open: nothing was heard\n      // yet, and the pending start must not bring the engine up afterwards.\n      if (stateRef.current.status === DICTATION_STATUSES.starting) {\n        teardown();\n        dispatch({ type: 'cancel' });\n        return Promise.resolve('');\n      }\n      return Promise.resolve(spokenText(transcriptRef.current));\n    }\n    dispatch({ type: 'stop' });\n    const flushed = new Promise<string>((resolve) => {\n      stopWaitersRef.current.push(resolve);\n      window.setTimeout(() => {\n        // Bounded wait: a recognizer that never fires onend must not hold the\n        // composer hostage. Force the session closed and hand over what was\n        // heard so far.\n        if (sessionRef.current === session) {\n          session.abort();\n          dispatch({ type: 'ended' });\n          releaseSession();\n          settleWaiters(spokenText(transcriptRef.current));\n        }\n      }, STOP_FLUSH_TIMEOUT_MS);\n    });\n    session.stop();\n    return flushed;\n  }, [releaseSession, settleWaiters, teardown]);\n\n  const cancel = useCallback(() => {\n    teardown();\n    dispatch({ type: 'cancel' });\n  }, [teardown]);\n\n  // Release the microphone with the component.\n  useEffect(() => () => teardown(), [teardown]);\n\n  const isActive =\n    state.status === DICTATION_STATUSES.starting ||\n    state.status === DICTATION_STATUSES.listening ||\n    state.status === DICTATION_STATUSES.stopping;\n\n  return {\n    status: state.status,\n    isActive,\n    transcript: state.transcript,\n    text: spokenText(state.transcript),\n    error: state.error,\n    stream,\n    isSupported,\n    start,\n    stop,\n    cancel,\n  };\n}\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"use-dictation.js","sources":["../../src/dictation/use-dictation.ts"],"sourcesContent":["import { useCallback, useEffect, useMemo, useReducer, useRef, useState } from 'react';\nimport { athenaDiagnostics } from '../diagnostics/athena-diagnostics';\nimport {\n  createWebSpeechDictationEngine,\n  DICTATION_ENGINE_ERROR_KINDS,\n  type DictationEngine,\n  type DictationEngineError,\n  type DictationEngineSession,\n} from './dictation-engine';\nimport {\n  DICTATION_STATUSES,\n  dictationReducer,\n  INITIAL_DICTATION_STATE,\n  joinSpeech,\n  spokenText,\n  type DictationStatus,\n  type DictationTranscript,\n} from './dictation-state';\n\nexport interface UseDictationOptions {\n  /**\n   * Speech engine. Defaults to the browser's Web Speech API; `AthenaChat`\n   * passes the record-then-transcribe engine from `useAthenaDictationEngine`.\n   */\n  engine?: DictationEngine;\n  /** BCP-47 language tag. Defaults to the document language, else `en-US`. */\n  lang?: string;\n  /**\n   * Open the microphone through `getUserMedia` so callers get a `stream` for\n   * a waveform. Web Speech opens its own capture; this second capture is\n   * what the level meter reads. Defaults to true.\n   */\n  captureStream?: boolean;\n  /**\n   * The engine ended on its own (silence window, recognizer timeout) while\n   * listening, without `stop()` or `cancel()`. Receives the spoken text so\n   * the words are not lost; the composer puts them into the draft.\n   */\n  onAutoEnd?: (spoken: string) => void;\n}\n\nexport interface DictationStopResult {\n  /** Spoken text (final plus interim tail) gathered before the engine closed. */\n  text: string;\n  /**\n   * The engine error reported during this session, if any. When set the\n   * transcript may be incomplete: a recorded engine whose upload failed has no\n   * words to hand over, so callers should not send the draft as if it were.\n   */\n  error: DictationEngineError | null;\n}\n\nexport interface DictationController {\n  status: DictationStatus;\n  /** True while starting, listening or stopping. */\n  isActive: boolean;\n  transcript: DictationTranscript;\n  /** `final` plus the interim tail, ready to hand to the composer. */\n  text: string;\n  error: DictationEngineError | null;\n  /** The microphone stream while active (for a waveform), else null. */\n  stream: MediaStream | null;\n  /** Whether the engine can run here. Hide the control when false. */\n  isSupported: boolean;\n  /** The engine in use (for its `stoppingLabel` and diagnostics). */\n  engine: DictationEngine;\n  start: () => void;\n  /**\n   * Finish recording. Resolves once the engine has flushed (bounded wait), so\n   * trailing words are not lost, with the spoken text and any error raised\n   * along the way.\n   */\n  stop: () => Promise<DictationStopResult>;\n  /** Discard the session and its transcript. */\n  cancel: () => void;\n}\n\n/** How long `stop()` waits for a live engine's final flush before giving up. */\nconst DEFAULT_STOP_FLUSH_TIMEOUT_MS = 1500;\n\ntype StopResolver = (result: DictationStopResult) => void;\n\nconst EMPTY_TRANSCRIPT: DictationTranscript = { final: '', interim: '' };\n\nfunction documentLanguage(): string {\n  if (typeof document !== 'undefined' && document.documentElement.lang) {\n    return document.documentElement.lang;\n  }\n  if (typeof navigator !== 'undefined' && navigator.language) return navigator.language;\n  return 'en-US';\n}\n\nasync function openMicrophone(): Promise<MediaStream | null> {\n  if (typeof navigator === 'undefined' || !navigator.mediaDevices?.getUserMedia) return null;\n  return navigator.mediaDevices.getUserMedia({ audio: true });\n}\n\nfunction releaseStream(stream: MediaStream | null): void {\n  if (!stream) return;\n  for (const track of stream.getTracks()) track.stop();\n}\n\n/**\n * Drive a dictation session: microphone, speech engine, and the transcript\n * state machine. The composer renders the waveform from `stream` and the\n * live caption from `transcript`; on `stop()` it appends `text` to the draft.\n */\nexport function useDictation(options: UseDictationOptions = {}): DictationController {\n  const engine = useMemo(() => options.engine ?? createWebSpeechDictationEngine(), [options.engine]);\n  const { lang, captureStream = true, onAutoEnd } = options;\n  const [state, dispatch] = useReducer(dictationReducer, INITIAL_DICTATION_STATE);\n  const [stream, setStream] = useState<MediaStream | null>(null);\n  const [isSupported, setIsSupported] = useState(false);\n\n  const sessionRef = useRef<DictationEngineSession | null>(null);\n  const streamRef = useRef<MediaStream | null>(null);\n  const stateRef = useRef(state);\n  stateRef.current = state;\n  // The authoritative transcript, updated synchronously as the engine reports\n  // it. The reducer's copy renders the caption; this one is what `stop()` and\n  // `onAutoEnd` hand over, so an engine that flushes its last words and ends\n  // in the same tick — before React has rendered — loses nothing.\n  const transcriptRef = useRef<DictationTranscript>(EMPTY_TRANSCRIPT);\n  const onAutoEndRef = useRef(onAutoEnd);\n  onAutoEndRef.current = onAutoEnd;\n  // stop() callers waiting for the engine's final flush.\n  const stopWaitersRef = useRef<StopResolver[]>([]);\n  // Last engine error of the current session, handed to stop() callers\n  // synchronously (the reducer's copy may not have rendered yet).\n  const sessionErrorRef = useRef<DictationEngineError | null>(null);\n  // Distinguishes a fresh session from the callbacks of a torn-down one.\n  const generationRef = useRef(0);\n\n  useEffect(() => {\n    setIsSupported(engine.isSupported());\n  }, [engine]);\n\n  const settleWaiters = useCallback((spoken: string) => {\n    const waiters = stopWaitersRef.current;\n    stopWaitersRef.current = [];\n    const result: DictationStopResult = { text: spoken, error: sessionErrorRef.current };\n    for (const resolve of waiters) resolve(result);\n  }, []);\n\n  const releaseSession = useCallback(() => {\n    sessionRef.current = null;\n    releaseStream(streamRef.current);\n    streamRef.current = null;\n    setStream(null);\n  }, []);\n\n  const teardown = useCallback(() => {\n    generationRef.current += 1;\n    sessionRef.current?.abort();\n    releaseSession();\n    transcriptRef.current = EMPTY_TRANSCRIPT;\n    settleWaiters('');\n  }, [releaseSession, settleWaiters]);\n\n  const reportEngineError = useCallback(\n    (engineError: DictationEngineError) => {\n      athenaDiagnostics.emit('composer.dictation', {\n        level: 'warn',\n        data: { phase: 'error', engine: engine.id, kind: engineError.kind },\n      });\n      sessionErrorRef.current = engineError;\n      dispatch({ type: 'error', error: engineError });\n    },\n    [engine.id],\n  );\n\n  const start = useCallback(() => {\n    if (sessionRef.current) return;\n    const generation = generationRef.current + 1;\n    generationRef.current = generation;\n    transcriptRef.current = EMPTY_TRANSCRIPT;\n    sessionErrorRef.current = null;\n    dispatch({ type: 'start' });\n    athenaDiagnostics.emit('composer.dictation', {\n      level: 'debug',\n      data: { phase: 'start', engine: engine.id },\n    });\n\n    const run = async () => {\n      let microphone: MediaStream | null = null;\n      if (captureStream) {\n        try {\n          microphone = await openMicrophone();\n        } catch (error) {\n          if (generationRef.current !== generation) {\n            releaseStream(microphone);\n            return;\n          }\n          dispatch({\n            type: 'error',\n            error: {\n              kind: DICTATION_ENGINE_ERROR_KINDS.permission,\n              message:\n                error instanceof DOMException && error.name === 'NotFoundError'\n                  ? 'No microphone was found.'\n                  : 'Microphone access was denied. Allow the microphone for this site and try again.',\n            },\n          });\n          return;\n        }\n      }\n      if (generationRef.current !== generation) {\n        releaseStream(microphone);\n        return;\n      }\n      streamRef.current = microphone;\n      setStream(microphone);\n\n      // An engine may fail synchronously inside start() (Web Speech throws\n      // when recognition.start() is refused) and run onError/onEnd before we\n      // hold the session. Those callbacks flip this flag so a dead session is\n      // never stored, which would make every later mic click return early.\n      let terminated = false;\n      const endSession = () => {\n        terminated = true;\n        const current = stateRef.current;\n        const spoken = spokenText(transcriptRef.current);\n        // No stop() is waiting: the engine gave up on its own. Hand the\n        // words over so they land in the draft instead of vanishing.\n        const endedOnItsOwn =\n          stopWaitersRef.current.length === 0 && current.status === DICTATION_STATUSES.listening;\n        // The reducer keeps an error status through 'ended', so an error\n        // reported just before the engine closed stays on screen.\n        dispatch({ type: 'ended' });\n        releaseSession();\n        settleWaiters(spoken);\n        if (endedOnItsOwn) onAutoEndRef.current?.(spoken);\n      };\n      let session: DictationEngineSession;\n      try {\n        session = engine.start({\n          stream: microphone,\n          lang: lang ?? documentLanguage(),\n          callbacks: {\n            onTranscript: (update) => {\n              if (generationRef.current !== generation) return;\n              transcriptRef.current = {\n                final: joinSpeech(transcriptRef.current.final, update.final),\n                interim: update.interim,\n              };\n              dispatch({ type: 'transcript', update });\n            },\n            onError: (engineError) => {\n              if (generationRef.current !== generation) return;\n              // A silence timeout is the engine giving up politely; keep the\n              // words we have instead of showing an error.\n              if (engineError.kind === DICTATION_ENGINE_ERROR_KINDS.noSpeech) return;\n              reportEngineError(engineError);\n            },\n            onEnd: () => {\n              if (generationRef.current !== generation) return;\n              endSession();\n            },\n          },\n        });\n      } catch (error) {\n        // A relay engine that cannot build its session must not strand the\n        // microphone or leave the composer in `starting`.\n        releaseSession();\n        reportEngineError({\n          kind: DICTATION_ENGINE_ERROR_KINDS.connection,\n          message: error instanceof Error ? error.message : 'Dictation could not start.',\n        });\n        return;\n      }\n      if (terminated) return;\n      sessionRef.current = session;\n      dispatch({ type: 'listening' });\n    };\n    void run();\n  }, [captureStream, engine, lang, releaseSession, reportEngineError, settleWaiters]);\n\n  const stop = useCallback((): Promise<DictationStopResult> => {\n    const session = sessionRef.current;\n    if (!session) {\n      // Stopped while the microphone prompt was still open: nothing was heard\n      // yet, and the pending start must not bring the engine up afterwards.\n      if (stateRef.current.status === DICTATION_STATUSES.starting) {\n        teardown();\n        dispatch({ type: 'cancel' });\n        return Promise.resolve({ text: '', error: null });\n      }\n      return Promise.resolve({ text: spokenText(transcriptRef.current), error: sessionErrorRef.current });\n    }\n    dispatch({ type: 'stop' });\n    const flushed = new Promise<DictationStopResult>((resolve) => {\n      stopWaitersRef.current.push(resolve);\n      window.setTimeout(() => {\n        // Bounded wait: a recognizer that never fires onend must not hold the\n        // composer hostage. Force the session closed and hand over what was\n        // heard so far. An engine that had nothing to show yet (a recorded\n        // clip still transcribing) surfaces that as an error rather than\n        // passing off silence as the result.\n        if (sessionRef.current === session) {\n          // Report before abort(): an engine that ends synchronously on\n          // abort settles the waiters, and they must see this error.\n          if (!spokenText(transcriptRef.current)) {\n            reportEngineError({\n              kind: DICTATION_ENGINE_ERROR_KINDS.connection,\n              message: 'Transcription timed out. Try again.',\n            });\n          }\n          session.abort();\n          dispatch({ type: 'ended' });\n          releaseSession();\n          settleWaiters(spokenText(transcriptRef.current));\n        }\n      }, engine.flushTimeoutMs ?? DEFAULT_STOP_FLUSH_TIMEOUT_MS);\n    });\n    session.stop();\n    return flushed;\n  }, [engine.flushTimeoutMs, releaseSession, reportEngineError, settleWaiters, teardown]);\n\n  const cancel = useCallback(() => {\n    teardown();\n    dispatch({ type: 'cancel' });\n  }, [teardown]);\n\n  // Release the microphone with the component.\n  useEffect(() => () => teardown(), [teardown]);\n\n  const isActive =\n    state.status === DICTATION_STATUSES.starting ||\n    state.status === DICTATION_STATUSES.listening ||\n    state.status === DICTATION_STATUSES.stopping;\n\n  return {\n    status: state.status,\n    isActive,\n    transcript: state.transcript,\n    text: spokenText(state.transcript),\n    error: state.error,\n    stream,\n    isSupported,\n    engine,\n    start,\n    stop,\n    cancel,\n  };\n}\n"],"names":[],"mappings":"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"}

package/dist/index.cjs

@@ -40,27 +40,6 @@ const toolUis = require("./tools/tool-uis.cjs");
 const primitives = require("./tools/primitives.cjs");
 const miscToolUis = require("./tools/misc-tool-uis.cjs");
 const toolIcons = require("./tools/tool-icons.cjs");
-require("./packages/agent-runtime/src/generated/runconfig-contract.cjs");
-require("react");
-require("@assistant-ui/tap");
-require("statewire");
-require("./packages/agent-runtime/src/statewire-suspended.cjs");
-const conversationList = require("./packages/agent-runtime/src/conversation-list.cjs");
-const toolMetadata = require("./packages/agent-runtime/src/tool-metadata.cjs");
-const toolResult = require("./packages/agent-runtime/src/tool-result.cjs");
-require("@tanstack/react-query");
-const interrupts = require("./packages/agent-runtime/src/interrupts.cjs");
-require("./packages/agent-runtime/src/messages.cjs");
-require("./packages/agent-runtime/src/statewire-state.cjs");
-const threadExtras = require("./packages/agent-runtime/src/thread-extras.cjs");
-require("@assistant-ui/store");
-require("./packages/agent-runtime/src/quota-safe-local-storage-session.cjs");
-require("./packages/agent-runtime/src/statewire-attach-observer.cjs");
-require("./packages/agent-runtime/src/thread-status.cjs");
-require("@assistant-ui/react-statewire");
-const githubWakeEvent = require("./packages/agent-runtime/src/github-wake-event.cjs");
-require("@assistant-ui/core");
-require("./packages/agent-runtime/src/thread-handoff.cjs");
 const writeTodosToolUi = require("./tools/write-todos-tool-ui.cjs");
 const todoPlanStore = require("./tools/todo-plan-store.cjs");
 const fileToolUis = require("./tools/file-tool-uis.cjs");
@@ -91,6 +70,8 @@ const useAthenaThreadManager = require("./threads/useAthenaThreadManager.cjs");
 const useDictation = require("./dictation/use-dictation.cjs");
 const DictationStrip = require("./dictation/DictationStrip.cjs");
 const dictationEngine = require("./dictation/dictation-engine.cjs");
+const recordedDictationEngine = require("./dictation/recorded-dictation-engine.cjs");
+const useAthenaDictationEngine = require("./dictation/use-athena-dictation-engine.cjs");
 const dictationState = require("./dictation/dictation-state.cjs");
 const useAppendToComposer = require("./composer/useAppendToComposer.cjs");
 const composerHandoff = require("./composer/composer-handoff.cjs");
@@ -108,7 +89,13 @@ const tooltip = require("./ui/tooltip.cjs");
 const collapsible = require("./ui/collapsible.cjs");
 const index = require("./toolkits/index.cjs");
 const index$1 = require("./theme/index.cjs");
+const interrupts = require("./packages/agent-runtime/src/interrupts.cjs");
+const toolResult = require("./packages/agent-runtime/src/tool-result.cjs");
 const cnfast = require("cnfast");
+const conversationList = require("./packages/agent-runtime/src/conversation-list.cjs");
+const toolMetadata = require("./packages/agent-runtime/src/tool-metadata.cjs");
+const githubWakeEvent = require("./packages/agent-runtime/src/github-wake-event.cjs");
+const threadExtras = require("./packages/agent-runtime/src/thread-extras.cjs");
 const toolAppearance = require("./tools/tool-appearance.cjs");
 exports.ATHENA_REACT_SDK_VERSION = version.ATHENA_REACT_SDK_VERSION;
 exports.athenaDiagnostics = athenaDiagnostics.athenaDiagnostics;
@@ -218,24 +205,6 @@ exports.truncate = primitives.truncate;
 exports.InstallPackageToolUI = miscToolUis.InstallPackageToolUI;
 exports.TOOL_ICONS = toolIcons.TOOL_ICONS;
 exports.toolIcon = toolIcons.toolIcon;
-exports.deriveConversationAttention = conversationList.deriveConversationAttention;
-exports.describeToolArgs = toolMetadata.describeToolArgs;
-exports.formatToolName = toolMetadata.formatToolName;
-exports.getToolDisplayMeta = toolMetadata.getToolDisplayMeta;
-exports.toolActiveLabel = toolMetadata.toolActiveLabel;
-exports.toolCompletedLabel = toolMetadata.toolCompletedLabel;
-exports.classifyToolResult = toolResult.classifyToolResult;
-exports.isToolResultSuccess = toolResult.isToolResultSuccess;
-exports.resultMessage = toolResult.resultMessage;
-exports.HITL_PENDING_RESUME_GRACE_MS = interrupts.HITL_PENDING_RESUME_GRACE_MS;
-exports.asHitlApproval = interrupts.asHitlApproval;
-exports.isPendingInterrupt = interrupts.isPendingInterrupt;
-exports.readInterruptMessage = interrupts.readInterruptMessage;
-exports.hasStatewireThreadExtras = threadExtras.hasStatewireThreadExtras;
-exports.githubWakeEventLabel = githubWakeEvent.githubWakeEventLabel;
-exports.githubWakeMarkerText = githubWakeEvent.githubWakeMarkerText;
-exports.isGithubWakeMessage = githubWakeEvent.isGithubWakeMessage;
-exports.readGithubWakeEvent = githubWakeEvent.readGithubWakeEvent;
 exports.HiddenWriteTodosToolUI = writeTodosToolUi.HiddenWriteTodosToolUI;
 exports.WriteTodosToolUI = writeTodosToolUi.WriteTodosToolUI;
 exports.parseTodoPlan = writeTodosToolUi.parseTodoPlan;
@@ -310,6 +279,8 @@ exports.DictationStrip = DictationStrip.DictationStrip;
 exports.DictationWaveform = DictationStrip.DictationWaveform;
 exports.DICTATION_ENGINE_ERROR_KINDS = dictationEngine.DICTATION_ENGINE_ERROR_KINDS;
 exports.createWebSpeechDictationEngine = dictationEngine.createWebSpeechDictationEngine;
+exports.createRecordedDictationEngine = recordedDictationEngine.createRecordedDictationEngine;
+exports.useAthenaDictationEngine = useAthenaDictationEngine.useAthenaDictationEngine;
 exports.DICTATION_STATUSES = dictationState.DICTATION_STATUSES;
 exports.composeDictationDraft = dictationState.composeDictationDraft;
 exports.useAppendToComposer = useAppendToComposer.useAppendToComposer;
@@ -342,9 +313,27 @@ exports.CollapsibleTrigger = collapsible.CollapsibleTrigger;
 exports.Toolkits = index.Toolkits;
 exports.themeToStyleVars = index$1.themeToStyleVars;
 exports.themes = index$1.themes;
+exports.HITL_PENDING_RESUME_GRACE_MS = interrupts.HITL_PENDING_RESUME_GRACE_MS;
+exports.asHitlApproval = interrupts.asHitlApproval;
+exports.isPendingInterrupt = interrupts.isPendingInterrupt;
+exports.readInterruptMessage = interrupts.readInterruptMessage;
+exports.classifyToolResult = toolResult.classifyToolResult;
+exports.isToolResultSuccess = toolResult.isToolResultSuccess;
+exports.resultMessage = toolResult.resultMessage;
 Object.defineProperty(exports, "cn", {
   enumerable: true,
   get: () => cnfast.cn
 });
+exports.deriveConversationAttention = conversationList.deriveConversationAttention;
+exports.describeToolArgs = toolMetadata.describeToolArgs;
+exports.formatToolName = toolMetadata.formatToolName;
+exports.getToolDisplayMeta = toolMetadata.getToolDisplayMeta;
+exports.toolActiveLabel = toolMetadata.toolActiveLabel;
+exports.toolCompletedLabel = toolMetadata.toolCompletedLabel;
+exports.githubWakeEventLabel = githubWakeEvent.githubWakeEventLabel;
+exports.githubWakeMarkerText = githubWakeEvent.githubWakeMarkerText;
+exports.isGithubWakeMessage = githubWakeEvent.isGithubWakeMessage;
+exports.readGithubWakeEvent = githubWakeEvent.readGithubWakeEvent;
+exports.hasStatewireThreadExtras = threadExtras.hasStatewireThreadExtras;
 exports.useToolAppearance = toolAppearance.useToolAppearance;
 //# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/index.d.ts

@@ -115,11 +115,14 @@ export { conversationSummaryFromIndexEntry, useStatewireConversationHistory, typ
 export { useAthenaThreadManager } from './threads/useAthenaThreadManager';
 export type { AthenaThreadManagerState } from './threads/useAthenaThreadManager';
 export { useDictation } from './dictation/use-dictation';
-export type { DictationController, UseDictationOptions } from './dictation/use-dictation';
+export type { DictationController, DictationStopResult, UseDictationOptions, } from './dictation/use-dictation';
 export { DictationStrip, DictationWaveform } from './dictation/DictationStrip';
 export type { DictationStripProps } from './dictation/DictationStrip';
 export { createWebSpeechDictationEngine, DICTATION_ENGINE_ERROR_KINDS, } from './dictation/dictation-engine';
 export type { DictationEngine, DictationEngineCallbacks, DictationEngineError, DictationEngineErrorKind, DictationEngineSession, DictationTranscriptUpdate, } from './dictation/dictation-engine';
+export { createRecordedDictationEngine } from './dictation/recorded-dictation-engine';
+export type { DictationTranscribeContext, DictationTranscriber, RecordedDictationEngineOptions, } from './dictation/recorded-dictation-engine';
+export { useAthenaDictationEngine } from './dictation/use-athena-dictation-engine';
 export { composeDictationDraft, DICTATION_STATUSES } from './dictation/dictation-state';
 export type { DictationStatus, DictationTranscript } from './dictation/dictation-state';
 export type { AthenaChatComposerSlots, AthenaChatDictationOptions } from './chat/AthenaChat';

package/dist/index.js

@@ -38,27 +38,6 @@ import { BrowseToolUI, CreateDocumentToolUI, CreateEmailDraftToolUI, CreateNoteb
 import { CopyToolSpecButton, ExpandableSection, ToolCard, normalizeResult, truncate } from "./tools/primitives.js";
 import { InstallPackageToolUI } from "./tools/misc-tool-uis.js";
 import { TOOL_ICONS, toolIcon } from "./tools/tool-icons.js";
-import "./packages/agent-runtime/src/generated/runconfig-contract.js";
-import "react";
-import "@assistant-ui/tap";
-import "statewire";
-import "./packages/agent-runtime/src/statewire-suspended.js";
-import { deriveConversationAttention } from "./packages/agent-runtime/src/conversation-list.js";
-import { describeToolArgs, formatToolName, getToolDisplayMeta, toolActiveLabel, toolCompletedLabel } from "./packages/agent-runtime/src/tool-metadata.js";
-import { classifyToolResult, isToolResultSuccess, resultMessage } from "./packages/agent-runtime/src/tool-result.js";
-import "@tanstack/react-query";
-import { HITL_PENDING_RESUME_GRACE_MS, asHitlApproval, isPendingInterrupt, readInterruptMessage } from "./packages/agent-runtime/src/interrupts.js";
-import "./packages/agent-runtime/src/messages.js";
-import "./packages/agent-runtime/src/statewire-state.js";
-import { hasStatewireThreadExtras } from "./packages/agent-runtime/src/thread-extras.js";
-import "@assistant-ui/store";
-import "./packages/agent-runtime/src/quota-safe-local-storage-session.js";
-import "./packages/agent-runtime/src/statewire-attach-observer.js";
-import "./packages/agent-runtime/src/thread-status.js";
-import "@assistant-ui/react-statewire";
-import { githubWakeEventLabel, githubWakeMarkerText, isGithubWakeMessage, readGithubWakeEvent } from "./packages/agent-runtime/src/github-wake-event.js";
-import "@assistant-ui/core";
-import "./packages/agent-runtime/src/thread-handoff.js";
 import { HiddenWriteTodosToolUI, WriteTodosToolUI, parseTodoPlan } from "./tools/write-todos-tool-ui.js";
 import { useLatestTodoPlan } from "./tools/todo-plan-store.js";
 import { EditFileToolUI, ListFilesToolUI, ReadFileToolUI, SearchFilesToolUI, WriteFileToolUI, friendlyWorkspacePath } from "./tools/file-tool-uis.js";
@@ -89,6 +68,8 @@ import { useAthenaThreadManager } from "./threads/useAthenaThreadManager.js";
 import { useDictation } from "./dictation/use-dictation.js";
 import { DictationStrip, DictationWaveform } from "./dictation/DictationStrip.js";
 import { DICTATION_ENGINE_ERROR_KINDS, createWebSpeechDictationEngine } from "./dictation/dictation-engine.js";
+import { createRecordedDictationEngine } from "./dictation/recorded-dictation-engine.js";
+import { useAthenaDictationEngine } from "./dictation/use-athena-dictation-engine.js";
 import { DICTATION_STATUSES, composeDictationDraft } from "./dictation/dictation-state.js";
 import { useAppendToComposer } from "./composer/useAppendToComposer.js";
 import { useComposerReady } from "./composer/composer-handoff.js";
@@ -106,7 +87,13 @@ import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from "./ui/t
 import { Collapsible, CollapsibleContent, CollapsibleTrigger } from "./ui/collapsible.js";
 import { Toolkits } from "./toolkits/index.js";
 import { themeToStyleVars, themes } from "./theme/index.js";
+import { HITL_PENDING_RESUME_GRACE_MS, asHitlApproval, isPendingInterrupt, readInterruptMessage } from "./packages/agent-runtime/src/interrupts.js";
+import { classifyToolResult, isToolResultSuccess, resultMessage } from "./packages/agent-runtime/src/tool-result.js";
 import { cn } from "cnfast";
+import { deriveConversationAttention } from "./packages/agent-runtime/src/conversation-list.js";
+import { describeToolArgs, formatToolName, getToolDisplayMeta, toolActiveLabel, toolCompletedLabel } from "./packages/agent-runtime/src/tool-metadata.js";
+import { githubWakeEventLabel, githubWakeMarkerText, isGithubWakeMessage, readGithubWakeEvent } from "./packages/agent-runtime/src/github-wake-event.js";
+import { hasStatewireThreadExtras } from "./packages/agent-runtime/src/thread-extras.js";
 import { useToolAppearance } from "./tools/tool-appearance.js";
 export {
   ATHENA_REACT_SDK_VERSION,
@@ -238,6 +225,7 @@ export {
   countActivityTools,
   createAssetToolUI,
   createAthenaSpacesUrl,
+  createRecordedDictationEngine,
   createThread,
   createToolBasedGroupingFunction,
   createWebSpeechDictationEngine,
@@ -315,6 +303,7 @@ export {
   useAthenaCitationLinkHandler,
   useAthenaConfig,
   useAthenaDiagnostics,
+  useAthenaDictationEngine,
   useAthenaLinkClickHandler,
   useAthenaRepoSearch,
   useAthenaRunLive,

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/packages/agent-runtime/src/edit-command.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"edit-command.cjs","sources":["../../../../../agent-runtime/src/edit-command.ts"],"sourcesContent":["import type { StatewireThread } from '@assistant-ui/react-statewire';\nimport { DEEP_AGENT_INTEREST_PROTOCOL } from './generated/runconfig-contract';\nimport {\n  type DeepAgentMessageWindow,\n  pageInterestRequests,\n  readDeepAgentMessageWindow,\n} from './message-window';\nimport { hasStatewireThreadExtras } from './thread-extras';\n\n/**\n * Wire-accurate `run/edit` construction for deep-agent retry/edit, shared by\n * every surface that resubmits a user message.\n *\n * assistant-ui builds the command's `runAnchorMessageId` from the CONVERTED\n * thread messages (`resolveEditCommand`: `messages[index - 1].id`), but the\n * deep-agent host validates that anchor against the edited message's parent in\n * its RAW message list (`harness_sdk.linear_thread`: the entry before it in\n * `state[\"messages\"]`). Those two lists do not line up:\n *\n * - the converter chunks an assistant turn and its tool messages into ONE\n *   thread message carrying only the FIRST wire id, so the anchor names the\n *   head of the previous turn instead of its last tool message;\n * - `sanitizeLangChainMessages` drops hidden-from-frontend and unconvertible\n *   entries, so a dropped tail message is invisible to the anchor too.\n *\n * Either way the host rejects the command with `wrong-anchor`\n * (`runAnchorMessageId … is not the source's parent`) AFTER the composer's\n * synchronous `send()` returned, so the retry/edit silently does nothing.\n *\n * Building the command here off the replicated raw state makes the anchor the\n * same value the host computes.\n *\n * The raw list is the loaded interest window, so the first loaded message's\n * parent is not in it while older messages exist — an edit there must not\n * anchor on `null` (the root, rejected `wrong-anchor`); a message below the\n * window has no parent on this client at all. {@link resolveDeepAgentEditCommand}\n * states older page interests until the parent is loaded.\n */\n\n/** The pieces of the statewire thread extras the edit path reads. */\nexport interface DeepAgentStatewireExtras {\n  /** The library's dispatch; it resolves with the host's reply to the command. */\n  sendCommand: (\n    command: StatewireThread.Command,\n    options?: StatewireThread.SendOptions,\n  ) => Promise<unknown> | void;\n  /** Optional on older hosts; capture before loading an edit's history anchor. */\n  prepareMessageMetadata?: StatewireThread.Extras['prepareMessageMetadata'];\n  discardPreparedMessageMetadata?: StatewireThread.Extras['discardPreparedMessageMetadata'];\n  sendPreparedEdit?: StatewireThread.Extras['sendPreparedEdit'];\n  isPreparingSubmission?: boolean;\n  /** The composed thread state — its `messages` are the raw wire messages of the loaded window. */\n  state: { messages?: readonly { id?: unknown }[] } | null;\n  /** The mounted documents (the interest window), absent on a wire without documents. */\n  documents?: StatewireThread.Extras['documents'];\n  invoke?: StatewireThread.Extras['invoke'];\n  /** The live run, when one is in flight; `epoch` advances on each dispatch. */\n  runs: { runId?: string | null; epoch?: number };\n  /** The host's replicated run status; absent on a surface that predates it. */\n  status?: StatewireThread.ThreadStatus;\n}\n\n/**\n * The statewire extras of the nearest aui thread, or `null` when the thread is\n * not a statewire thread (e.g. a read-only subagent transcript runtime).\n * Gated on {@link hasStatewireThreadExtras} for the same reason the approval\n * card is: the library's own hooks throw on a non-statewire thread.\n */\nexport function readDeepAgentStatewireExtras(extras: unknown): DeepAgentStatewireExtras | null {\n  if (!hasStatewireThreadExtras(extras)) return null;\n  return extras as DeepAgentStatewireExtras;\n}\n\n/**\n * The host's parent of `sourceId`: the raw wire message directly before it\n * (`null` when it is the first of the whole transcript). Returns `undefined`\n * when `sourceId` is not in the raw list at all — an optimistic bubble the\n * host has not settled yet, a message below the loaded window, or a surface\n * whose state this module cannot read — or when it is the first loaded\n * message while older ones exist (`hasOlder`), so the caller can load more or\n * fall back to the library's own path instead of asserting a wrong anchor.\n */\nexport function resolveWireAnchorMessageId({\n  wireMessages,\n  sourceId,\n  hasOlder = false,\n}: {\n  wireMessages: readonly { id?: unknown }[] | undefined;\n  sourceId: string;\n  hasOlder?: boolean;\n}): string | null | undefined {\n  if (!wireMessages) return undefined;\n  const index = wireMessages.findIndex((message) => message?.id === sourceId);\n  if (index < 0) return undefined;\n  if (index === 0) return hasOlder ? undefined : null;\n  const parentId = wireMessages[index - 1]?.id;\n  return typeof parentId === 'string' ? parentId : undefined;\n}\n\n/**\n * Whether `sourceId`'s parent lies below the loaded window: the message is\n * absent from the raw list, or its first entry, while older messages exist.\n * The caller loads older history before an edit can be anchored.\n */\nexport function isSourceBelowLoadedWindow({\n  wireMessages,\n  sourceId,\n  window,\n}: {\n  wireMessages: readonly { id?: unknown }[] | undefined;\n  sourceId: string;\n  window: DeepAgentMessageWindow | null;\n}): boolean {\n  if (!wireMessages || window === null || !window.hasOlder) return false;\n  const index = wireMessages.findIndex((message) => message?.id === sourceId);\n  return index <= 0;\n}\n\nconst readWindow = (extras: DeepAgentStatewireExtras) =>\n  readDeepAgentMessageWindow(extras.documents?.list());\n\n/**\n * A fresh command / message id (uniqueness, not secrecy). `crypto.randomUUID`\n * where the host runtime has it — every browser, Bun, Node and Hermes with\n * webcrypto — and a v4-shaped fallback elsewhere, so the shared path never\n * throws on a runtime without full webcrypto.\n */\nfunction mintCommandId(): string {\n  const webcrypto = (globalThis as { crypto?: { randomUUID?: () => string } }).crypto;\n  if (typeof webcrypto?.randomUUID === 'function') return webcrypto.randomUUID();\n  const hex = (): string => Math.floor(Math.random() * 0x10000).toString(16).padStart(4, '0');\n  return `${hex()}${hex()}-${hex()}-4${hex().slice(1)}-${hex()}-${hex()}${hex()}${hex()}`;\n}\n\n/**\n * The `run/edit` command for resubmitting `sourceId` with `text`, anchored on\n * the host's own parent. `null` when the anchor cannot be resolved from the\n * replicated state.\n */\nexport function buildDeepAgentEditCommand({\n  extras,\n  sourceId,\n  text,\n}: {\n  extras: DeepAgentStatewireExtras;\n  sourceId: string;\n  text: string;\n}): StatewireThread.RunEditCommand | null {\n  const runAnchorMessageId = resolveWireAnchorMessageId({\n    wireMessages: extras.state?.messages,\n    sourceId,\n    hasOlder: readWindow(extras)?.hasOlder ?? false,\n  });\n  if (runAnchorMessageId === undefined) return null;\n  return {\n    type: 'run/edit',\n    runId: extras.runs.runId ?? mintCommandId(),\n    message: { id: mintCommandId(), role: 'user', parts: [{ type: 'text', text }] },\n    sourceId,\n    runAnchorMessageId,\n  };\n}\n\n/**\n * Pages of older history stated while looking for an edited message's host\n * parent. Each page is up to a window's worth of messages, so an edit reaches\n * this many windows below what was loaded before it gives up.\n */\nexport const MAX_EDIT_ANCHOR_HISTORY_LOADS = 5;\n\n/**\n * The anchored `run/edit` for `sourceId`, stating older page interests one at\n * a time when the message's parent lies below the loaded window. Every page\n * is read back from the live documents (`readExtras` — the host mounts them\n * before it answers the statement), so the anchor is always the host's own\n * parent id.\n *\n * Resolves `null` — the caller's cue for the library's composer path, whose\n * failure it reports — when the thread is not a statewire thread, the host has\n * not settled the message, the history is exhausted without it, or the page\n * budget ({@link MAX_EDIT_ANCHOR_HISTORY_LOADS}) is spent. A synchronous\n * resolution never awaits: the first read either anchors at once or decides\n * that pages are needed.\n */\nexport async function resolveDeepAgentEditCommand({\n  readExtras,\n  sourceId,\n  text,\n  pageSize,\n  maxHistoryLoads = MAX_EDIT_ANCHOR_HISTORY_LOADS,\n}: {\n  /** The live thread extras — re-read per page so each anchor attempt sees the widened window. */\n  readExtras: () => DeepAgentStatewireExtras | null;\n  sourceId: string;\n  text: string;\n  pageSize?: number;\n  maxHistoryLoads?: number;\n}): Promise<StatewireThread.RunEditCommand | null> {\n  for (let page = 0; page <= maxHistoryLoads; page += 1) {\n    const extras = readExtras();\n    if (!extras) return null;\n    const command = buildDeepAgentEditCommand({ extras, sourceId, text });\n    if (command) return command;\n    if (page === maxHistoryLoads || !extras.invoke) return null;\n    const window = readWindow(extras);\n    if (!isSourceBelowLoadedWindow({ wireMessages: extras.state?.messages, sourceId, window })) {\n      return null;\n    }\n    const requests = window === null ? null : pageInterestRequests(window, pageSize);\n    if (requests === null) return null;\n    await extras.invoke(DEEP_AGENT_INTEREST_PROTOCOL, 'set', [requests]);\n  }\n  return null;\n}\n"],"names":["hasStatewireThreadExtras","readDeepAgentMessageWindow","pageInterestRequests","DEEP_AGENT_INTEREST_PROTOCOL"],"mappings":";;;;;AAoEO,SAAS,6BAA6B,QAAkD;AAC7F,MAAI,CAACA,aAAAA,yBAAyB,MAAM,EAAG,QAAO;AAC9C,SAAO;AACT;AAWO,SAAS,2BAA2B;AAAA,EACzC;AAAA,EACA;AAAA,EACA,WAAW;AACb,GAI8B;;AAC5B,MAAI,CAAC,aAAc,QAAO;AAC1B,QAAM,QAAQ,aAAa,UAAU,CAAC,aAAY,mCAAS,QAAO,QAAQ;AAC1E,MAAI,QAAQ,EAAG,QAAO;AACtB,MAAI,UAAU,EAAG,QAAO,WAAW,SAAY;AAC/C,QAAM,YAAW,kBAAa,QAAQ,CAAC,MAAtB,mBAAyB;AAC1C,SAAO,OAAO,aAAa,WAAW,WAAW;AACnD;AAOO,SAAS,0BAA0B;AAAA,EACxC;AAAA,EACA;AAAA,EACA;AACF,GAIY;AACV,MAAI,CAAC,gBAAgB,WAAW,QAAQ,CAAC,OAAO,SAAU,QAAO;AACjE,QAAM,QAAQ,aAAa,UAAU,CAAC,aAAY,mCAAS,QAAO,QAAQ;AAC1E,SAAO,SAAS;AAClB;AAEA,MAAM,aAAa,CAAC,WAAA;;AAClBC,uBAAAA,4BAA2B,YAAO,cAAP,mBAAkB,MAAM;AAAA;AAQrD,SAAS,gBAAwB;AAC/B,QAAM,YAAa,WAA0D;AAC7E,MAAI,QAAO,uCAAW,gBAAe,WAAY,QAAO,UAAU,WAAA;AAClE,QAAM,MAAM,MAAc,KAAK,MAAM,KAAK,OAAA,IAAW,KAAO,EAAE,SAAS,EAAE,EAAE,SAAS,GAAG,GAAG;AAC1F,SAAO,GAAG,IAAA,CAAK,GAAG,IAAA,CAAK,IAAI,IAAA,CAAK,KAAK,MAAM,MAAM,CAAC,CAAC,IAAI,IAAA,CAAK,IAAI,KAAK,GAAG,IAAA,CAAK,GAAG,IAAA,CAAK;AACvF;AAOO,SAAS,0BAA0B;AAAA,EACxC;AAAA,EACA;AAAA,EACA;AACF,GAI0C;;AACxC,QAAM,qBAAqB,2BAA2B;AAAA,IACpD,eAAc,YAAO,UAAP,mBAAc;AAAA,IAC5B;AAAA,IACA,YAAU,gBAAW,MAAM,MAAjB,mBAAoB,aAAY;AAAA,EAAA,CAC3C;AACD,MAAI,uBAAuB,OAAW,QAAO;AAC7C,SAAO;AAAA,IACL,MAAM;AAAA,IACN,OAAO,OAAO,KAAK,SAAS,cAAA;AAAA,IAC5B,SAAS,EAAE,IAAI,cAAA,GAAiB,MAAM,QAAQ,OAAO,CAAC,EAAE,MAAM,QAAQ,KAAA,CAAM,EAAA;AAAA,IAC5E;AAAA,IACA;AAAA,EAAA;AAEJ;AAOO,MAAM,gCAAgC;AAgB7C,eAAsB,4BAA4B;AAAA,EAChD;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA,kBAAkB;AACpB,GAOmD;;AACjD,WAAS,OAAO,GAAG,QAAQ,iBAAiB,QAAQ,GAAG;AACrD,UAAM,SAAS,WAAA;AACf,QAAI,CAAC,OAAQ,QAAO;AACpB,UAAM,UAAU,0BAA0B,EAAE,QAAQ,UAAU,MAAM;AACpE,QAAI,QAAS,QAAO;AACpB,QAAI,SAAS,mBAAmB,CAAC,OAAO,OAAQ,QAAO;AACvD,UAAM,SAAS,WAAW,MAAM;AAChC,QAAI,CAAC,0BAA0B,EAAE,eAAc,YAAO,UAAP,mBAAc,UAAU,UAAU,OAAA,CAAQ,GAAG;AAC1F,aAAO;AAAA,IACT;AACA,UAAM,WAAW,WAAW,OAAO,OAAOC,cAAAA,qBAAqB,QAAQ,QAAQ;AAC/E,QAAI,aAAa,KAAM,QAAO;AAC9B,UAAM,OAAO,OAAOC,kBAAAA,8BAA8B,OAAO,CAAC,QAAQ,CAAC;AAAA,EACrE;AACA,SAAO;AACT;;;;;;;"}
+{"version":3,"file":"edit-command.cjs","sources":["../../../../../agent-runtime/src/edit-command.ts"],"sourcesContent":["import type { StatewireThread } from '@assistant-ui/react-statewire';\nimport { DEEP_AGENT_INTEREST_PROTOCOL } from './generated/runconfig-contract';\nimport {\n  type DeepAgentMessageWindow,\n  pageInterestRequests,\n  readDeepAgentMessageWindow,\n} from './message-window';\nimport { hasStatewireThreadExtras } from './thread-extras';\n\n/**\n * Wire-accurate `run/edit` construction for deep-agent retry/edit, shared by\n * every surface that resubmits a user message.\n *\n * assistant-ui builds the command's `runAnchorMessageId` from the CONVERTED\n * thread messages (`resolveEditCommand`: `messages[index - 1].id`), but the\n * deep-agent host validates that anchor against the edited message's parent in\n * its RAW message list (`harness_sdk.linear_thread`: the entry before it in\n * `state[\"messages\"]`). Those two lists do not line up:\n *\n * - the converter chunks an assistant turn and its tool messages into ONE\n *   thread message carrying only the FIRST wire id, so the anchor names the\n *   head of the previous turn instead of its last tool message;\n * - `sanitizeLangChainMessages` drops hidden-from-frontend and unconvertible\n *   entries, so a dropped tail message is invisible to the anchor too.\n *\n * Either way the host rejects the command with `wrong-anchor`\n * (`runAnchorMessageId … is not the source's parent`) AFTER the composer's\n * synchronous `send()` returned, so the retry/edit silently does nothing.\n *\n * Building the command here off the replicated raw state makes the anchor the\n * same value the host computes.\n *\n * The raw list is the loaded interest window, so the first loaded message's\n * parent is not in it while older messages exist — an edit there must not\n * anchor on `null` (the root, rejected `wrong-anchor`); a message below the\n * window has no parent on this client at all. {@link resolveDeepAgentEditCommand}\n * states older page interests until the parent is loaded.\n */\n\n/**\n * Host metadata frozen at submission, settling once the async capture does.\n * The message-metadata preparation surface — `prepareMessageMetadata`,\n * `discardPreparedMessageMetadata`, `sendPreparedEdit` and `sendCommand`'s\n * `preparedMetadata` option — is what the monorepo patches into\n * `@assistant-ui/react-statewire@0.29.1` (`patches/`). It is declared\n * structurally here rather than as `StatewireThread.Extras[...]` so that the\n * published sources also compile against the unpatched upstream typings, where\n * those members are absent and the edit path's optional calls never run.\n */\nexport type DeepAgentPreparedMessageMetadata = Promise<Record<string, unknown> | undefined>;\n\n/** The pieces of the statewire thread extras the edit path reads. */\nexport interface DeepAgentStatewireExtras {\n  /** The library's dispatch; it resolves with the host's reply to the command. */\n  sendCommand: (\n    command: StatewireThread.Command,\n    options?: { preparedMetadata?: DeepAgentPreparedMessageMetadata | undefined },\n  ) => Promise<unknown> | void;\n  /** Optional on older hosts; capture before loading an edit's history anchor. */\n  prepareMessageMetadata?: (() => DeepAgentPreparedMessageMetadata) | undefined;\n  discardPreparedMessageMetadata?:\n    | ((prepared: DeepAgentPreparedMessageMetadata) => void)\n    | undefined;\n  sendPreparedEdit?:\n    | ((sourceId: string, prepared: DeepAgentPreparedMessageMetadata) => void)\n    | undefined;\n  isPreparingSubmission?: boolean;\n  /** The composed thread state — its `messages` are the raw wire messages of the loaded window. */\n  state: { messages?: readonly { id?: unknown }[] } | null;\n  /** The mounted documents (the interest window), absent on a wire without documents. */\n  documents?: StatewireThread.Extras['documents'];\n  invoke?: StatewireThread.Extras['invoke'];\n  /** The live run, when one is in flight; `epoch` advances on each dispatch. */\n  runs: { runId?: string | null; epoch?: number };\n  /** The host's replicated run status; absent on a surface that predates it. */\n  status?: StatewireThread.ThreadStatus;\n}\n\n/**\n * The statewire extras of the nearest aui thread, or `null` when the thread is\n * not a statewire thread (e.g. a read-only subagent transcript runtime).\n * Gated on {@link hasStatewireThreadExtras} for the same reason the approval\n * card is: the library's own hooks throw on a non-statewire thread.\n */\nexport function readDeepAgentStatewireExtras(extras: unknown): DeepAgentStatewireExtras | null {\n  if (!hasStatewireThreadExtras(extras)) return null;\n  return extras as DeepAgentStatewireExtras;\n}\n\n/**\n * The host's parent of `sourceId`: the raw wire message directly before it\n * (`null` when it is the first of the whole transcript). Returns `undefined`\n * when `sourceId` is not in the raw list at all — an optimistic bubble the\n * host has not settled yet, a message below the loaded window, or a surface\n * whose state this module cannot read — or when it is the first loaded\n * message while older ones exist (`hasOlder`), so the caller can load more or\n * fall back to the library's own path instead of asserting a wrong anchor.\n */\nexport function resolveWireAnchorMessageId({\n  wireMessages,\n  sourceId,\n  hasOlder = false,\n}: {\n  wireMessages: readonly { id?: unknown }[] | undefined;\n  sourceId: string;\n  hasOlder?: boolean;\n}): string | null | undefined {\n  if (!wireMessages) return undefined;\n  const index = wireMessages.findIndex((message) => message?.id === sourceId);\n  if (index < 0) return undefined;\n  if (index === 0) return hasOlder ? undefined : null;\n  const parentId = wireMessages[index - 1]?.id;\n  return typeof parentId === 'string' ? parentId : undefined;\n}\n\n/**\n * Whether `sourceId`'s parent lies below the loaded window: the message is\n * absent from the raw list, or its first entry, while older messages exist.\n * The caller loads older history before an edit can be anchored.\n */\nexport function isSourceBelowLoadedWindow({\n  wireMessages,\n  sourceId,\n  window,\n}: {\n  wireMessages: readonly { id?: unknown }[] | undefined;\n  sourceId: string;\n  window: DeepAgentMessageWindow | null;\n}): boolean {\n  if (!wireMessages || window === null || !window.hasOlder) return false;\n  const index = wireMessages.findIndex((message) => message?.id === sourceId);\n  return index <= 0;\n}\n\nconst readWindow = (extras: DeepAgentStatewireExtras) =>\n  readDeepAgentMessageWindow(extras.documents?.list());\n\n/**\n * A fresh command / message id (uniqueness, not secrecy). `crypto.randomUUID`\n * where the host runtime has it — every browser, Bun, Node and Hermes with\n * webcrypto — and a v4-shaped fallback elsewhere, so the shared path never\n * throws on a runtime without full webcrypto.\n */\nfunction mintCommandId(): string {\n  const webcrypto = (globalThis as { crypto?: { randomUUID?: () => string } }).crypto;\n  if (typeof webcrypto?.randomUUID === 'function') return webcrypto.randomUUID();\n  const hex = (): string => Math.floor(Math.random() * 0x10000).toString(16).padStart(4, '0');\n  return `${hex()}${hex()}-${hex()}-4${hex().slice(1)}-${hex()}-${hex()}${hex()}${hex()}`;\n}\n\n/**\n * The `run/edit` command for resubmitting `sourceId` with `text`, anchored on\n * the host's own parent. `null` when the anchor cannot be resolved from the\n * replicated state.\n */\nexport function buildDeepAgentEditCommand({\n  extras,\n  sourceId,\n  text,\n}: {\n  extras: DeepAgentStatewireExtras;\n  sourceId: string;\n  text: string;\n}): StatewireThread.RunEditCommand | null {\n  const runAnchorMessageId = resolveWireAnchorMessageId({\n    wireMessages: extras.state?.messages,\n    sourceId,\n    hasOlder: readWindow(extras)?.hasOlder ?? false,\n  });\n  if (runAnchorMessageId === undefined) return null;\n  return {\n    type: 'run/edit',\n    runId: extras.runs.runId ?? mintCommandId(),\n    message: { id: mintCommandId(), role: 'user', parts: [{ type: 'text', text }] },\n    sourceId,\n    runAnchorMessageId,\n  };\n}\n\n/**\n * Pages of older history stated while looking for an edited message's host\n * parent. Each page is up to a window's worth of messages, so an edit reaches\n * this many windows below what was loaded before it gives up.\n */\nexport const MAX_EDIT_ANCHOR_HISTORY_LOADS = 5;\n\n/**\n * The anchored `run/edit` for `sourceId`, stating older page interests one at\n * a time when the message's parent lies below the loaded window. Every page\n * is read back from the live documents (`readExtras` — the host mounts them\n * before it answers the statement), so the anchor is always the host's own\n * parent id.\n *\n * Resolves `null` — the caller's cue for the library's composer path, whose\n * failure it reports — when the thread is not a statewire thread, the host has\n * not settled the message, the history is exhausted without it, or the page\n * budget ({@link MAX_EDIT_ANCHOR_HISTORY_LOADS}) is spent. A synchronous\n * resolution never awaits: the first read either anchors at once or decides\n * that pages are needed.\n */\nexport async function resolveDeepAgentEditCommand({\n  readExtras,\n  sourceId,\n  text,\n  pageSize,\n  maxHistoryLoads = MAX_EDIT_ANCHOR_HISTORY_LOADS,\n}: {\n  /** The live thread extras — re-read per page so each anchor attempt sees the widened window. */\n  readExtras: () => DeepAgentStatewireExtras | null;\n  sourceId: string;\n  text: string;\n  pageSize?: number;\n  maxHistoryLoads?: number;\n}): Promise<StatewireThread.RunEditCommand | null> {\n  for (let page = 0; page <= maxHistoryLoads; page += 1) {\n    const extras = readExtras();\n    if (!extras) return null;\n    const command = buildDeepAgentEditCommand({ extras, sourceId, text });\n    if (command) return command;\n    if (page === maxHistoryLoads || !extras.invoke) return null;\n    const window = readWindow(extras);\n    if (!isSourceBelowLoadedWindow({ wireMessages: extras.state?.messages, sourceId, window })) {\n      return null;\n    }\n    const requests = window === null ? null : pageInterestRequests(window, pageSize);\n    if (requests === null) return null;\n    await extras.invoke(DEEP_AGENT_INTEREST_PROTOCOL, 'set', [requests]);\n  }\n  return null;\n}\n"],"names":["hasStatewireThreadExtras","readDeepAgentMessageWindow","pageInterestRequests","DEEP_AGENT_INTEREST_PROTOCOL"],"mappings":";;;;;AAoFO,SAAS,6BAA6B,QAAkD;AAC7F,MAAI,CAACA,aAAAA,yBAAyB,MAAM,EAAG,QAAO;AAC9C,SAAO;AACT;AAWO,SAAS,2BAA2B;AAAA,EACzC;AAAA,EACA;AAAA,EACA,WAAW;AACb,GAI8B;;AAC5B,MAAI,CAAC,aAAc,QAAO;AAC1B,QAAM,QAAQ,aAAa,UAAU,CAAC,aAAY,mCAAS,QAAO,QAAQ;AAC1E,MAAI,QAAQ,EAAG,QAAO;AACtB,MAAI,UAAU,EAAG,QAAO,WAAW,SAAY;AAC/C,QAAM,YAAW,kBAAa,QAAQ,CAAC,MAAtB,mBAAyB;AAC1C,SAAO,OAAO,aAAa,WAAW,WAAW;AACnD;AAOO,SAAS,0BAA0B;AAAA,EACxC;AAAA,EACA;AAAA,EACA;AACF,GAIY;AACV,MAAI,CAAC,gBAAgB,WAAW,QAAQ,CAAC,OAAO,SAAU,QAAO;AACjE,QAAM,QAAQ,aAAa,UAAU,CAAC,aAAY,mCAAS,QAAO,QAAQ;AAC1E,SAAO,SAAS;AAClB;AAEA,MAAM,aAAa,CAAC,WAAA;;AAClBC,uBAAAA,4BAA2B,YAAO,cAAP,mBAAkB,MAAM;AAAA;AAQrD,SAAS,gBAAwB;AAC/B,QAAM,YAAa,WAA0D;AAC7E,MAAI,QAAO,uCAAW,gBAAe,WAAY,QAAO,UAAU,WAAA;AAClE,QAAM,MAAM,MAAc,KAAK,MAAM,KAAK,OAAA,IAAW,KAAO,EAAE,SAAS,EAAE,EAAE,SAAS,GAAG,GAAG;AAC1F,SAAO,GAAG,IAAA,CAAK,GAAG,IAAA,CAAK,IAAI,IAAA,CAAK,KAAK,MAAM,MAAM,CAAC,CAAC,IAAI,IAAA,CAAK,IAAI,KAAK,GAAG,IAAA,CAAK,GAAG,IAAA,CAAK;AACvF;AAOO,SAAS,0BAA0B;AAAA,EACxC;AAAA,EACA;AAAA,EACA;AACF,GAI0C;;AACxC,QAAM,qBAAqB,2BAA2B;AAAA,IACpD,eAAc,YAAO,UAAP,mBAAc;AAAA,IAC5B;AAAA,IACA,YAAU,gBAAW,MAAM,MAAjB,mBAAoB,aAAY;AAAA,EAAA,CAC3C;AACD,MAAI,uBAAuB,OAAW,QAAO;AAC7C,SAAO;AAAA,IACL,MAAM;AAAA,IACN,OAAO,OAAO,KAAK,SAAS,cAAA;AAAA,IAC5B,SAAS,EAAE,IAAI,cAAA,GAAiB,MAAM,QAAQ,OAAO,CAAC,EAAE,MAAM,QAAQ,KAAA,CAAM,EAAA;AAAA,IAC5E;AAAA,IACA;AAAA,EAAA;AAEJ;AAOO,MAAM,gCAAgC;AAgB7C,eAAsB,4BAA4B;AAAA,EAChD;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA,kBAAkB;AACpB,GAOmD;;AACjD,WAAS,OAAO,GAAG,QAAQ,iBAAiB,QAAQ,GAAG;AACrD,UAAM,SAAS,WAAA;AACf,QAAI,CAAC,OAAQ,QAAO;AACpB,UAAM,UAAU,0BAA0B,EAAE,QAAQ,UAAU,MAAM;AACpE,QAAI,QAAS,QAAO;AACpB,QAAI,SAAS,mBAAmB,CAAC,OAAO,OAAQ,QAAO;AACvD,UAAM,SAAS,WAAW,MAAM;AAChC,QAAI,CAAC,0BAA0B,EAAE,eAAc,YAAO,UAAP,mBAAc,UAAU,UAAU,OAAA,CAAQ,GAAG;AAC1F,aAAO;AAAA,IACT;AACA,UAAM,WAAW,WAAW,OAAO,OAAOC,cAAAA,qBAAqB,QAAQ,QAAQ;AAC/E,QAAI,aAAa,KAAM,QAAO;AAC9B,UAAM,OAAO,OAAOC,kBAAAA,8BAA8B,OAAO,CAAC,QAAQ,CAAC;AAAA,EACrE;AACA,SAAO;AACT;;;;;;;"}

package/dist/packages/agent-runtime/src/edit-command.js.map

@@ -1 +1 @@
-{"version":3,"file":"edit-command.js","sources":["../../../../../agent-runtime/src/edit-command.ts"],"sourcesContent":["import type { StatewireThread } from '@assistant-ui/react-statewire';\nimport { DEEP_AGENT_INTEREST_PROTOCOL } from './generated/runconfig-contract';\nimport {\n  type DeepAgentMessageWindow,\n  pageInterestRequests,\n  readDeepAgentMessageWindow,\n} from './message-window';\nimport { hasStatewireThreadExtras } from './thread-extras';\n\n/**\n * Wire-accurate `run/edit` construction for deep-agent retry/edit, shared by\n * every surface that resubmits a user message.\n *\n * assistant-ui builds the command's `runAnchorMessageId` from the CONVERTED\n * thread messages (`resolveEditCommand`: `messages[index - 1].id`), but the\n * deep-agent host validates that anchor against the edited message's parent in\n * its RAW message list (`harness_sdk.linear_thread`: the entry before it in\n * `state[\"messages\"]`). Those two lists do not line up:\n *\n * - the converter chunks an assistant turn and its tool messages into ONE\n *   thread message carrying only the FIRST wire id, so the anchor names the\n *   head of the previous turn instead of its last tool message;\n * - `sanitizeLangChainMessages` drops hidden-from-frontend and unconvertible\n *   entries, so a dropped tail message is invisible to the anchor too.\n *\n * Either way the host rejects the command with `wrong-anchor`\n * (`runAnchorMessageId … is not the source's parent`) AFTER the composer's\n * synchronous `send()` returned, so the retry/edit silently does nothing.\n *\n * Building the command here off the replicated raw state makes the anchor the\n * same value the host computes.\n *\n * The raw list is the loaded interest window, so the first loaded message's\n * parent is not in it while older messages exist — an edit there must not\n * anchor on `null` (the root, rejected `wrong-anchor`); a message below the\n * window has no parent on this client at all. {@link resolveDeepAgentEditCommand}\n * states older page interests until the parent is loaded.\n */\n\n/** The pieces of the statewire thread extras the edit path reads. */\nexport interface DeepAgentStatewireExtras {\n  /** The library's dispatch; it resolves with the host's reply to the command. */\n  sendCommand: (\n    command: StatewireThread.Command,\n    options?: StatewireThread.SendOptions,\n  ) => Promise<unknown> | void;\n  /** Optional on older hosts; capture before loading an edit's history anchor. */\n  prepareMessageMetadata?: StatewireThread.Extras['prepareMessageMetadata'];\n  discardPreparedMessageMetadata?: StatewireThread.Extras['discardPreparedMessageMetadata'];\n  sendPreparedEdit?: StatewireThread.Extras['sendPreparedEdit'];\n  isPreparingSubmission?: boolean;\n  /** The composed thread state — its `messages` are the raw wire messages of the loaded window. */\n  state: { messages?: readonly { id?: unknown }[] } | null;\n  /** The mounted documents (the interest window), absent on a wire without documents. */\n  documents?: StatewireThread.Extras['documents'];\n  invoke?: StatewireThread.Extras['invoke'];\n  /** The live run, when one is in flight; `epoch` advances on each dispatch. */\n  runs: { runId?: string | null; epoch?: number };\n  /** The host's replicated run status; absent on a surface that predates it. */\n  status?: StatewireThread.ThreadStatus;\n}\n\n/**\n * The statewire extras of the nearest aui thread, or `null` when the thread is\n * not a statewire thread (e.g. a read-only subagent transcript runtime).\n * Gated on {@link hasStatewireThreadExtras} for the same reason the approval\n * card is: the library's own hooks throw on a non-statewire thread.\n */\nexport function readDeepAgentStatewireExtras(extras: unknown): DeepAgentStatewireExtras | null {\n  if (!hasStatewireThreadExtras(extras)) return null;\n  return extras as DeepAgentStatewireExtras;\n}\n\n/**\n * The host's parent of `sourceId`: the raw wire message directly before it\n * (`null` when it is the first of the whole transcript). Returns `undefined`\n * when `sourceId` is not in the raw list at all — an optimistic bubble the\n * host has not settled yet, a message below the loaded window, or a surface\n * whose state this module cannot read — or when it is the first loaded\n * message while older ones exist (`hasOlder`), so the caller can load more or\n * fall back to the library's own path instead of asserting a wrong anchor.\n */\nexport function resolveWireAnchorMessageId({\n  wireMessages,\n  sourceId,\n  hasOlder = false,\n}: {\n  wireMessages: readonly { id?: unknown }[] | undefined;\n  sourceId: string;\n  hasOlder?: boolean;\n}): string | null | undefined {\n  if (!wireMessages) return undefined;\n  const index = wireMessages.findIndex((message) => message?.id === sourceId);\n  if (index < 0) return undefined;\n  if (index === 0) return hasOlder ? undefined : null;\n  const parentId = wireMessages[index - 1]?.id;\n  return typeof parentId === 'string' ? parentId : undefined;\n}\n\n/**\n * Whether `sourceId`'s parent lies below the loaded window: the message is\n * absent from the raw list, or its first entry, while older messages exist.\n * The caller loads older history before an edit can be anchored.\n */\nexport function isSourceBelowLoadedWindow({\n  wireMessages,\n  sourceId,\n  window,\n}: {\n  wireMessages: readonly { id?: unknown }[] | undefined;\n  sourceId: string;\n  window: DeepAgentMessageWindow | null;\n}): boolean {\n  if (!wireMessages || window === null || !window.hasOlder) return false;\n  const index = wireMessages.findIndex((message) => message?.id === sourceId);\n  return index <= 0;\n}\n\nconst readWindow = (extras: DeepAgentStatewireExtras) =>\n  readDeepAgentMessageWindow(extras.documents?.list());\n\n/**\n * A fresh command / message id (uniqueness, not secrecy). `crypto.randomUUID`\n * where the host runtime has it — every browser, Bun, Node and Hermes with\n * webcrypto — and a v4-shaped fallback elsewhere, so the shared path never\n * throws on a runtime without full webcrypto.\n */\nfunction mintCommandId(): string {\n  const webcrypto = (globalThis as { crypto?: { randomUUID?: () => string } }).crypto;\n  if (typeof webcrypto?.randomUUID === 'function') return webcrypto.randomUUID();\n  const hex = (): string => Math.floor(Math.random() * 0x10000).toString(16).padStart(4, '0');\n  return `${hex()}${hex()}-${hex()}-4${hex().slice(1)}-${hex()}-${hex()}${hex()}${hex()}`;\n}\n\n/**\n * The `run/edit` command for resubmitting `sourceId` with `text`, anchored on\n * the host's own parent. `null` when the anchor cannot be resolved from the\n * replicated state.\n */\nexport function buildDeepAgentEditCommand({\n  extras,\n  sourceId,\n  text,\n}: {\n  extras: DeepAgentStatewireExtras;\n  sourceId: string;\n  text: string;\n}): StatewireThread.RunEditCommand | null {\n  const runAnchorMessageId = resolveWireAnchorMessageId({\n    wireMessages: extras.state?.messages,\n    sourceId,\n    hasOlder: readWindow(extras)?.hasOlder ?? false,\n  });\n  if (runAnchorMessageId === undefined) return null;\n  return {\n    type: 'run/edit',\n    runId: extras.runs.runId ?? mintCommandId(),\n    message: { id: mintCommandId(), role: 'user', parts: [{ type: 'text', text }] },\n    sourceId,\n    runAnchorMessageId,\n  };\n}\n\n/**\n * Pages of older history stated while looking for an edited message's host\n * parent. Each page is up to a window's worth of messages, so an edit reaches\n * this many windows below what was loaded before it gives up.\n */\nexport const MAX_EDIT_ANCHOR_HISTORY_LOADS = 5;\n\n/**\n * The anchored `run/edit` for `sourceId`, stating older page interests one at\n * a time when the message's parent lies below the loaded window. Every page\n * is read back from the live documents (`readExtras` — the host mounts them\n * before it answers the statement), so the anchor is always the host's own\n * parent id.\n *\n * Resolves `null` — the caller's cue for the library's composer path, whose\n * failure it reports — when the thread is not a statewire thread, the host has\n * not settled the message, the history is exhausted without it, or the page\n * budget ({@link MAX_EDIT_ANCHOR_HISTORY_LOADS}) is spent. A synchronous\n * resolution never awaits: the first read either anchors at once or decides\n * that pages are needed.\n */\nexport async function resolveDeepAgentEditCommand({\n  readExtras,\n  sourceId,\n  text,\n  pageSize,\n  maxHistoryLoads = MAX_EDIT_ANCHOR_HISTORY_LOADS,\n}: {\n  /** The live thread extras — re-read per page so each anchor attempt sees the widened window. */\n  readExtras: () => DeepAgentStatewireExtras | null;\n  sourceId: string;\n  text: string;\n  pageSize?: number;\n  maxHistoryLoads?: number;\n}): Promise<StatewireThread.RunEditCommand | null> {\n  for (let page = 0; page <= maxHistoryLoads; page += 1) {\n    const extras = readExtras();\n    if (!extras) return null;\n    const command = buildDeepAgentEditCommand({ extras, sourceId, text });\n    if (command) return command;\n    if (page === maxHistoryLoads || !extras.invoke) return null;\n    const window = readWindow(extras);\n    if (!isSourceBelowLoadedWindow({ wireMessages: extras.state?.messages, sourceId, window })) {\n      return null;\n    }\n    const requests = window === null ? null : pageInterestRequests(window, pageSize);\n    if (requests === null) return null;\n    await extras.invoke(DEEP_AGENT_INTEREST_PROTOCOL, 'set', [requests]);\n  }\n  return null;\n}\n"],"names":[],"mappings":";;;AAoEO,SAAS,6BAA6B,QAAkD;AAC7F,MAAI,CAAC,yBAAyB,MAAM,EAAG,QAAO;AAC9C,SAAO;AACT;AAWO,SAAS,2BAA2B;AAAA,EACzC;AAAA,EACA;AAAA,EACA,WAAW;AACb,GAI8B;;AAC5B,MAAI,CAAC,aAAc,QAAO;AAC1B,QAAM,QAAQ,aAAa,UAAU,CAAC,aAAY,mCAAS,QAAO,QAAQ;AAC1E,MAAI,QAAQ,EAAG,QAAO;AACtB,MAAI,UAAU,EAAG,QAAO,WAAW,SAAY;AAC/C,QAAM,YAAW,kBAAa,QAAQ,CAAC,MAAtB,mBAAyB;AAC1C,SAAO,OAAO,aAAa,WAAW,WAAW;AACnD;AAOO,SAAS,0BAA0B;AAAA,EACxC;AAAA,EACA;AAAA,EACA;AACF,GAIY;AACV,MAAI,CAAC,gBAAgB,WAAW,QAAQ,CAAC,OAAO,SAAU,QAAO;AACjE,QAAM,QAAQ,aAAa,UAAU,CAAC,aAAY,mCAAS,QAAO,QAAQ;AAC1E,SAAO,SAAS;AAClB;AAEA,MAAM,aAAa,CAAC,WAAA;;AAClB,qCAA2B,YAAO,cAAP,mBAAkB,MAAM;AAAA;AAQrD,SAAS,gBAAwB;AAC/B,QAAM,YAAa,WAA0D;AAC7E,MAAI,QAAO,uCAAW,gBAAe,WAAY,QAAO,UAAU,WAAA;AAClE,QAAM,MAAM,MAAc,KAAK,MAAM,KAAK,OAAA,IAAW,KAAO,EAAE,SAAS,EAAE,EAAE,SAAS,GAAG,GAAG;AAC1F,SAAO,GAAG,IAAA,CAAK,GAAG,IAAA,CAAK,IAAI,IAAA,CAAK,KAAK,MAAM,MAAM,CAAC,CAAC,IAAI,IAAA,CAAK,IAAI,KAAK,GAAG,IAAA,CAAK,GAAG,IAAA,CAAK;AACvF;AAOO,SAAS,0BAA0B;AAAA,EACxC;AAAA,EACA;AAAA,EACA;AACF,GAI0C;;AACxC,QAAM,qBAAqB,2BAA2B;AAAA,IACpD,eAAc,YAAO,UAAP,mBAAc;AAAA,IAC5B;AAAA,IACA,YAAU,gBAAW,MAAM,MAAjB,mBAAoB,aAAY;AAAA,EAAA,CAC3C;AACD,MAAI,uBAAuB,OAAW,QAAO;AAC7C,SAAO;AAAA,IACL,MAAM;AAAA,IACN,OAAO,OAAO,KAAK,SAAS,cAAA;AAAA,IAC5B,SAAS,EAAE,IAAI,cAAA,GAAiB,MAAM,QAAQ,OAAO,CAAC,EAAE,MAAM,QAAQ,KAAA,CAAM,EAAA;AAAA,IAC5E;AAAA,IACA;AAAA,EAAA;AAEJ;AAOO,MAAM,gCAAgC;AAgB7C,eAAsB,4BAA4B;AAAA,EAChD;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA,kBAAkB;AACpB,GAOmD;;AACjD,WAAS,OAAO,GAAG,QAAQ,iBAAiB,QAAQ,GAAG;AACrD,UAAM,SAAS,WAAA;AACf,QAAI,CAAC,OAAQ,QAAO;AACpB,UAAM,UAAU,0BAA0B,EAAE,QAAQ,UAAU,MAAM;AACpE,QAAI,QAAS,QAAO;AACpB,QAAI,SAAS,mBAAmB,CAAC,OAAO,OAAQ,QAAO;AACvD,UAAM,SAAS,WAAW,MAAM;AAChC,QAAI,CAAC,0BAA0B,EAAE,eAAc,YAAO,UAAP,mBAAc,UAAU,UAAU,OAAA,CAAQ,GAAG;AAC1F,aAAO;AAAA,IACT;AACA,UAAM,WAAW,WAAW,OAAO,OAAO,qBAAqB,QAAQ,QAAQ;AAC/E,QAAI,aAAa,KAAM,QAAO;AAC9B,UAAM,OAAO,OAAO,8BAA8B,OAAO,CAAC,QAAQ,CAAC;AAAA,EACrE;AACA,SAAO;AACT;"}
+{"version":3,"file":"edit-command.js","sources":["../../../../../agent-runtime/src/edit-command.ts"],"sourcesContent":["import type { StatewireThread } from '@assistant-ui/react-statewire';\nimport { DEEP_AGENT_INTEREST_PROTOCOL } from './generated/runconfig-contract';\nimport {\n  type DeepAgentMessageWindow,\n  pageInterestRequests,\n  readDeepAgentMessageWindow,\n} from './message-window';\nimport { hasStatewireThreadExtras } from './thread-extras';\n\n/**\n * Wire-accurate `run/edit` construction for deep-agent retry/edit, shared by\n * every surface that resubmits a user message.\n *\n * assistant-ui builds the command's `runAnchorMessageId` from the CONVERTED\n * thread messages (`resolveEditCommand`: `messages[index - 1].id`), but the\n * deep-agent host validates that anchor against the edited message's parent in\n * its RAW message list (`harness_sdk.linear_thread`: the entry before it in\n * `state[\"messages\"]`). Those two lists do not line up:\n *\n * - the converter chunks an assistant turn and its tool messages into ONE\n *   thread message carrying only the FIRST wire id, so the anchor names the\n *   head of the previous turn instead of its last tool message;\n * - `sanitizeLangChainMessages` drops hidden-from-frontend and unconvertible\n *   entries, so a dropped tail message is invisible to the anchor too.\n *\n * Either way the host rejects the command with `wrong-anchor`\n * (`runAnchorMessageId … is not the source's parent`) AFTER the composer's\n * synchronous `send()` returned, so the retry/edit silently does nothing.\n *\n * Building the command here off the replicated raw state makes the anchor the\n * same value the host computes.\n *\n * The raw list is the loaded interest window, so the first loaded message's\n * parent is not in it while older messages exist — an edit there must not\n * anchor on `null` (the root, rejected `wrong-anchor`); a message below the\n * window has no parent on this client at all. {@link resolveDeepAgentEditCommand}\n * states older page interests until the parent is loaded.\n */\n\n/**\n * Host metadata frozen at submission, settling once the async capture does.\n * The message-metadata preparation surface — `prepareMessageMetadata`,\n * `discardPreparedMessageMetadata`, `sendPreparedEdit` and `sendCommand`'s\n * `preparedMetadata` option — is what the monorepo patches into\n * `@assistant-ui/react-statewire@0.29.1` (`patches/`). It is declared\n * structurally here rather than as `StatewireThread.Extras[...]` so that the\n * published sources also compile against the unpatched upstream typings, where\n * those members are absent and the edit path's optional calls never run.\n */\nexport type DeepAgentPreparedMessageMetadata = Promise<Record<string, unknown> | undefined>;\n\n/** The pieces of the statewire thread extras the edit path reads. */\nexport interface DeepAgentStatewireExtras {\n  /** The library's dispatch; it resolves with the host's reply to the command. */\n  sendCommand: (\n    command: StatewireThread.Command,\n    options?: { preparedMetadata?: DeepAgentPreparedMessageMetadata | undefined },\n  ) => Promise<unknown> | void;\n  /** Optional on older hosts; capture before loading an edit's history anchor. */\n  prepareMessageMetadata?: (() => DeepAgentPreparedMessageMetadata) | undefined;\n  discardPreparedMessageMetadata?:\n    | ((prepared: DeepAgentPreparedMessageMetadata) => void)\n    | undefined;\n  sendPreparedEdit?:\n    | ((sourceId: string, prepared: DeepAgentPreparedMessageMetadata) => void)\n    | undefined;\n  isPreparingSubmission?: boolean;\n  /** The composed thread state — its `messages` are the raw wire messages of the loaded window. */\n  state: { messages?: readonly { id?: unknown }[] } | null;\n  /** The mounted documents (the interest window), absent on a wire without documents. */\n  documents?: StatewireThread.Extras['documents'];\n  invoke?: StatewireThread.Extras['invoke'];\n  /** The live run, when one is in flight; `epoch` advances on each dispatch. */\n  runs: { runId?: string | null; epoch?: number };\n  /** The host's replicated run status; absent on a surface that predates it. */\n  status?: StatewireThread.ThreadStatus;\n}\n\n/**\n * The statewire extras of the nearest aui thread, or `null` when the thread is\n * not a statewire thread (e.g. a read-only subagent transcript runtime).\n * Gated on {@link hasStatewireThreadExtras} for the same reason the approval\n * card is: the library's own hooks throw on a non-statewire thread.\n */\nexport function readDeepAgentStatewireExtras(extras: unknown): DeepAgentStatewireExtras | null {\n  if (!hasStatewireThreadExtras(extras)) return null;\n  return extras as DeepAgentStatewireExtras;\n}\n\n/**\n * The host's parent of `sourceId`: the raw wire message directly before it\n * (`null` when it is the first of the whole transcript). Returns `undefined`\n * when `sourceId` is not in the raw list at all — an optimistic bubble the\n * host has not settled yet, a message below the loaded window, or a surface\n * whose state this module cannot read — or when it is the first loaded\n * message while older ones exist (`hasOlder`), so the caller can load more or\n * fall back to the library's own path instead of asserting a wrong anchor.\n */\nexport function resolveWireAnchorMessageId({\n  wireMessages,\n  sourceId,\n  hasOlder = false,\n}: {\n  wireMessages: readonly { id?: unknown }[] | undefined;\n  sourceId: string;\n  hasOlder?: boolean;\n}): string | null | undefined {\n  if (!wireMessages) return undefined;\n  const index = wireMessages.findIndex((message) => message?.id === sourceId);\n  if (index < 0) return undefined;\n  if (index === 0) return hasOlder ? undefined : null;\n  const parentId = wireMessages[index - 1]?.id;\n  return typeof parentId === 'string' ? parentId : undefined;\n}\n\n/**\n * Whether `sourceId`'s parent lies below the loaded window: the message is\n * absent from the raw list, or its first entry, while older messages exist.\n * The caller loads older history before an edit can be anchored.\n */\nexport function isSourceBelowLoadedWindow({\n  wireMessages,\n  sourceId,\n  window,\n}: {\n  wireMessages: readonly { id?: unknown }[] | undefined;\n  sourceId: string;\n  window: DeepAgentMessageWindow | null;\n}): boolean {\n  if (!wireMessages || window === null || !window.hasOlder) return false;\n  const index = wireMessages.findIndex((message) => message?.id === sourceId);\n  return index <= 0;\n}\n\nconst readWindow = (extras: DeepAgentStatewireExtras) =>\n  readDeepAgentMessageWindow(extras.documents?.list());\n\n/**\n * A fresh command / message id (uniqueness, not secrecy). `crypto.randomUUID`\n * where the host runtime has it — every browser, Bun, Node and Hermes with\n * webcrypto — and a v4-shaped fallback elsewhere, so the shared path never\n * throws on a runtime without full webcrypto.\n */\nfunction mintCommandId(): string {\n  const webcrypto = (globalThis as { crypto?: { randomUUID?: () => string } }).crypto;\n  if (typeof webcrypto?.randomUUID === 'function') return webcrypto.randomUUID();\n  const hex = (): string => Math.floor(Math.random() * 0x10000).toString(16).padStart(4, '0');\n  return `${hex()}${hex()}-${hex()}-4${hex().slice(1)}-${hex()}-${hex()}${hex()}${hex()}`;\n}\n\n/**\n * The `run/edit` command for resubmitting `sourceId` with `text`, anchored on\n * the host's own parent. `null` when the anchor cannot be resolved from the\n * replicated state.\n */\nexport function buildDeepAgentEditCommand({\n  extras,\n  sourceId,\n  text,\n}: {\n  extras: DeepAgentStatewireExtras;\n  sourceId: string;\n  text: string;\n}): StatewireThread.RunEditCommand | null {\n  const runAnchorMessageId = resolveWireAnchorMessageId({\n    wireMessages: extras.state?.messages,\n    sourceId,\n    hasOlder: readWindow(extras)?.hasOlder ?? false,\n  });\n  if (runAnchorMessageId === undefined) return null;\n  return {\n    type: 'run/edit',\n    runId: extras.runs.runId ?? mintCommandId(),\n    message: { id: mintCommandId(), role: 'user', parts: [{ type: 'text', text }] },\n    sourceId,\n    runAnchorMessageId,\n  };\n}\n\n/**\n * Pages of older history stated while looking for an edited message's host\n * parent. Each page is up to a window's worth of messages, so an edit reaches\n * this many windows below what was loaded before it gives up.\n */\nexport const MAX_EDIT_ANCHOR_HISTORY_LOADS = 5;\n\n/**\n * The anchored `run/edit` for `sourceId`, stating older page interests one at\n * a time when the message's parent lies below the loaded window. Every page\n * is read back from the live documents (`readExtras` — the host mounts them\n * before it answers the statement), so the anchor is always the host's own\n * parent id.\n *\n * Resolves `null` — the caller's cue for the library's composer path, whose\n * failure it reports — when the thread is not a statewire thread, the host has\n * not settled the message, the history is exhausted without it, or the page\n * budget ({@link MAX_EDIT_ANCHOR_HISTORY_LOADS}) is spent. A synchronous\n * resolution never awaits: the first read either anchors at once or decides\n * that pages are needed.\n */\nexport async function resolveDeepAgentEditCommand({\n  readExtras,\n  sourceId,\n  text,\n  pageSize,\n  maxHistoryLoads = MAX_EDIT_ANCHOR_HISTORY_LOADS,\n}: {\n  /** The live thread extras — re-read per page so each anchor attempt sees the widened window. */\n  readExtras: () => DeepAgentStatewireExtras | null;\n  sourceId: string;\n  text: string;\n  pageSize?: number;\n  maxHistoryLoads?: number;\n}): Promise<StatewireThread.RunEditCommand | null> {\n  for (let page = 0; page <= maxHistoryLoads; page += 1) {\n    const extras = readExtras();\n    if (!extras) return null;\n    const command = buildDeepAgentEditCommand({ extras, sourceId, text });\n    if (command) return command;\n    if (page === maxHistoryLoads || !extras.invoke) return null;\n    const window = readWindow(extras);\n    if (!isSourceBelowLoadedWindow({ wireMessages: extras.state?.messages, sourceId, window })) {\n      return null;\n    }\n    const requests = window === null ? null : pageInterestRequests(window, pageSize);\n    if (requests === null) return null;\n    await extras.invoke(DEEP_AGENT_INTEREST_PROTOCOL, 'set', [requests]);\n  }\n  return null;\n}\n"],"names":[],"mappings":";;;AAoFO,SAAS,6BAA6B,QAAkD;AAC7F,MAAI,CAAC,yBAAyB,MAAM,EAAG,QAAO;AAC9C,SAAO;AACT;AAWO,SAAS,2BAA2B;AAAA,EACzC;AAAA,EACA;AAAA,EACA,WAAW;AACb,GAI8B;;AAC5B,MAAI,CAAC,aAAc,QAAO;AAC1B,QAAM,QAAQ,aAAa,UAAU,CAAC,aAAY,mCAAS,QAAO,QAAQ;AAC1E,MAAI,QAAQ,EAAG,QAAO;AACtB,MAAI,UAAU,EAAG,QAAO,WAAW,SAAY;AAC/C,QAAM,YAAW,kBAAa,QAAQ,CAAC,MAAtB,mBAAyB;AAC1C,SAAO,OAAO,aAAa,WAAW,WAAW;AACnD;AAOO,SAAS,0BAA0B;AAAA,EACxC;AAAA,EACA;AAAA,EACA;AACF,GAIY;AACV,MAAI,CAAC,gBAAgB,WAAW,QAAQ,CAAC,OAAO,SAAU,QAAO;AACjE,QAAM,QAAQ,aAAa,UAAU,CAAC,aAAY,mCAAS,QAAO,QAAQ;AAC1E,SAAO,SAAS;AAClB;AAEA,MAAM,aAAa,CAAC,WAAA;;AAClB,qCAA2B,YAAO,cAAP,mBAAkB,MAAM;AAAA;AAQrD,SAAS,gBAAwB;AAC/B,QAAM,YAAa,WAA0D;AAC7E,MAAI,QAAO,uCAAW,gBAAe,WAAY,QAAO,UAAU,WAAA;AAClE,QAAM,MAAM,MAAc,KAAK,MAAM,KAAK,OAAA,IAAW,KAAO,EAAE,SAAS,EAAE,EAAE,SAAS,GAAG,GAAG;AAC1F,SAAO,GAAG,IAAA,CAAK,GAAG,IAAA,CAAK,IAAI,IAAA,CAAK,KAAK,MAAM,MAAM,CAAC,CAAC,IAAI,IAAA,CAAK,IAAI,KAAK,GAAG,IAAA,CAAK,GAAG,IAAA,CAAK;AACvF;AAOO,SAAS,0BAA0B;AAAA,EACxC;AAAA,EACA;AAAA,EACA;AACF,GAI0C;;AACxC,QAAM,qBAAqB,2BAA2B;AAAA,IACpD,eAAc,YAAO,UAAP,mBAAc;AAAA,IAC5B;AAAA,IACA,YAAU,gBAAW,MAAM,MAAjB,mBAAoB,aAAY;AAAA,EAAA,CAC3C;AACD,MAAI,uBAAuB,OAAW,QAAO;AAC7C,SAAO;AAAA,IACL,MAAM;AAAA,IACN,OAAO,OAAO,KAAK,SAAS,cAAA;AAAA,IAC5B,SAAS,EAAE,IAAI,cAAA,GAAiB,MAAM,QAAQ,OAAO,CAAC,EAAE,MAAM,QAAQ,KAAA,CAAM,EAAA;AAAA,IAC5E;AAAA,IACA;AAAA,EAAA;AAEJ;AAOO,MAAM,gCAAgC;AAgB7C,eAAsB,4BAA4B;AAAA,EAChD;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA,kBAAkB;AACpB,GAOmD;;AACjD,WAAS,OAAO,GAAG,QAAQ,iBAAiB,QAAQ,GAAG;AACrD,UAAM,SAAS,WAAA;AACf,QAAI,CAAC,OAAQ,QAAO;AACpB,UAAM,UAAU,0BAA0B,EAAE,QAAQ,UAAU,MAAM;AACpE,QAAI,QAAS,QAAO;AACpB,QAAI,SAAS,mBAAmB,CAAC,OAAO,OAAQ,QAAO;AACvD,UAAM,SAAS,WAAW,MAAM;AAChC,QAAI,CAAC,0BAA0B,EAAE,eAAc,YAAO,UAAP,mBAAc,UAAU,UAAU,OAAA,CAAQ,GAAG;AAC1F,aAAO;AAAA,IACT;AACA,UAAM,WAAW,WAAW,OAAO,OAAO,qBAAqB,QAAQ,QAAQ;AAC/E,QAAI,aAAa,KAAM,QAAO;AAC9B,UAAM,OAAO,OAAO,8BAA8B,OAAO,CAAC,QAAQ,CAAC;AAAA,EACrE;AACA,SAAO;AACT;"}

package/dist/packages/agent-runtime/src/errors.cjs

@@ -25,17 +25,32 @@ function readRetryableRunRefusal(error) {
   if (error === null || typeof error !== "object" || Array.isArray(error)) return null;
   return readRetryableDetail(error.detail);
 }
+function readRetryableCommandRejection(error) {
+  const payload = statewireRejectionPayload(error);
+  return payload === null ? null : readRetryableDetail(payload.detail);
+}
 function isLegacyThreadReadOnlyRejection(error) {
   const payload = statewireRejectionPayload(error);
   if ((payload == null ? void 0 : payload.status) !== 409) return false;
   const detail = payload.detail;
   return (detail == null ? void 0 : detail.code) === "legacy_thread_read_only";
 }
+function isStatewireExpiredVerdict(error) {
+  const failure = error == null ? void 0 : error.failure;
+  return (failure == null ? void 0 : failure.fate) === "expired" && failure.cause === "server";
+}
 function isStatewireChannelTeardown(error) {
   var _a;
   const cause = (_a = error == null ? void 0 : error.failure) == null ? void 0 : _a.cause;
   return typeof cause === "string" && cause !== "server";
 }
+function statewireTransportOutcome(error) {
+  var _a, _b;
+  const cause = (_a = error == null ? void 0 : error.failure) == null ? void 0 : _a.cause;
+  if (typeof cause === "string" && cause !== "server") return cause;
+  if (isStatewireExpiredVerdict(error)) return "expired";
+  return ((_b = readRetryableCommandRejection(error)) == null ? void 0 : _b.code) ?? null;
+}
 const sanitizeConnectionMessage = (message) => {
   const printable = Array.from(message, (character) => {
     const code = character.charCodeAt(0);
@@ -88,8 +103,11 @@ function unknownConnectionStatus(connection) {
 }
 exports.isLegacyThreadReadOnlyRejection = isLegacyThreadReadOnlyRejection;
 exports.isStatewireChannelTeardown = isStatewireChannelTeardown;
+exports.isStatewireExpiredVerdict = isStatewireExpiredVerdict;
 exports.projectDeepAgentConnection = projectDeepAgentConnection;
+exports.readRetryableCommandRejection = readRetryableCommandRejection;
 exports.readRetryableRunRefusal = readRetryableRunRefusal;
 exports.statewireRejectionDetailMessage = statewireRejectionDetailMessage;
 exports.statewireRejectionPayload = statewireRejectionPayload;
+exports.statewireTransportOutcome = statewireTransportOutcome;
 //# sourceMappingURL=errors.cjs.map