@ai-matrx/chat 0.6.6 → 0.7.1

package/dist/agents/hooks/message-crud/useMessageActions.js

@@ -1,119 +0,0 @@
-"use client";
-import { useCallback } from "react";
-import { useRouter } from "../../../host/navigation.js";
-import { useAppDispatch } from "../../../store/hooks.js";
-import { editMessage } from "../../redux/execution-system/message-crud/edit-message.thunk.js";
-import { forkConversation } from "../../redux/execution-system/message-crud/fork-conversation.thunk.js";
-import { softDeleteConversation } from "../../redux/execution-system/message-crud/soft-delete-conversation.thunk.js";
-import { launchConversation } from "../../redux/execution-system/thunks/launch-conversation.thunk.js";
-function useMessageActions({
-  conversationId,
-  messageId,
-  position,
-  surfaceKey,
-  buildInvocationForResubmit,
-  onNavigateToFork
-}) {
-  const dispatch = useAppDispatch();
-  const router = useRouter();
-  const saveFullContent = useCallback(
-    async (newContent) => {
-      await dispatch(
-        editMessage({
-          conversationId,
-          messageId,
-          newContent
-        })
-      ).unwrap();
-    },
-    [conversationId, messageId, dispatch]
-  );
-  const forkAtThisMessage = useCallback(async () => {
-    if (typeof position !== "number") {
-      console.warn(
-        "[useMessageActions] forkAtThisMessage called without `position` \u2014 skipping. Pass the message position when constructing the hook."
-      );
-      return null;
-    }
-    const result = await dispatch(
-      forkConversation({
-        conversationId,
-        atPosition: position,
-        surfaceKey
-      })
-    ).unwrap();
-    if (onNavigateToFork) {
-      onNavigateToFork(result.conversationId);
-    } else {
-      router.push(`/agents/runs/${result.conversationId}`);
-    }
-    return result.conversationId;
-  }, [
-    conversationId,
-    position,
-    surfaceKey,
-    dispatch,
-    onNavigateToFork,
-    router
-  ]);
-  const editAndResubmit = useCallback(
-    async (newUserInput) => {
-      if (typeof position !== "number") {
-        console.warn(
-          "[useMessageActions] editAndResubmit called without `position` \u2014 skipping."
-        );
-        return null;
-      }
-      const forkPosition = Math.max(0, position - 1);
-      const fork = await dispatch(
-        forkConversation({
-          conversationId,
-          atPosition: forkPosition,
-          surfaceKey
-        })
-      ).unwrap();
-      if (buildInvocationForResubmit) {
-        const invocation = buildInvocationForResubmit(fork.conversationId);
-        const withInput = {
-          ...invocation,
-          identity: {
-            ...invocation.identity,
-            conversationId: fork.conversationId
-          },
-          inputs: invocation.inputs ? { ...invocation.inputs, userInput: newUserInput } : { userInput: newUserInput }
-        };
-        await dispatch(launchConversation(withInput)).unwrap();
-      }
-      if (onNavigateToFork) {
-        onNavigateToFork(fork.conversationId);
-      } else {
-        router.push(`/agents/runs/${fork.conversationId}`);
-      }
-      return fork.conversationId;
-    },
-    [
-      conversationId,
-      position,
-      surfaceKey,
-      dispatch,
-      buildInvocationForResubmit,
-      onNavigateToFork,
-      router
-    ]
-  );
-  const deleteConversation = useCallback(async () => {
-    const result = await dispatch(
-      softDeleteConversation({ conversationId })
-    ).unwrap();
-    return result.deleted;
-  }, [conversationId, dispatch]);
-  return {
-    saveFullContent,
-    forkAtThisMessage,
-    editAndResubmit,
-    deleteConversation
-  };
-}
-export {
-  useMessageActions
-};

package/dist/agents/hooks/useConversationPendingCalls.d.ts

@@ -1,30 +0,0 @@
-/**
- * useConversationPendingCalls — surface durable client-delegated tool prompts.
- *
- * Mount this hook in any component that renders a conversation. It fetches
- * the list of `cx_tool_call` rows the server has persisted in
- * `status='delegated'` for this conversation and exposes them so the UI can
- * render pending prompts exactly as if the original SSE had just delivered
- * the `tool_delegated` events live.
- *
- * Use case: the user closed their browser during a tool prompt and reopened
- * the conversation the next day. The server preserved the call; this hook
- * surfaces it.
- *
- * Intentionally stateless — no Redux slice is introduced. Callers keep the
- * list in local state and re-run the fetch when they need to.
- */
-import { type PendingCallSummary } from "../api/fetch-pending-calls.js";
-export interface UseConversationPendingCallsResult {
-    /** All client-delegated calls currently awaiting the user's response. */
-    pendingCalls: PendingCallSummary[];
-    /** True from the moment the hook starts fetching until the first response. */
-    isLoading: boolean;
-    /** Re-fetch from the server (e.g. after POSTing a tool_result). */
-    refresh: () => Promise<PendingCallSummary[]>;
-}
-export interface UseConversationPendingCallsOptions {
-    /** Skip the automatic fetch-on-mount. Default: false. */
-    skip?: boolean;
-}
-export declare function useConversationPendingCalls(conversationId: string | null | undefined, options?: UseConversationPendingCallsOptions): UseConversationPendingCallsResult;

package/dist/agents/hooks/useConversationPendingCalls.js

@@ -1,42 +0,0 @@
-import { useCallback, useEffect, useRef, useState } from "react";
-import { useAppDispatch } from "../../store/hooks.js";
-import {
-  fetchConversationPendingCalls
-} from "../api/fetch-pending-calls.js";
-function useConversationPendingCalls(conversationId, options = {}) {
-  const { skip = false } = options;
-  const dispatch = useAppDispatch();
-  const [pendingCalls, setPendingCalls] = useState([]);
-  const [isLoading, setIsLoading] = useState(false);
-  const latestRequestRef = useRef(0);
-  const refresh = useCallback(async () => {
-    if (!conversationId) return [];
-    const tick = ++latestRequestRef.current;
-    setIsLoading(true);
-    try {
-      const calls = await dispatch(
-        fetchConversationPendingCalls(conversationId)
-      );
-      if (tick === latestRequestRef.current) {
-        setPendingCalls(calls);
-      }
-      return calls;
-    } finally {
-      if (tick === latestRequestRef.current) {
-        setIsLoading(false);
-      }
-    }
-  }, [conversationId, dispatch]);
-  useEffect(() => {
-    if (skip) return;
-    if (!conversationId) {
-      setPendingCalls([]);
-      return;
-    }
-    void refresh();
-  }, [conversationId, refresh, skip]);
-  return { pendingCalls, isLoading, refresh };
-}
-export {
-  useConversationPendingCalls
-};

package/dist/agents/model-registry/model-classes.d.ts

@@ -1 +0,0 @@
-export * from "@ai-matrx/agents/models";

package/dist/agents/model-registry/model-classes.js

@@ -1 +0,0 @@
-export * from "@ai-matrx/agents/models";

package/dist/agents/redux/conversation-history/index.d.ts

@@ -1,18 +0,0 @@
-/**
- * conversation-history — reusable, scope-keyed conversation sidebar slice.
- *
- * Ships alongside `conversation-list`:
- * - `conversation-list` owns per-agent RPC caches (used by the Runner) and
- *   the global user list.
- * - `conversation-history` owns feature-scoped, multi-agent, paginated
- *   views (used by the /code workspace and future consumers).
- *
- * Pattern:
- *   dispatch(fetchConversationHistory({ scopeId, agentIds, replace: true }))
- *   dispatch(fetchConversationHistory({ scopeId, replace: false }))  // load more
- *   useAppSelector(makeSelectGroupedByDate(scopeId))
- */
-export * from "./slice.js";
-export * from "./selectors.js";
-export * from "./thunks.js";
-export * from "./types.js";

package/dist/agents/redux/conversation-history/index.js

@@ -1,4 +0,0 @@
-export * from "./slice.js";
-export * from "./selectors.js";
-export * from "./thunks.js";
-export * from "./types.js";

package/dist/agents/redux/execution-system/instance-variable-values/instance-variable-values.thunks.d.ts

@@ -1,38 +0,0 @@
-/**
- * Instance Variable Values — Undo-aware thunks
- *
- * Wraps setUserVariableValue / setUserVariableValues so every variable edit
- * also pushes a combined { text, userValues } snapshot to the user-input
- * undo stack. This keeps both fields restorable together on Cmd+Z.
- *
- * Components should import setVariableValueWithUndo / setVariableValuesWithUndo
- * from here instead of calling the raw slice actions directly.
- */
-import type { ChatRootState, ChatDispatch } from "../../../../store/root-state.js";
-export declare const setVariableValueWithUndo: import("@reduxjs/toolkit").AsyncThunk<void, {
-    conversationId: string;
-    name: string;
-    value: unknown;
-}, {
-    extra?: unknown;
-    rejectValue?: unknown;
-    serializedErrorType?: unknown;
-    pendingMeta?: unknown;
-    fulfilledMeta?: unknown;
-    rejectedMeta?: unknown;
-    state: ChatRootState;
-    dispatch: ChatDispatch;
-}>;
-export declare const setVariableValuesWithUndo: import("@reduxjs/toolkit").AsyncThunk<void, {
-    conversationId: string;
-    values: Record<string, unknown>;
-}, {
-    extra?: unknown;
-    rejectValue?: unknown;
-    serializedErrorType?: unknown;
-    pendingMeta?: unknown;
-    fulfilledMeta?: unknown;
-    rejectedMeta?: unknown;
-    state: ChatRootState;
-    dispatch: ChatDispatch;
-}>;

package/dist/agents/redux/execution-system/instance-variable-values/instance-variable-values.thunks.js

@@ -1,42 +0,0 @@
-import { createAsyncThunk } from "@reduxjs/toolkit";
-import {
-  setUserVariableValue,
-  setUserVariableValues
-} from "./instance-variable-values.slice.js";
-import { pushInputSnapshot } from "../instance-user-input/instance-user-input.slice.js";
-const setVariableValueWithUndo = createAsyncThunk(
-  "instanceVariableValues/setValueWithUndo",
-  async ({ conversationId, name, value }, { getState, dispatch }) => {
-    const state = getState();
-    const currentText = state.instanceUserInput.byConversationId[conversationId]?.text ?? "";
-    const currentValues = state.instanceVariableValues.byConversationId[conversationId]?.userValues ?? {};
-    dispatch(
-      pushInputSnapshot({
-        conversationId,
-        text: currentText,
-        userValues: currentValues
-      })
-    );
-    dispatch(setUserVariableValue({ conversationId, name, value }));
-  }
-);
-const setVariableValuesWithUndo = createAsyncThunk(
-  "instanceVariableValues/setValuesWithUndo",
-  async ({ conversationId, values }, { getState, dispatch }) => {
-    const state = getState();
-    const currentText = state.instanceUserInput.byConversationId[conversationId]?.text ?? "";
-    const currentValues = state.instanceVariableValues.byConversationId[conversationId]?.userValues ?? {};
-    dispatch(
-      pushInputSnapshot({
-        conversationId,
-        text: currentText,
-        userValues: currentValues
-      })
-    );
-    dispatch(setUserVariableValues({ conversationId, values }));
-  }
-);
-export {
-  setVariableValueWithUndo,
-  setVariableValuesWithUndo
-};

package/dist/agents/redux/execution-system/message-crud/server/compact-turns.thunk.d.ts

@@ -1,58 +0,0 @@
-/**
- * compactTurns — compact one or more **whole turns** at once.
- *
- * Endpoint: `POST /cx/conversations/{id}/turns/compact`.
- *
- * A turn = one `role: "user"` message → the next `role: "user"` message
- * (exclusive). The server resolves the turn boundary from the live
- * conversation, then delegates to `/messages/replace` (`mode: "user"`)
- * or `/messages/hide` (`mode: "system"`) under the hood.
- *
- * The caller supplies the summary content directly — this endpoint does
- * NOT run an LLM. Use whatever summarization agent you like upstream, or
- * invoke a chat endpoint separately and pass the result here.
- */
-import type { ChatDispatch, ChatRootState } from "../../../../../store/root-state.js";
-interface CompactTurnsArgs {
-    conversationId: string;
-    /** Inclusive start — must be a live `role: "user"` message id. */
-    fromUserMessageId: string;
-    /**
-     * Exclusive end — also a `role: "user"` message id. The compaction
-     * range ends BEFORE this message. Omit to compact all the way to the
-     * end of the conversation.
-     */
-    toUserMessageId?: string;
-    summaryContent: Array<{
-        [key: string]: unknown;
-    }>;
-    /**
-     * Default `"user"` — soft-delete + insert a visible summary (same
-     * semantics as `replaceMessages`). `"system"` hides from the model
-     * only (no summary row inserted, user view unchanged).
-     */
-    mode?: "user" | "system";
-    /** Default true. Keeps tool_use ↔ tool_result pairs adjacent. */
-    cascadeToolPairs?: boolean;
-    /** Arbitrary metadata copied onto the summary row (user mode only). */
-    summaryMetadata?: Record<string, unknown>;
-}
-export declare const compactTurns: import("@reduxjs/toolkit").AsyncThunk<{
-    compaction_group_id: string;
-    summary_message_id: string | null;
-    compacted_message_ids: string[];
-    turn_count: number;
-    position_range: [number, number];
-}, CompactTurnsArgs, {
-    extra?: unknown;
-    serializedErrorType?: unknown;
-    pendingMeta?: unknown;
-    fulfilledMeta?: unknown;
-    rejectedMeta?: unknown;
-    dispatch: ChatDispatch;
-    state: ChatRootState;
-    rejectValue: {
-        message: string;
-    };
-}>;
-export {};

package/dist/agents/redux/execution-system/message-crud/server/compact-turns.thunk.js

@@ -1,50 +0,0 @@
-import { createAsyncThunk } from "@reduxjs/toolkit";
-import { callCompactTurns } from "../../../../../host/server/call-api.js";
-import { loadConversation } from "../../thunks/load-conversation.thunk.js";
-import { markCacheBypass } from "../cache-bypass.slice.js";
-import { invalidateConversationCache } from "../invalidate-conversation-cache.thunk.js";
-const compactTurns = createAsyncThunk(
-  "messages/compactTurnsServer",
-  async ({
-    conversationId,
-    fromUserMessageId,
-    toUserMessageId,
-    summaryContent,
-    mode,
-    cascadeToolPairs,
-    summaryMetadata
-  }, { dispatch, rejectWithValue }) => {
-    const result = await dispatch(
-      callCompactTurns({
-        conversationId,
-        body: {
-          range: {
-            from_user_message_id: fromUserMessageId,
-            to_user_message_id: toUserMessageId ?? null
-          },
-          summary_content: summaryContent,
-          mode: mode ?? "user",
-          cascade_tool_pairs: cascadeToolPairs ?? true,
-          summary_metadata: summaryMetadata ?? null
-        }
-      })
-    );
-    if (result.error) {
-      return rejectWithValue({
-        message: result.error.message ?? `Compact turns failed: HTTP ${result.error.status ?? "unknown"}`
-      });
-    }
-    if (!result.data) {
-      return rejectWithValue({
-        message: "Compact turns returned no payload"
-      });
-    }
-    dispatch(markCacheBypass({ conversationId, conversation: true }));
-    void dispatch(invalidateConversationCache({ conversationId }));
-    void dispatch(loadConversation({ conversationId }));
-    return result.data;
-  }
-);
-export {
-  compactTurns
-};

package/dist/agents/redux/execution-system/message-crud/server/fork-and-run-server.thunk.d.ts

@@ -1,76 +0,0 @@
-/**
- * forkAndRunServer — atomic "fork + new turn" via the streaming server
- * endpoint. Replaces the legacy 3-call pattern (`forkConversation` →
- * `editMessage` → `executeInstance`) used by the "Edit & Resubmit (Fork)"
- * flow in `UserActionBar.tsx`.
- *
- * Endpoint: `POST /ai/conversations/{id}/fork-and-run` (streaming).
- *
- * Stream wire shape:
- *   • FIRST event:   `{ kind: "conversation.forked", new_conversation_id, ... }`
- *     — see `features/agents/types/conversation-stream-events.ts`.
- *   • Subsequent events: identical to `POST /ai/conversations/{id}` —
- *     `record_reserved`, `chunk`, `tool_event`, `end`, ...
- *
- * **WIRE-UP-FIRST, INTEGRATION-LATER:** This thunk captures the new
- * `conversation_id` from the first event, dispatches `loadConversation` after
- * the stream completes to materialize the new conversation in Redux, and
- * exposes per-event callbacks so a caller can drive UI feedback. It does NOT
- * yet plug into `processStream` for live token-by-token rendering into the
- * fork's slice entries. Once we've validated the endpoint end-to-end, the
- * follow-up is to route subsequent events into `processStream` with the new
- * `conversation_id` so the user watches the new turn stream into the fork
- * exactly like a normal continuation. Until then this is honest atomic
- * fork-and-run with a post-completion hydration.
- *
- * Does NOT touch any existing thunk or call site. Opt in per surface.
- */
-import type { ChatDispatch, ChatRootState } from "../../../../../store/root-state.js";
-import { type ApiCallError, type ConversationForkAndRunBody } from "../../../../../host/server/call-api.js";
-import type { TypedStreamEvent } from "@ai-matrx/agents/generated/stream-events";
-import { type ConversationForkedEvent } from "../../../../types/conversation-stream-events.js";
-interface ForkAndRunServerArgs {
-    /** Source conversation to fork from. */
-    conversationId: string;
-    /**
-     * Full ForkAndRunRequest body. Caller supplies fork selector
-     * (`from_message_id` + `exclusive`, or `up_to_position`) and the
-     * standard turn payload (`user_input`, `tools`, etc.). Default values are
-     * NOT injected here — pass the body in OpenAPI shape.
-     */
-    body: ConversationForkAndRunBody;
-    /**
-     * Optional surface key. When set, focus jumps to the new conversation
-     * the instant `conversation.forked` arrives — so the user watches the
-     * new turn stream in (post-integration) rather than seeing it land in
-     * the source.
-     */
-    surfaceKey?: string;
-    /** Optional per-event callbacks for UI wiring. */
-    onForked?: (event: ConversationForkedEvent) => void;
-    onStreamEvent?: (event: TypedStreamEvent) => void;
-    onStreamComplete?: (newConversationId: string | null) => void;
-    onStreamError?: (error: ApiCallError) => void;
-    signal?: AbortSignal;
-}
-interface ForkAndRunServerResult {
-    /** The new conversation id, captured from the `conversation.forked` event. */
-    newConversationId: string;
-    sourceConversationId: string;
-    forkedAtPosition: number | null;
-    /** Number of messages copied into the fork from the source. */
-    copiedMessageCount: number;
-}
-export declare const forkAndRunServer: import("@reduxjs/toolkit").AsyncThunk<ForkAndRunServerResult, ForkAndRunServerArgs, {
-    extra?: unknown;
-    serializedErrorType?: unknown;
-    pendingMeta?: unknown;
-    fulfilledMeta?: unknown;
-    rejectedMeta?: unknown;
-    dispatch: ChatDispatch;
-    state: ChatRootState;
-    rejectValue: {
-        message: string;
-    };
-}>;
-export {};

package/dist/agents/redux/execution-system/message-crud/server/fork-and-run-server.thunk.js

@@ -1,101 +0,0 @@
-import { createAsyncThunk } from "@reduxjs/toolkit";
-import {
-  callConversationForkAndRun
-} from "../../../../../host/server/call-api.js";
-import {
-  isConversationForkedEvent
-} from "../../../../types/conversation-stream-events.js";
-import { loadConversation } from "../../thunks/load-conversation.thunk.js";
-import { setFocus } from "../../conversation-focus/conversation-focus.slice.js";
-import { markCacheBypass } from "../cache-bypass.slice.js";
-import { invalidateConversationCache } from "../invalidate-conversation-cache.thunk.js";
-const forkAndRunServer = createAsyncThunk(
-  "conversations/forkAndRunServer",
-  async (args, { dispatch, rejectWithValue }) => {
-    const {
-      conversationId,
-      body,
-      surfaceKey,
-      onForked,
-      onStreamEvent,
-      onStreamComplete,
-      onStreamError,
-      signal
-    } = args;
-    let forkedEvent = null;
-    const result = await dispatch(
-      callConversationForkAndRun({
-        conversationId,
-        body,
-        signal,
-        onStreamEvent: (event) => {
-          if (!forkedEvent && isConversationForkedEvent(event)) {
-            forkedEvent = event;
-            onForked?.(event);
-            if (surfaceKey) {
-              dispatch(
-                setFocus({
-                  surfaceKey,
-                  conversationId: event.new_conversation_id
-                })
-              );
-            }
-            return;
-          }
-          onStreamEvent?.(event);
-        },
-        onStreamComplete: () => {
-          onStreamComplete?.(forkedEvent?.new_conversation_id ?? null);
-        },
-        onStreamError
-      })
-    );
-    if (result.error) {
-      onStreamError?.(result.error);
-      return rejectWithValue({
-        message: result.error.message ?? `fork-and-run failed: HTTP ${result.error.status ?? "unknown"}`
-      });
-    }
-    if (!forkedEvent) {
-      return rejectWithValue({
-        message: "fork-and-run stream completed without emitting a `conversation.forked` event"
-      });
-    }
-    const forked = forkedEvent;
-    try {
-      await dispatch(
-        loadConversation({ conversationId: forked.new_conversation_id })
-      ).unwrap();
-    } catch (err) {
-      console.error(
-        "[forkAndRunServer] loadConversation after stream failed",
-        err
-      );
-      return rejectWithValue({
-        message: `fork-and-run streamed successfully but rehydration failed: ${err instanceof Error ? err.message : String(err)}`
-      });
-    }
-    dispatch(markCacheBypass({ conversationId, conversation: true }));
-    dispatch(
-      markCacheBypass({
-        conversationId: forked.new_conversation_id,
-        conversation: true
-      })
-    );
-    void dispatch(invalidateConversationCache({ conversationId }));
-    void dispatch(
-      invalidateConversationCache({
-        conversationId: forked.new_conversation_id
-      })
-    );
-    return {
-      newConversationId: forked.new_conversation_id,
-      sourceConversationId: forked.source_conversation_id,
-      forkedAtPosition: forked.forked_at_position,
-      copiedMessageCount: forked.message_count
-    };
-  }
-);
-export {
-  forkAndRunServer
-};

package/dist/agents/redux/execution-system/thunks/attach-workflow-run.d.ts

@@ -1,38 +0,0 @@
-/**
- * attachWorkflowRun — rejoin a durable workflow run that nobody is following.
- *
- * ## Why this exists
- *
- * `adoptForeignStream` + `followWorkflowRunStream` cover the run you STARTED:
- * the start response hands you a request row and a run id in the same breath.
- * But a workflow run is durable server work — it outlives the tab that started
- * it. After a refresh (or on a second device, or from a run row in a list) the
- * run is still executing and there is no inline stream left to adopt, so the
- * surface has no `requestId` to follow under and the live view dies. A run that
- * dies on page refresh is the same defect as a spinner (CLAUDE.md § THE
- * FLOATING LAW), so this is the missing half of the pair.
- *
- * It mints a fresh `activeRequests` row for the run and follows the run's SSE
- * feed into it. The feed replays from seq 0 (Last-Event-ID cursor starts unset),
- * so the node lifecycle the surface missed while away arrives on `onEvent` and
- * the stage view rebuilds itself — no bespoke catch-up read.
- *
- * The row is new on purpose: `activeRequests` rows are per-viewer stream
- * accumulators, not identities of the run. The run's identity is its `run_id`.
- */
-import type { ChatThunk } from "../../../../store/root-state.js";
-import { type WorkflowRunWireEvent } from "./follow-workflow-run-stream.js";
-export interface AttachWorkflowRunOptions {
-    /** The durable run to rejoin. */
-    runId: string;
-    /** Caller teardown — abort to stop following. */
-    signal: AbortSignal;
-    /** Fires with the freshly minted ids, before any event is processed. */
-    onAttached?: (ids: {
-        requestId: string;
-        conversationId: string;
-    }) => void;
-    /** Every workflow event (replayed lifecycle first, then live). Must not throw. */
-    onEvent?: (event: WorkflowRunWireEvent) => void;
-}
-export declare function attachWorkflowRun(opts: AttachWorkflowRunOptions): ChatThunk<Promise<void>>;

package/dist/agents/redux/execution-system/thunks/attach-workflow-run.js

@@ -1,25 +0,0 @@
-import { createRequest } from "../active-requests/active-requests.slice.js";
-import { generateConversationId, generateRequestId } from "../utils/ids.js";
-import {
-  followWorkflowRunStream
-} from "./follow-workflow-run-stream.js";
-function attachWorkflowRun(opts) {
-  return async (dispatch) => {
-    const requestId = generateRequestId();
-    const conversationId = generateConversationId();
-    dispatch(createRequest({ requestId, conversationId }));
-    opts.onAttached?.({ requestId, conversationId });
-    await dispatch(
-      followWorkflowRunStream({
-        runId: opts.runId,
-        requestId,
-        conversationId,
-        signal: opts.signal,
-        onEvent: opts.onEvent
-      })
-    );
-  };
-}
-export {
-  attachWorkflowRun
-};