@ai-matrx/chat 0.4.0 → 0.4.7

package/dist/agents/redux/execution-system/context-state/context-state.selectors.d.ts

@@ -52,6 +52,7 @@ export declare const selectContextState: (conversationId: string) => ((state: {
     agentSettings: import("../../agent-settings/types.js").AgentSettingsState;
     conversationAttachments: import("../../../connectors/attachments.slice.js").AttachmentsSliceState;
     chatHost: import("../../../../store/chat-host.slice.js").ChatHostState;
+    hostConversations: import("../host-conversations/host-conversations.slice.js").HostConversationsState;
 } & import("../../../../store/root-state.js").ChatHostReadSlices) => ContextStateEntry | null) & {
     clearCache: () => void;
     resultsCount: () => number;
@@ -122,6 +123,7 @@ export declare const selectEstimatedTokens: (conversationId: string) => ((state:
     agentSettings: import("../../agent-settings/types.js").AgentSettingsState;
     conversationAttachments: import("../../../connectors/attachments.slice.js").AttachmentsSliceState;
     chatHost: import("../../../../store/chat-host.slice.js").ChatHostState;
+    hostConversations: import("../host-conversations/host-conversations.slice.js").HostConversationsState;
 } & import("../../../../store/root-state.js").ChatHostReadSlices) => number) & {
     clearCache: () => void;
     resultsCount: () => number;
@@ -177,6 +179,7 @@ export declare const selectEstimatedTokens: (conversationId: string) => ((state:
         agentSettings: import("../../agent-settings/types.js").AgentSettingsState;
         conversationAttachments: import("../../../connectors/attachments.slice.js").AttachmentsSliceState;
         chatHost: import("../../../../store/chat-host.slice.js").ChatHostState;
+        hostConversations: import("../host-conversations/host-conversations.slice.js").HostConversationsState;
     } & import("../../../../store/root-state.js").ChatHostReadSlices) => ContextStateEntry | null) & {
         clearCache: () => void;
         resultsCount: () => number;
@@ -253,6 +256,7 @@ export declare const selectContextFillRatio: (conversationId: string, windowToke
     agentSettings: import("../../agent-settings/types.js").AgentSettingsState;
     conversationAttachments: import("../../../connectors/attachments.slice.js").AttachmentsSliceState;
     chatHost: import("../../../../store/chat-host.slice.js").ChatHostState;
+    hostConversations: import("../host-conversations/host-conversations.slice.js").HostConversationsState;
 } & import("../../../../store/root-state.js").ChatHostReadSlices) => number) & {
     clearCache: () => void;
     resultsCount: () => number;
@@ -308,6 +312,7 @@ export declare const selectContextFillRatio: (conversationId: string, windowToke
         agentSettings: import("../../agent-settings/types.js").AgentSettingsState;
         conversationAttachments: import("../../../connectors/attachments.slice.js").AttachmentsSliceState;
         chatHost: import("../../../../store/chat-host.slice.js").ChatHostState;
+        hostConversations: import("../host-conversations/host-conversations.slice.js").HostConversationsState;
     } & import("../../../../store/root-state.js").ChatHostReadSlices) => number) & {
         clearCache: () => void;
         resultsCount: () => number;
@@ -363,6 +368,7 @@ export declare const selectContextFillRatio: (conversationId: string, windowToke
             agentSettings: import("../../agent-settings/types.js").AgentSettingsState;
             conversationAttachments: import("../../../connectors/attachments.slice.js").AttachmentsSliceState;
             chatHost: import("../../../../store/chat-host.slice.js").ChatHostState;
+            hostConversations: import("../host-conversations/host-conversations.slice.js").HostConversationsState;
         } & import("../../../../store/root-state.js").ChatHostReadSlices) => ContextStateEntry | null) & {
             clearCache: () => void;
             resultsCount: () => number;
@@ -444,6 +450,7 @@ export declare const selectCacheLikelyAlive: (conversationId: string) => ((state
     agentSettings: import("../../agent-settings/types.js").AgentSettingsState;
     conversationAttachments: import("../../../connectors/attachments.slice.js").AttachmentsSliceState;
     chatHost: import("../../../../store/chat-host.slice.js").ChatHostState;
+    hostConversations: import("../host-conversations/host-conversations.slice.js").HostConversationsState;
 } & import("../../../../store/root-state.js").ChatHostReadSlices) => boolean) & {
     clearCache: () => void;
     resultsCount: () => number;
@@ -499,6 +506,7 @@ export declare const selectCacheLikelyAlive: (conversationId: string) => ((state
         agentSettings: import("../../agent-settings/types.js").AgentSettingsState;
         conversationAttachments: import("../../../connectors/attachments.slice.js").AttachmentsSliceState;
         chatHost: import("../../../../store/chat-host.slice.js").ChatHostState;
+        hostConversations: import("../host-conversations/host-conversations.slice.js").HostConversationsState;
     } & import("../../../../store/root-state.js").ChatHostReadSlices) => ContextStateEntry | null) & {
         clearCache: () => void;
         resultsCount: () => number;
@@ -572,6 +580,7 @@ export declare const selectCacheSecondsRemaining: (conversationId: string) => ((
     agentSettings: import("../../agent-settings/types.js").AgentSettingsState;
     conversationAttachments: import("../../../connectors/attachments.slice.js").AttachmentsSliceState;
     chatHost: import("../../../../store/chat-host.slice.js").ChatHostState;
+    hostConversations: import("../host-conversations/host-conversations.slice.js").HostConversationsState;
 } & import("../../../../store/root-state.js").ChatHostReadSlices) => number) & {
     clearCache: () => void;
     resultsCount: () => number;
@@ -627,6 +636,7 @@ export declare const selectCacheSecondsRemaining: (conversationId: string) => ((
         agentSettings: import("../../agent-settings/types.js").AgentSettingsState;
         conversationAttachments: import("../../../connectors/attachments.slice.js").AttachmentsSliceState;
         chatHost: import("../../../../store/chat-host.slice.js").ChatHostState;
+        hostConversations: import("../host-conversations/host-conversations.slice.js").HostConversationsState;
     } & import("../../../../store/root-state.js").ChatHostReadSlices) => ContextStateEntry | null) & {
         clearCache: () => void;
         resultsCount: () => number;
@@ -699,6 +709,7 @@ export declare const selectLastTrimSummary: (conversationId: string) => ((state:
     agentSettings: import("../../agent-settings/types.js").AgentSettingsState;
     conversationAttachments: import("../../../connectors/attachments.slice.js").AttachmentsSliceState;
     chatHost: import("../../../../store/chat-host.slice.js").ChatHostState;
+    hostConversations: import("../host-conversations/host-conversations.slice.js").HostConversationsState;
 } & import("../../../../store/root-state.js").ChatHostReadSlices) => import("./context-state.slice.js").TrimSummary | null) & {
     clearCache: () => void;
     resultsCount: () => number;
@@ -754,6 +765,7 @@ export declare const selectLastTrimSummary: (conversationId: string) => ((state:
         agentSettings: import("../../agent-settings/types.js").AgentSettingsState;
         conversationAttachments: import("../../../connectors/attachments.slice.js").AttachmentsSliceState;
         chatHost: import("../../../../store/chat-host.slice.js").ChatHostState;
+        hostConversations: import("../host-conversations/host-conversations.slice.js").HostConversationsState;
     } & import("../../../../store/root-state.js").ChatHostReadSlices) => ContextStateEntry | null) & {
         clearCache: () => void;
         resultsCount: () => number;
@@ -826,6 +838,7 @@ export declare const selectLastRawUsage: (conversationId: string) => ((state: {
     agentSettings: import("../../agent-settings/types.js").AgentSettingsState;
     conversationAttachments: import("../../../connectors/attachments.slice.js").AttachmentsSliceState;
     chatHost: import("../../../../store/chat-host.slice.js").ChatHostState;
+    hostConversations: import("../host-conversations/host-conversations.slice.js").HostConversationsState;
 } & import("../../../../store/root-state.js").ChatHostReadSlices) => Record<string, unknown> | null) & {
     clearCache: () => void;
     resultsCount: () => number;
@@ -881,6 +894,7 @@ export declare const selectLastRawUsage: (conversationId: string) => ((state: {
         agentSettings: import("../../agent-settings/types.js").AgentSettingsState;
         conversationAttachments: import("../../../connectors/attachments.slice.js").AttachmentsSliceState;
         chatHost: import("../../../../store/chat-host.slice.js").ChatHostState;
+        hostConversations: import("../host-conversations/host-conversations.slice.js").HostConversationsState;
     } & import("../../../../store/root-state.js").ChatHostReadSlices) => ContextStateEntry | null) & {
         clearCache: () => void;
         resultsCount: () => number;

package/dist/agents/redux/execution-system/conversations/conversations.selectors.d.ts

@@ -49,6 +49,7 @@ export declare const selectConversationIdsByAgent: ((state: {
     agentSettings: import("../../agent-settings/types.js").AgentSettingsState;
     conversationAttachments: import("../../../connectors/attachments.slice.js").AttachmentsSliceState;
     chatHost: import("../../../../store/chat-host.slice.js").ChatHostState;
+    hostConversations: import("../host-conversations/host-conversations.slice.js").HostConversationsState;
 } & import("../../../../store/root-state.js").ChatHostReadSlices) => Record<string, string[]>) & {
     clearCache: () => void;
     resultsCount: () => number;
@@ -113,6 +114,7 @@ export declare const selectInstancesByAgent: (agentId: string) => ((state: {
     agentSettings: import("../../agent-settings/types.js").AgentSettingsState;
     conversationAttachments: import("../../../connectors/attachments.slice.js").AttachmentsSliceState;
     chatHost: import("../../../../store/chat-host.slice.js").ChatHostState;
+    hostConversations: import("../host-conversations/host-conversations.slice.js").HostConversationsState;
 } & import("../../../../store/root-state.js").ChatHostReadSlices) => ExecutionInstance[]) & {
     clearCache: () => void;
     resultsCount: () => number;
@@ -182,6 +184,7 @@ export declare const selectConversationSurfaceOwnsOutput: ((state: {
     agentSettings: import("../../agent-settings/types.js").AgentSettingsState;
     conversationAttachments: import("../../../connectors/attachments.slice.js").AttachmentsSliceState;
     chatHost: import("../../../../store/chat-host.slice.js").ChatHostState;
+    hostConversations: import("../host-conversations/host-conversations.slice.js").HostConversationsState;
 } & import("../../../../store/root-state.js").ChatHostReadSlices, conversationId: string | null | undefined) => boolean) & {
     clearCache: () => void;
     resultsCount: () => number;
@@ -247,6 +250,7 @@ export declare const selectRunningInstances: ((state: {
     agentSettings: import("../../agent-settings/types.js").AgentSettingsState;
     conversationAttachments: import("../../../connectors/attachments.slice.js").AttachmentsSliceState;
     chatHost: import("../../../../store/chat-host.slice.js").ChatHostState;
+    hostConversations: import("../host-conversations/host-conversations.slice.js").HostConversationsState;
 } & import("../../../../store/root-state.js").ChatHostReadSlices) => ExecutionInstance[]) & {
     clearCache: () => void;
     resultsCount: () => number;
@@ -340,6 +344,7 @@ export declare const selectConversationScopeIds: (conversationId: string) => ((s
     agentSettings: import("../../agent-settings/types.js").AgentSettingsState;
     conversationAttachments: import("../../../connectors/attachments.slice.js").AttachmentsSliceState;
     chatHost: import("../../../../store/chat-host.slice.js").ChatHostState;
+    hostConversations: import("../host-conversations/host-conversations.slice.js").HostConversationsState;
 } & import("../../../../store/root-state.js").ChatHostReadSlices) => {
     organizationId: string | null;
     projectId: string | null;

package/dist/agents/redux/execution-system/host-conversations/conversation-abilities.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The conversation's abilities, provided ONCE by `AgentConversationColumn` (HOST-OWNED-SOURCE-PLAN
+ * §2.3). Every database-backed control reads `useConversationAbilities()` and is ABSENT when the
+ * ability is false — never a dead button. Outside a column: a database-backed conversation.
+ */
+import { type ReactNode } from "react";
+import { type ConversationAbilities } from "./host-conversations.selectors.js";
+export declare function ConversationAbilitiesProvider({ conversationId, children, }: {
+    conversationId: string;
+    children?: ReactNode;
+}): import("react").JSX.Element;
+export declare function useConversationAbilities(): ConversationAbilities;

package/dist/agents/redux/execution-system/host-conversations/conversation-abilities.js

@@ -0,0 +1,25 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { createContext, useContext } from "react";
+import { useAppSelector } from "../../../../store/hooks.js";
+import {
+  FULL_CONVERSATION_ABILITIES,
+  selectConversationAbilities
+} from "./host-conversations.selectors.js";
+const ConversationAbilitiesContext = createContext(
+  FULL_CONVERSATION_ABILITIES
+);
+function ConversationAbilitiesProvider({
+  conversationId,
+  children
+}) {
+  const abilities = useAppSelector(selectConversationAbilities(conversationId));
+  return /* @__PURE__ */ jsx(ConversationAbilitiesContext.Provider, { value: abilities, children });
+}
+function useConversationAbilities() {
+  return useContext(ConversationAbilitiesContext);
+}
+export {
+  ConversationAbilitiesProvider,
+  useConversationAbilities
+};

package/dist/agents/redux/execution-system/host-conversations/host-conversation.thunks.d.ts

@@ -0,0 +1,53 @@
+/**
+ * The engine half of a host-owned conversation (HOST-OWNED-SOURCE-PLAN §2.3, P28b).
+ *
+ * ONE store, ONE stream parser, ONE renderer serve both kinds of conversation:
+ *  - binding creates the same instance every conversation has (`createInstanceFull`, endpoint
+ *    mode "host"), registers the source, and hydrates its history through `hydrateMessages`;
+ *  - every live turn — sent here or started by the host — runs through `processStream`
+ *    unchanged (typed events are wrapped as the platform's NDJSON `Response`);
+ *  - message ids are minted by the client (no `record_reserved` ever arrives), and whether the
+ *    conversation is SAVED comes from `source.persistence`, never from that.
+ *
+ * Nothing here reaches `host/db` or the server port.
+ */
+import type { ChatDispatch, ChatRootState } from "../../../../store/root-state.js";
+import { type ChatMessageSource, type HostMessageRecord, type HostToolCall, type HostTurn } from "../../../../host/source.js";
+import { type CxToolCallRecord } from "../observability/observability.slice.js";
+import { type MessageRecord } from "../messages/messages.slice.js";
+type Dispatch = ChatDispatch;
+type GetState = () => ChatRootState;
+export declare function hostRecordToMessageRecord(conversationId: string, record: HostMessageRecord): MessageRecord;
+/** A host's tool call as the record a saved `tool_call` part's card reads (no database row). */
+export declare function hostToolCallToRecord(conversationId: string, call: HostToolCall): CxToolCallRecord;
+/** Read (or re-read) the host's history into the store. The host's sentence on failure. */
+export declare function loadHostHistory(dispatch: Dispatch, getState: GetState, conversationId: string, options?: {
+    older?: boolean;
+}): Promise<void>;
+/**
+ * Run one host turn through the ONE stream parser. `user` is the person's message when the host
+ * started the turn; a turn this tab sent already shows it (no second copy).
+ */
+export declare function runHostTurn(dispatch: Dispatch, getState: GetState, conversationId: string, turn: HostTurn): Promise<void>;
+/**
+ * The person's send on a host conversation. Resolves when the host accepted it (the turn then
+ * streams, here or through `sink.turn`); rejects with the host's refusal so the caller puts the
+ * words back in the box.
+ */
+export declare function sendToHost(dispatch: Dispatch, getState: GetState, conversationId: string, text: string, mode: "send" | "queue" | "steer"): Promise<void>;
+/** Stop: the host ends its run; our read of the turn ends now either way. */
+export declare function stopHostTurn(conversationId: string): Promise<void>;
+export declare function answerHostAsk(conversationId: string, askId: string, value: unknown): Promise<void>;
+/**
+ * Bind a conversation to a host-owned source: the instance, the plain-data entry, the
+ * subscription, and the first history read. Returns the unbind.
+ */
+export declare function bindHostConversation(dispatch: Dispatch, getState: GetState, args: {
+    conversationId: string;
+    source: ChatMessageSource;
+    database: boolean;
+    surfaceKey?: string;
+}): () => void;
+/** For thunks that only hold state: is this conversation hosted (branch first, never reach a db). */
+export declare function hostConversationOf(state: ChatRootState, conversationId: string): import("./host-conversations.slice.js").HostConversationEntry | null;
+export {};

package/dist/agents/redux/execution-system/host-conversations/host-conversation.thunks.js

@@ -0,0 +1,412 @@
+import { v4 as uuidv4 } from "uuid";
+import { mintClientTempId } from "@ai-matrx/kit/ids";
+import {
+  hostTurnResponse
+} from "../../../../host/source.js";
+import { upsertToolCall } from "../observability/observability.slice.js";
+import { createInstanceFull } from "../create-instance-full.js";
+import {
+  addOptimisticUserMessage,
+  hydrateMessages,
+  prependMessages,
+  removeMessage,
+  reserveMessage,
+  setMessagesHydrationFailure,
+  updateMessageRecord,
+  setOlderLoading
+} from "../messages/messages.slice.js";
+import { selectNextMessagePosition } from "../messages/messages.selectors.js";
+import { createRequest, setRequestStatus } from "../active-requests/active-requests.slice.js";
+import { setInstanceStatus } from "../conversations/conversations.slice.js";
+import { processStream } from "../thunks/process-stream.js";
+import {
+  registerAbortController,
+  unregisterAbortController
+} from "../thunks/abort-registry.js";
+import {
+  hostConversationBound,
+  hostConversationHeld,
+  hostConversationUnavailable,
+  hostConversationUnbound
+} from "./host-conversations.slice.js";
+import { getHostSource, registerHostSource, unregisterHostSource } from "./source-registry.js";
+import { selectHostConversation } from "./host-conversations.selectors.js";
+const localEcho = /* @__PURE__ */ new Map();
+const liveTurn = /* @__PURE__ */ new Map();
+function hostRecordToMessageRecord(conversationId, record) {
+  return {
+    id: record.id,
+    conversationId,
+    agentId: null,
+    role: record.role,
+    content: record.content,
+    contentHistory: null,
+    userContent: null,
+    position: record.position,
+    source: "host",
+    status: "active",
+    isVisibleToModel: true,
+    isVisibleToUser: true,
+    metadata: {},
+    createdAt: record.createdAt,
+    deletedAt: null,
+    error: record.error ? { type: record.error.code ?? "host_error", message: record.error.message } : null
+  };
+}
+function hostToolCallToRecord(conversationId, call) {
+  const at = (/* @__PURE__ */ new Date(0)).toISOString();
+  return {
+    id: `host-tool-${conversationId}-${call.callId}`,
+    conversationId,
+    userRequestId: null,
+    messageId: call.messageId ?? null,
+    userId: "",
+    callId: call.callId,
+    toolName: call.name,
+    toolNameAsCalled: call.displayName ?? null,
+    toolType: "host",
+    iteration: 0,
+    status: call.status,
+    success: call.status === "completed" && !call.isError,
+    isError: call.isError,
+    errorType: call.isError ? "tool_error" : null,
+    errorMessage: call.isError ? call.output : null,
+    arguments: call.arguments,
+    output: call.isError ? null : call.output,
+    outputChars: call.output?.length ?? 0,
+    outputPreview: null,
+    outputType: null,
+    inputTokens: null,
+    outputTokens: null,
+    totalTokens: null,
+    costUsd: null,
+    durationMs: 0,
+    startedAt: at,
+    completedAt: at,
+    parentCallId: null,
+    retryCount: null,
+    persistKey: null,
+    filePath: null,
+    executionEvents: call.displayName ? [{ event: "tool_started", call_id: call.callId, tool_name: call.name, data: { display_name: call.displayName } }] : null,
+    metadata: {},
+    createdAt: at,
+    deletedAt: null
+  };
+}
+function applyHistory(dispatch, conversationId, page, older) {
+  const records = page.records.map((r) => hostRecordToMessageRecord(conversationId, r));
+  const oldestPosition = records.reduce(
+    (min, r) => min === null || r.position < min ? r.position : min,
+    null
+  );
+  const pagination = { oldestPosition, hasMoreOlder: page.hasMoreOlder };
+  for (const call of page.toolCalls ?? []) {
+    dispatch(upsertToolCall(hostToolCallToRecord(conversationId, call)));
+  }
+  if (older) dispatch(prependMessages({ conversationId, messages: records, pagination }));
+  else dispatch(hydrateMessages({ conversationId, messages: records, pagination }));
+  dispatch(hostConversationUnavailable({ conversationId, reason: page.unavailable ?? null }));
+  dispatch(
+    setMessagesHydrationFailure({
+      conversationId,
+      failure: page.unavailable && records.length === 0 ? page.unavailable : null
+    })
+  );
+}
+async function loadHostHistory(dispatch, getState, conversationId, options = {}) {
+  const source = getHostSource(conversationId);
+  if (!source) return;
+  const entry = getState().messages.byConversationId[conversationId];
+  if (options.older) {
+    if (!entry?.hasMoreOlder || entry.isLoadingOlder) return;
+    dispatch(setOlderLoading({ conversationId, loading: true }));
+  }
+  try {
+    const page = await source.load(
+      conversationId,
+      options.older ? { before: entry?.oldestPosition ?? null } : void 0
+    );
+    if (getHostSource(conversationId) !== source) return;
+    applyHistory(dispatch, conversationId, page, Boolean(options.older));
+  } catch (error) {
+    const reason = error instanceof Error && error.message ? error.message : "This chat's history could not be read.";
+    dispatch(setMessagesHydrationFailure({ conversationId, failure: reason }));
+    dispatch(hostConversationUnavailable({ conversationId, reason }));
+  } finally {
+    if (options.older) dispatch(setOlderLoading({ conversationId, loading: false }));
+  }
+}
+const DROPPED_EVENTS = /* @__PURE__ */ new Set(["record_reserved", "record_update"]);
+const DROPPED_TABLES = /* @__PURE__ */ new Set(["message", "cx_message", "conversation", "cx_conversation"]);
+function hostTurnBody(response, signal) {
+  const body = response.body;
+  if (!body) return response;
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  const encoder = new TextEncoder();
+  let carry = "";
+  const keep = (line) => {
+    if (!line.trim()) return false;
+    try {
+      const frame = JSON.parse(line);
+      return !(typeof frame.event === "string" && DROPPED_EVENTS.has(frame.event) && typeof frame.data?.table === "string" && DROPPED_TABLES.has(frame.data.table));
+    } catch {
+      return true;
+    }
+  };
+  const stream = new ReadableStream({
+    start(controller) {
+      signal.addEventListener("abort", () => {
+        try {
+          controller.close();
+        } catch {
+        }
+        void reader.cancel().catch(() => {
+        });
+      });
+    },
+    async pull(controller) {
+      for (; ; ) {
+        if (signal.aborted) return;
+        let chunk;
+        try {
+          chunk = await reader.read();
+        } catch (error) {
+          if (!signal.aborted) controller.error(error);
+          return;
+        }
+        if (signal.aborted) return;
+        if (chunk.done) {
+          if (keep(carry)) controller.enqueue(encoder.encode(`${carry}
+`));
+          carry = "";
+          controller.close();
+          return;
+        }
+        const lines = (carry + decoder.decode(chunk.value, { stream: true })).split("\n");
+        carry = lines.pop() ?? "";
+        const kept = lines.filter(keep);
+        if (kept.length > 0) {
+          controller.enqueue(encoder.encode(`${kept.join("\n")}
+`));
+          return;
+        }
+      }
+    },
+    cancel() {
+      void reader.cancel().catch(() => {
+      });
+    }
+  });
+  return new Response(stream, { status: response.status, headers: response.headers });
+}
+async function runHostTurn(dispatch, getState, conversationId, turn) {
+  const { requestId } = turn;
+  let userMessageClientTempId;
+  const echoes = localEcho.get(conversationId) ?? 0;
+  if (echoes > 0) {
+    if (echoes === 1) localEcho.delete(conversationId);
+    else localEcho.set(conversationId, echoes - 1);
+  } else if (turn.user && turn.user.length > 0) {
+    userMessageClientTempId = addUserMessage(dispatch, getState, conversationId, turn.user, requestId);
+    settleUserMessage(dispatch, conversationId, userMessageClientTempId);
+  }
+  const controller = new AbortController();
+  liveTurn.set(conversationId, { requestId, controller });
+  registerAbortController(conversationId, controller);
+  dispatch(createRequest({ requestId, conversationId }));
+  dispatch(
+    reserveMessage({
+      conversationId,
+      messageId: mintClientTempId("assistant", requestId),
+      role: "assistant",
+      position: selectNextMessagePosition(conversationId)(getState()),
+      requestId,
+      streamSlotStart: 0
+    })
+  );
+  dispatch(setInstanceStatus({ conversationId, status: "running" }));
+  dispatch(setInstanceStatus({ conversationId, status: "streaming" }));
+  dispatch(setRequestStatus({ requestId, status: "streaming" }));
+  try {
+    await processStream({
+      requestId,
+      conversationId,
+      response: hostTurnBody(hostTurnResponse(turn), controller.signal),
+      submitAt: performance.now(),
+      conversationIdAt: null,
+      dispatch,
+      getState,
+      userMessageClientTempId,
+      // The host's events may name its own conversation id (a CLI session id); everything
+      // lands on the bound conversation.
+      forceLocalConversationId: true
+    });
+  } catch (error) {
+    dispatch(
+      setRequestStatus({
+        requestId,
+        status: "error",
+        error: {
+          error_type: "client_error",
+          message: error instanceof Error ? error.message : String(error)
+        }
+      })
+    );
+    dispatch(setInstanceStatus({ conversationId, status: "error" }));
+  } finally {
+    if (liveTurn.get(conversationId)?.controller === controller) liveTurn.delete(conversationId);
+    unregisterAbortController(conversationId, controller);
+    if (controller.signal.aborted) {
+      dispatch(setInstanceStatus({ conversationId, status: "cancelled" }));
+    }
+  }
+}
+function dropLastOptimisticUser(dispatch, getState, conversationId, text) {
+  const entry = getState().messages.byConversationId[conversationId];
+  if (!entry) return;
+  for (let i = entry.orderedIds.length - 1; i >= 0; i -= 1) {
+    const record = entry.byId[entry.orderedIds[i]];
+    if (record?.role !== "user" || record._clientStatus !== "pending") continue;
+    const parts = record.content;
+    if (Array.isArray(parts) && parts.some((p) => p?.type === "text" && p.text === text)) {
+      dispatch(removeMessage({ conversationId, messageId: record.id }));
+    }
+    return;
+  }
+}
+function addUserMessage(dispatch, getState, conversationId, content, requestId) {
+  const clientTempId = mintClientTempId("user", uuidv4());
+  dispatch(
+    addOptimisticUserMessage({
+      conversationId,
+      clientTempId,
+      content,
+      position: selectNextMessagePosition(conversationId)(getState()),
+      ...requestId ? { requestId } : {}
+    })
+  );
+  return clientTempId;
+}
+async function sendToHost(dispatch, getState, conversationId, text, mode) {
+  const source = getHostSource(conversationId);
+  if (!source?.send) throw new Error("This chat is read-only here.");
+  const controller = new AbortController();
+  const shown = mode === "send";
+  let shownId = null;
+  if (shown) {
+    shownId = addUserMessage(dispatch, getState, conversationId, [{ type: "text", text }], void 0);
+    localEcho.set(conversationId, (localEcho.get(conversationId) ?? 0) + 1);
+  }
+  let turn;
+  try {
+    turn = await source.send({ conversationId, text, mode }, controller.signal);
+  } catch (error) {
+    if (shown) {
+      const left = (localEcho.get(conversationId) ?? 1) - 1;
+      if (left > 0) localEcho.set(conversationId, left);
+      else localEcho.delete(conversationId);
+      dropLastOptimisticUser(dispatch, getState, conversationId, text);
+    }
+    throw error;
+  }
+  if (shownId) settleUserMessage(dispatch, conversationId, shownId);
+  if (turn) await runHostTurn(dispatch, getState, conversationId, turn);
+}
+function settleUserMessage(dispatch, conversationId, messageId) {
+  dispatch(
+    updateMessageRecord({ conversationId, messageId, patch: { _clientStatus: "complete" } })
+  );
+}
+async function stopHostTurn(conversationId) {
+  const source = getHostSource(conversationId);
+  const live = liveTurn.get(conversationId);
+  try {
+    await source?.stop?.(conversationId, live?.requestId ?? null);
+  } finally {
+    live?.controller.abort();
+  }
+}
+async function answerHostAsk(conversationId, askId, value) {
+  const source = getHostSource(conversationId);
+  if (!source?.answer) throw new Error("Answers are not taken here.");
+  await source.answer(conversationId, askId, value);
+}
+function bindHostConversation(dispatch, getState, args) {
+  const { conversationId, source, database, surfaceKey } = args;
+  registerHostSource(conversationId, source);
+  if (!getState().conversations.byConversationId[conversationId]) {
+    dispatch(
+      createInstanceFull({
+        conversationId,
+        agentId: "",
+        agentType: "user",
+        origin: "manual",
+        ...surfaceKey ? { surfaceKey } : {},
+        overrides: {},
+        inputCapabilities: { base: {} },
+        variables: {},
+        userInput: {},
+        clientTools: {},
+        uiState: {},
+        messages: { apiEndpointMode: "host" }
+      })
+    );
+  }
+  dispatch(
+    hostConversationBound({
+      conversationId,
+      entry: {
+        sourceId: source.id,
+        whileBusy: source.whileBusy,
+        persistence: source.persistence,
+        held: null,
+        unavailable: null,
+        database,
+        canSend: typeof source.send === "function",
+        canStop: typeof source.stop === "function",
+        canRetry: typeof source.retry === "function",
+        canAnswer: typeof source.answer === "function",
+        hasConversationList: Boolean(source.conversations)
+      }
+    })
+  );
+  const unsubscribe = source.subscribe(conversationId, {
+    turn: (turn) => {
+      if (getHostSource(conversationId) !== source) return;
+      void runHostTurn(dispatch, getState, conversationId, turn);
+    },
+    history: () => {
+      if (getHostSource(conversationId) !== source) return;
+      void loadHostHistory(dispatch, getState, conversationId);
+    },
+    held: (reason) => {
+      if (getHostSource(conversationId) !== source) return;
+      dispatch(hostConversationHeld({ conversationId, reason }));
+    }
+  });
+  void loadHostHistory(dispatch, getState, conversationId);
+  return () => {
+    unsubscribe();
+    if (getHostSource(conversationId) === source) {
+      liveTurn.get(conversationId)?.controller.abort();
+      unregisterHostSource(conversationId, source);
+      dispatch(hostConversationUnbound(conversationId));
+      localEcho.delete(conversationId);
+    }
+  };
+}
+function hostConversationOf(state, conversationId) {
+  return selectHostConversation(conversationId)(state);
+}
+export {
+  answerHostAsk,
+  bindHostConversation,
+  hostConversationOf,
+  hostRecordToMessageRecord,
+  hostToolCallToRecord,
+  loadHostHistory,
+  runHostTurn,
+  sendToHost,
+  stopHostTurn
+};