@signalcore/ui 0.1.0 → 1.0.0-beta.1

package/dist/useAgentFace.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAgentFace.js","names":[],"sources":["../src/useAgentFace.ts"],"sourcesContent":["import { useEffect, useState } from \"react\";\n\nimport type { Client } from \"./client\";\nimport type { AgentFace } from \"./types\";\n\n/** The agent's face as it is read: null until it lands, with what the read threw if it failed. */\nexport interface FaceRead {\n  face: AgentFace | null;\n  loading: boolean;\n  error: unknown;\n}\n\n/** A read that landed, and for which agent: one for another is not this one's. */\ninterface Landed {\n  client: Client;\n  agentId: string;\n  face: AgentFace | null;\n  error: unknown;\n}\n\n/**\n * What a person may know of agent `agentId` (`GET /agents/{id}/face`): its name, its role, the\n * mark of its work and whether it takes calls, read once for each agent. Until it lands (and\n * while another agent's is read) there is none; one that lands for an agent no longer asked\n * about is dropped.\n */\nexport function useAgentFace(client: Client, agentId: string): FaceRead {\n  const [landed, setLanded] = useState<Landed | null>(null);\n  useEffect(() => {\n    let asked = true;\n    client.agents.face(agentId).then(\n      (face) => {\n        if (asked) setLanded({ client, agentId, face, error: null });\n      },\n      (error: unknown) => {\n        if (asked) setLanded({ client, agentId, face: null, error });\n      },\n    );\n    return () => {\n      asked = false;\n    };\n  }, [client, agentId]);\n  const current = landed !== null && landed.client === client && landed.agentId === agentId;\n  return current\n    ? { face: landed.face, loading: false, error: landed.error }\n    : { face: null, loading: true, error: null };\n}\n"],"mappings":";;;;;;;;AA0BA,SAAgB,aAAa,QAAgB,SAA2B;CACtE,MAAM,CAAC,QAAQ,aAAa,SAAwB,IAAI;CACxD,gBAAgB;EACd,IAAI,QAAQ;EACZ,OAAO,OAAO,KAAK,OAAO,CAAC,CAAC,MACzB,SAAS;GACR,IAAI,OAAO,UAAU;IAAE;IAAQ;IAAS;IAAM,OAAO;GAAK,CAAC;EAC7D,IACC,UAAmB;GAClB,IAAI,OAAO,UAAU;IAAE;IAAQ;IAAS,MAAM;IAAM;GAAM,CAAC;EAC7D,CACF;EACA,aAAa;GACX,QAAQ;EACV;CACF,GAAG,CAAC,QAAQ,OAAO,CAAC;CAEpB,OADgB,WAAW,QAAQ,OAAO,WAAW,UAAU,OAAO,YAAY,UAE9E;EAAE,MAAM,OAAO;EAAM,SAAS;EAAO,OAAO,OAAO;CAAM,IACzD;EAAE,MAAM;EAAM,SAAS;EAAM,OAAO;CAAK;AAC/C"}

package/dist/useCall.d.ts

@@ -0,0 +1,39 @@
+import { CallState } from "./call.js";
+import { RefObject } from "react";
+//#region src/useCall.d.ts
+/** Where a call is joined: LiveKit's address, and a token for the call's room. */
+export interface CallJoin {
+  url: string;
+  token: string;
+}
+/** How loud each side of the call is right now, from 0 to 1, read when asked (every frame). */
+export interface CallMeter {
+  agent: () => number;
+  person: () => number;
+}
+/** A call, live: where it stands, how loud it is, and what the person can do on it. */
+export interface Call {
+  state: CallState;
+  meter: CallMeter;
+  /** Turns the microphone off or on; the other way from now when not said. */
+  mute: (muted?: boolean) => void;
+  /** Ends the call, for both sides. */
+  hangUp: () => void;
+  /** Lets the agent's voice play where the browser held it until the person pressed something. */
+  hear: () => void;
+}
+/**
+ * A voice call through LiveKit, for as long as the component is mounted: the microphone first
+ * (a person who can't be heard has no call, and no call is made for them), then `connect` for
+ * where to join (the API's refusal says why there is no call), the room, and the microphone
+ * published into it. The agent's voice plays as it comes (its `<audio>` goes into `sink`), and
+ * the call is on once the agent joins; its state is what the agent says it is doing. It ends when
+ * the person hangs up, when the room closes (the agent's goodbye, or its longest time: the API
+ * says which), when the line goes, or when no agent comes. Unmounting hangs up. `connect` is read
+ * once, when the call starts.
+ */
+export declare function useCall(connect: () => Promise<CallJoin>, { sink }: {
+  sink: RefObject<HTMLElement | null>;
+}): Call;
+//#endregion
+//# sourceMappingURL=useCall.d.ts.map

package/dist/useCall.js

@@ -0,0 +1,273 @@
+import { CALL_START, activityOf, callProblemOf, callReducer, endedBy, loudness, refusalOf } from "./call.js";
+import { useEffect, useReducer, useRef, useState } from "react";
+import { DisconnectReason, Room, RoomEvent, Track, createAudioAnalyser, createLocalAudioTrack } from "livekit-client";
+//#region src/useCall.ts
+/** How long a room may wait for its agent before the call is given up as unanswered. */
+const ANSWER_WITHIN = 2e4;
+/** How long the agent may be gone from the room before the call counts as dropped (its own end
+* closes the room for everyone, which says why, within this). */
+const GONE_FOR = 1500;
+/** What LiveKit's agents say they are doing, on their participant. */
+const AGENT_STATE = "lk.agent.state";
+/** A voice, cleaned as a phone call's is. */
+const CAPTURE = {
+	echoCancellation: true,
+	noiseSuppression: true,
+	autoGainControl: true
+};
+/** Speech, measured: a wide window of loudness, smoothed a little by the analyser itself. */
+const MEASURE = {
+	fftSize: 512,
+	smoothingTimeConstant: .5,
+	minDecibels: -90,
+	maxDecibels: -25
+};
+const SILENT = () => 0;
+/**
+* A voice call through LiveKit, for as long as the component is mounted: the microphone first
+* (a person who can't be heard has no call, and no call is made for them), then `connect` for
+* where to join (the API's refusal says why there is no call), the room, and the microphone
+* published into it. The agent's voice plays as it comes (its `<audio>` goes into `sink`), and
+* the call is on once the agent joins; its state is what the agent says it is doing. It ends when
+* the person hangs up, when the room closes (the agent's goodbye, or its longest time: the API
+* says which), when the line goes, or when no agent comes. Unmounting hangs up. `connect` is read
+* once, when the call starts.
+*/
+function useCall(connect, { sink }) {
+	const [state, dispatch] = useReducer(callReducer, CALL_START);
+	const given = useRef(connect);
+	useEffect(() => {
+		given.current = connect;
+	});
+	const line = useRef({
+		room: null,
+		mic: null,
+		hangUp: () => void 0
+	});
+	const readers = useRef({
+		agent: SILENT,
+		person: SILENT
+	});
+	const [meter] = useState(() => ({
+		agent: () => readers.current.agent(),
+		person: () => readers.current.person()
+	}));
+	useEffect(() => {
+		const room = new Room({ disconnectOnPageLeave: true });
+		let mic = null;
+		let gone = false;
+		let hungUp = false;
+		let joined = false;
+		let answeredAt = null;
+		let unanswered;
+		let away;
+		const releases = [];
+		const stopped = () => gone || hungUp;
+		/**
+		* Lets go of everything the call holds: the timers, the voices playing and the meters, the
+		* microphone, the room.
+		*/
+		const release = () => {
+			clearTimeout(unanswered);
+			clearTimeout(away);
+			for (const each of releases.splice(0)) each();
+			readers.current = {
+				agent: SILENT,
+				person: SILENT
+			};
+			mic?.stop();
+			room.disconnect();
+		};
+		const fail = (problem) => {
+			if (gone) return;
+			dispatch({
+				type: "failed",
+				problem
+			});
+			release();
+		};
+		/** A meter over a track, and its release with the call. */
+		const measure = (track) => {
+			const analyser = createAudioAnalyser(track, MEASURE);
+			releases.push(() => {
+				analyser.cleanup();
+			});
+			return () => loudness(analyser.calculateVolume());
+		};
+		const answer = (agent) => {
+			clearTimeout(unanswered);
+			clearTimeout(away);
+			if (answeredAt === null) {
+				answeredAt = Date.now();
+				dispatch({
+					type: "answered",
+					at: answeredAt
+				});
+			}
+			dispatch({
+				type: "agent",
+				activity: activityOf(agent.attributes[AGENT_STATE])
+			});
+		};
+		room.on(RoomEvent.ParticipantConnected, (participant) => {
+			if (participant.isAgent) answer(participant);
+		}).on(RoomEvent.ParticipantAttributesChanged, (_, participant) => {
+			if (!participant.isAgent) return;
+			dispatch({
+				type: "agent",
+				activity: activityOf(participant.attributes[AGENT_STATE])
+			});
+		}).on(RoomEvent.ActiveSpeakersChanged, (speakers) => {
+			dispatch({
+				type: "speaking",
+				speaking: speakers.some((each) => each.isAgent)
+			});
+		}).on(RoomEvent.TrackSubscribed, (track, _, participant) => {
+			if (track.kind !== Track.Kind.Audio) return;
+			const voice = track.attach();
+			sink.current?.append(voice);
+			releases.push(() => {
+				track.detach(voice);
+				voice.remove();
+			});
+			if (participant.isAgent) readers.current.agent = measure(track);
+		}).on(RoomEvent.TrackUnsubscribed, (track) => {
+			for (const element of track.detach()) element.remove();
+		}).on(RoomEvent.AudioPlaybackStatusChanged, () => {
+			dispatch({
+				type: "silenced",
+				silenced: !room.canPlaybackAudio
+			});
+		}).on(RoomEvent.Reconnecting, () => {
+			dispatch({
+				type: "reconnecting",
+				reconnecting: true
+			});
+		}).on(RoomEvent.Reconnected, () => {
+			dispatch({
+				type: "reconnecting",
+				reconnecting: false
+			});
+		}).on(RoomEvent.ParticipantDisconnected, (participant) => {
+			if (!participant.isAgent) return;
+			away = setTimeout(() => {
+				if (gone) return;
+				dispatch({
+					type: "ended",
+					by: "dropped",
+					at: Date.now()
+				});
+				release();
+			}, GONE_FOR);
+		}).on(RoomEvent.Disconnected, (reason) => {
+			if (gone || !joined) return;
+			const name = reason === void 0 ? void 0 : DisconnectReason[reason];
+			dispatch({
+				type: "ended",
+				by: endedBy(name, hungUp),
+				at: Date.now()
+			});
+			release();
+		});
+		const start = async () => {
+			if (typeof navigator === "undefined" || !navigator.mediaDevices?.getUserMedia) {
+				fail("unsupported");
+				return;
+			}
+			try {
+				mic = await createLocalAudioTrack(CAPTURE);
+			} catch (error) {
+				fail(callProblemOf(error));
+				return;
+			}
+			if (stopped()) return release();
+			line.current.mic = mic;
+			let where;
+			try {
+				where = await given.current();
+			} catch (error) {
+				if (stopped()) return release();
+				fail(refusalOf(error));
+				return;
+			}
+			if (stopped()) return release();
+			try {
+				await room.connect(where.url, where.token);
+				if (stopped()) return release();
+				await room.localParticipant.publishTrack(mic, { source: Track.Source.Microphone });
+			} catch {
+				if (stopped()) return release();
+				fail("failed");
+				return;
+			}
+			if (stopped()) return release();
+			joined = true;
+			readers.current.person = measure(mic);
+			dispatch({ type: "ringing" });
+			dispatch({
+				type: "silenced",
+				silenced: !room.canPlaybackAudio
+			});
+			const agent = [...room.remoteParticipants.values()].find((each) => each.isAgent);
+			if (agent) answer(agent);
+			else unanswered = setTimeout(() => fail("unanswered"), ANSWER_WITHIN);
+		};
+		line.current = {
+			room,
+			mic: null,
+			hangUp: () => {
+				if (gone || hungUp) return;
+				hungUp = true;
+				dispatch({
+					type: "ended",
+					by: "person",
+					at: Date.now()
+				});
+				release();
+			}
+		};
+		start();
+		return () => {
+			gone = true;
+			release();
+			room.removeAllListeners();
+			line.current = {
+				room: null,
+				mic: null,
+				hangUp: () => void 0
+			};
+		};
+	}, [sink]);
+	return {
+		state,
+		meter,
+		mute: (muted) => {
+			const { mic } = line.current;
+			if (mic === null || state.stage === "over") return;
+			const next = muted ?? !state.muted;
+			(next ? mic.mute() : mic.unmute()).then(() => {
+				dispatch({
+					type: "muted",
+					muted: next
+				});
+			});
+		},
+		hangUp: () => {
+			line.current.hangUp();
+		},
+		hear: () => {
+			const { room } = line.current;
+			if (room === null) return;
+			room.startAudio().then(() => {
+				dispatch({
+					type: "silenced",
+					silenced: !room.canPlaybackAudio
+				});
+			});
+		}
+	};
+}
+//#endregion
+export { useCall };
+
+//# sourceMappingURL=useCall.js.map

package/dist/useCall.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCall.js","names":[],"sources":["../src/useCall.ts"],"sourcesContent":["import {\n  createAudioAnalyser,\n  createLocalAudioTrack,\n  DisconnectReason,\n  Room,\n  RoomEvent,\n  Track,\n  type AudioAnalyserOptions,\n  type LocalAudioTrack,\n  type LocalTrack,\n  type Participant,\n  type RemoteAudioTrack,\n} from \"livekit-client\";\nimport { useEffect, useReducer, useRef, useState, type RefObject } from \"react\";\n\nimport {\n  activityOf,\n  CALL_START,\n  callReducer,\n  endedBy,\n  loudness,\n  callProblemOf,\n  refusalOf,\n  type CallProblem,\n  type CallState,\n} from \"./call\";\n\n/** Where a call is joined: LiveKit's address, and a token for the call's room. */\nexport interface CallJoin {\n  url: string;\n  token: string;\n}\n\n/** How loud each side of the call is right now, from 0 to 1, read when asked (every frame). */\nexport interface CallMeter {\n  agent: () => number;\n  person: () => number;\n}\n\n/** A call, live: where it stands, how loud it is, and what the person can do on it. */\nexport interface Call {\n  state: CallState;\n  meter: CallMeter;\n  /** Turns the microphone off or on; the other way from now when not said. */\n  mute: (muted?: boolean) => void;\n  /** Ends the call, for both sides. */\n  hangUp: () => void;\n  /** Lets the agent's voice play where the browser held it until the person pressed something. */\n  hear: () => void;\n}\n\n/** How long a room may wait for its agent before the call is given up as unanswered. */\nconst ANSWER_WITHIN = 20_000;\n/** How long the agent may be gone from the room before the call counts as dropped (its own end\n * closes the room for everyone, which says why, within this). */\nconst GONE_FOR = 1_500;\n/** What LiveKit's agents say they are doing, on their participant. */\nconst AGENT_STATE = \"lk.agent.state\";\n/** A voice, cleaned as a phone call's is. */\nconst CAPTURE = { echoCancellation: true, noiseSuppression: true, autoGainControl: true };\n/** Speech, measured: a wide window of loudness, smoothed a little by the analyser itself. */\nconst MEASURE: AudioAnalyserOptions = {\n  fftSize: 512,\n  smoothingTimeConstant: 0.5,\n  minDecibels: -90,\n  maxDecibels: -25,\n};\nconst SILENT = (): number => 0;\n\n/**\n * A voice call through LiveKit, for as long as the component is mounted: the microphone first\n * (a person who can't be heard has no call, and no call is made for them), then `connect` for\n * where to join (the API's refusal says why there is no call), the room, and the microphone\n * published into it. The agent's voice plays as it comes (its `<audio>` goes into `sink`), and\n * the call is on once the agent joins; its state is what the agent says it is doing. It ends when\n * the person hangs up, when the room closes (the agent's goodbye, or its longest time: the API\n * says which), when the line goes, or when no agent comes. Unmounting hangs up. `connect` is read\n * once, when the call starts.\n */\nexport function useCall(\n  connect: () => Promise<CallJoin>,\n  { sink }: { sink: RefObject<HTMLElement | null> },\n): Call {\n  const [state, dispatch] = useReducer(callReducer, CALL_START);\n  const given = useRef(connect);\n  useEffect(() => {\n    given.current = connect;\n  });\n  // What the person's buttons reach into: the room and the microphone, once they exist.\n  const line = useRef<{ room: Room | null; mic: LocalAudioTrack | null; hangUp: () => void }>({\n    room: null,\n    mic: null,\n    hangUp: () => undefined,\n  });\n  // The meters read whatever track each side has now; silence until it has one.\n  const readers = useRef<CallMeter>({ agent: SILENT, person: SILENT });\n  const [meter] = useState<CallMeter>(() => ({\n    agent: () => readers.current.agent(),\n    person: () => readers.current.person(),\n  }));\n\n  useEffect(() => {\n    const room = new Room({ disconnectOnPageLeave: true });\n    let mic: LocalAudioTrack | null = null;\n    let gone = false;\n    let hungUp = false;\n    // In the room with the microphone published: from here the room's own end is the call's.\n    let joined = false;\n    let answeredAt: number | null = null;\n    let unanswered: ReturnType<typeof setTimeout> | undefined;\n    let away: ReturnType<typeof setTimeout> | undefined;\n    const releases: (() => void)[] = [];\n    const stopped = () => gone || hungUp;\n\n    /**\n     * Lets go of everything the call holds: the timers, the voices playing and the meters, the\n     * microphone, the room.\n     */\n    const release = () => {\n      clearTimeout(unanswered);\n      clearTimeout(away);\n      for (const each of releases.splice(0)) each();\n      readers.current = { agent: SILENT, person: SILENT };\n      mic?.stop();\n      void room.disconnect();\n    };\n\n    const fail = (problem: CallProblem) => {\n      if (gone) return;\n      dispatch({ type: \"failed\", problem });\n      release();\n    };\n\n    /** A meter over a track, and its release with the call. */\n    const measure = (track: LocalAudioTrack | RemoteAudioTrack): (() => number) => {\n      const analyser = createAudioAnalyser(track, MEASURE);\n      releases.push(() => {\n        void analyser.cleanup();\n      });\n      return () => loudness(analyser.calculateVolume());\n    };\n\n    const answer = (agent: Participant) => {\n      clearTimeout(unanswered);\n      clearTimeout(away);\n      if (answeredAt === null) {\n        answeredAt = Date.now();\n        dispatch({ type: \"answered\", at: answeredAt });\n      }\n      dispatch({ type: \"agent\", activity: activityOf(agent.attributes[AGENT_STATE]) });\n    };\n\n    room\n      .on(RoomEvent.ParticipantConnected, (participant) => {\n        if (participant.isAgent) answer(participant);\n      })\n      .on(RoomEvent.ParticipantAttributesChanged, (_, participant) => {\n        if (!participant.isAgent) return;\n        dispatch({ type: \"agent\", activity: activityOf(participant.attributes[AGENT_STATE]) });\n      })\n      .on(RoomEvent.ActiveSpeakersChanged, (speakers) => {\n        dispatch({ type: \"speaking\", speaking: speakers.some((each) => each.isAgent) });\n      })\n      .on(RoomEvent.TrackSubscribed, (track, _, participant) => {\n        if (track.kind !== Track.Kind.Audio) return;\n        const voice = track.attach();\n        sink.current?.append(voice);\n        // A room left from here says nothing of its tracks: the call lets go of each itself.\n        releases.push(() => {\n          track.detach(voice);\n          voice.remove();\n        });\n        if (participant.isAgent) readers.current.agent = measure(track as RemoteAudioTrack);\n      })\n      .on(RoomEvent.TrackUnsubscribed, (track) => {\n        for (const element of track.detach()) element.remove();\n      })\n      .on(RoomEvent.AudioPlaybackStatusChanged, () => {\n        dispatch({ type: \"silenced\", silenced: !room.canPlaybackAudio });\n      })\n      .on(RoomEvent.Reconnecting, () => {\n        dispatch({ type: \"reconnecting\", reconnecting: true });\n      })\n      .on(RoomEvent.Reconnected, () => {\n        dispatch({ type: \"reconnecting\", reconnecting: false });\n      })\n      .on(RoomEvent.ParticipantDisconnected, (participant) => {\n        // The agent left without closing the room: its side fell. A goodbye or the longest time\n        // closes the room, whose disconnect comes first and says so.\n        if (!participant.isAgent) return;\n        away = setTimeout(() => {\n          if (gone) return;\n          dispatch({ type: \"ended\", by: \"dropped\", at: Date.now() });\n          release();\n        }, GONE_FOR);\n      })\n      .on(RoomEvent.Disconnected, (reason) => {\n        // Before the call was joined, its start says what went wrong.\n        if (gone || !joined) return;\n        const name = reason === undefined ? undefined : DisconnectReason[reason];\n        dispatch({ type: \"ended\", by: endedBy(name, hungUp), at: Date.now() });\n        release();\n      });\n\n    const start = async () => {\n      if (typeof navigator === \"undefined\" || !navigator.mediaDevices?.getUserMedia) {\n        fail(\"unsupported\");\n        return;\n      }\n      try {\n        mic = await createLocalAudioTrack(CAPTURE);\n      } catch (error) {\n        fail(callProblemOf(error));\n        return;\n      }\n      if (stopped()) return release();\n      line.current.mic = mic;\n      let where: CallJoin;\n      try {\n        where = await given.current();\n      } catch (error) {\n        if (stopped()) return release();\n        fail(refusalOf(error));\n        return;\n      }\n      if (stopped()) return release();\n      try {\n        await room.connect(where.url, where.token);\n        if (stopped()) return release();\n        // LiveKit's own types disagree under `exactOptionalPropertyTypes`: the track is one.\n        await room.localParticipant.publishTrack(mic as LocalTrack, {\n          source: Track.Source.Microphone,\n        });\n      } catch {\n        if (stopped()) return release();\n        fail(\"failed\");\n        return;\n      }\n      if (stopped()) return release();\n      joined = true;\n      readers.current.person = measure(mic);\n      dispatch({ type: \"ringing\" });\n      dispatch({ type: \"silenced\", silenced: !room.canPlaybackAudio });\n      const agent = [...room.remoteParticipants.values()].find((each) => each.isAgent);\n      if (agent) answer(agent);\n      else unanswered = setTimeout(() => fail(\"unanswered\"), ANSWER_WITHIN);\n    };\n\n    line.current = {\n      room,\n      mic: null,\n      hangUp: () => {\n        if (gone || hungUp) return;\n        hungUp = true;\n        dispatch({ type: \"ended\", by: \"person\", at: Date.now() });\n        release();\n      },\n    };\n    void start();\n\n    return () => {\n      gone = true;\n      release();\n      room.removeAllListeners();\n      line.current = { room: null, mic: null, hangUp: () => undefined };\n    };\n    // One call per mount: `connect` is read from `given` when it is needed.\n  }, [sink]);\n\n  return {\n    state,\n    meter,\n    mute: (muted) => {\n      const { mic } = line.current;\n      if (mic === null || state.stage === \"over\") return;\n      const next = muted ?? !state.muted;\n      void (next ? mic.mute() : mic.unmute()).then(() => {\n        dispatch({ type: \"muted\", muted: next });\n      });\n    },\n    hangUp: () => {\n      line.current.hangUp();\n    },\n    hear: () => {\n      const { room } = line.current;\n      if (room === null) return;\n      void room.startAudio().then(() => {\n        dispatch({ type: \"silenced\", silenced: !room.canPlaybackAudio });\n      });\n    },\n  };\n}\n"],"mappings":"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"}

package/dist/useConversation.d.ts

@@ -0,0 +1,77 @@
+import { Action, BrowserControl, BrowserFrame, BrowserInput, BrowserState, Handover, Holder, Message, ToolCall } from "./types.js";
+import { Client } from "./client.js";
+//#region src/useConversation.d.ts
+/**
+ * Runs one of the host's own tools in the page, for the agent: what it resolves to goes back as
+ * the tool's output, what it rejects with as why it failed (an error's message).
+ */
+export type ToolHandler = (call: ToolCall) => Promise<unknown>;
+/** What the page answers a tool of the host's when it runs none (no `onTool`), for the agent. */
+export declare const NO_TOOL = "This page can't do that";
+/** A conversation, live: its messages, where its turn stands, and the ways to speak. */
+export interface LiveConversation {
+  messages: Message[];
+  draft: string;
+  pending: boolean;
+  /**
+   * The step the turn waits on: a surface to answer, or an action the person allows (its
+   * `request`, `decides: "person"`; `act` on its id with `approve` or `decline`). Nothing else
+   * goes until the person acts. A yes the business gives holds nothing.
+   */
+  awaiting: string | null;
+  open: boolean;
+  /** Until the history has landed once. */
+  loading: boolean;
+  /** What the last history read threw, if it failed. */
+  error: unknown;
+  /**
+   * Says something: words, the ids of files uploaded to the conversation for it, or both; false
+   * when it cannot go now: nothing to say, a turn running or waiting, the socket closed.
+   */
+  say: (text: string, files?: readonly string[]) => boolean;
+  /** What the person did on a surface; false when the socket is closed. */
+  act: (action: Action) => boolean;
+  /** Stops the reply on its way; false when the socket is closed. */
+  stop: () => boolean;
+  /** The conversation's browser while it is open: where it is, who holds it. */
+  browser: BrowserState | null;
+  /** Hears each picture of the browser's screen, the latest at once; returns how to stop. */
+  watchScreen: (listener: (frame: BrowserFrame) => void) => () => void;
+  /** Takes the browser from the agent, or gives it back; false when the socket is closed. */
+  control: (to: BrowserControl) => boolean;
+  /** Closes the browser now (it stops being billed); false when the socket is closed. */
+  closeBrowser: () => boolean;
+  /** What the person does on the browser's screen while they hold it. */
+  input: (event: BrowserInput) => boolean;
+  /** Who answers it now: its agent, a person of the business, or nobody; null until the history lands. */
+  holder: Holder | null;
+  /** Every change of who answers it, in order, kept live. */
+  handovers: Handover[];
+}
+/**
+ * Conversation `conversationId` as the person sees it: the history, kept live by the socket.
+ * Each time the socket opens the history is read, with the socket already listening, so nothing
+ * stored can fall between the two; what came live meanwhile is kept. `onError` hears each
+ * error's code (the socket's, or `load` for a history that could not be read): the host words
+ * it, this hook shows no text; but `tool`, the page's answer to a call no longer waiting (one it
+ * answered already, told again), which is let pass (noted in development). `onHolder` hears each
+ * change of who answers it, live, for the host's own views of it; `handover` is the last change
+ * the host knows of (one it made itself, as its request answered), taken at once, so it shows
+ * whether or not the socket tells it.
+ * `onStep` hears each step the agent starts, live, by its action's name, for the host's own
+ * views of it (the builder's column, opened as the agent asks it).
+ * `onTool` runs the host's own tools the agent calls in the page (a `tool` frame), and its answer
+ * goes up (`tool_result`); each call runs once, and one told again while it waits (the socket
+ * opened anew) is answered again with what it gave. Without `onTool`, each is refused with
+ * `NO_TOOL`, so the turn never waits on a page that can't run it. One conversation per mount: key
+ * the component on the id.
+ */
+export declare function useConversation(client: Client, conversationId: string, { onError, onHolder, onStep, handover, onTool }?: {
+  onError?: ((code: string) => void) | undefined;
+  onHolder?: ((holder: Holder, handover: Handover) => void) | undefined;
+  onStep?: ((action: string) => void) | undefined;
+  handover?: Handover | null | undefined;
+  onTool?: ToolHandler | undefined;
+}): LiveConversation;
+//#endregion
+//# sourceMappingURL=useConversation.d.ts.map