@nextclaw/agent-chat 0.1.1

package/dist/index.js

@@ -0,0 +1,990 @@
+// src/services/agent-chat-controller.ts
+import { BehaviorSubject, Subject } from "rxjs";
+import { v4 as v42 } from "uuid";
+
+// src/types/agent.ts
+var ToolInvocationStatus = /* @__PURE__ */ ((ToolInvocationStatus2) => {
+  ToolInvocationStatus2["CALL"] = "call";
+  ToolInvocationStatus2["RESULT"] = "result";
+  ToolInvocationStatus2["PARTIAL_CALL"] = "partial-call";
+  ToolInvocationStatus2["ERROR"] = "error";
+  ToolInvocationStatus2["CANCELLED"] = "cancelled";
+  return ToolInvocationStatus2;
+})(ToolInvocationStatus || {});
+
+// src/types/agent-event.ts
+var EventType = /* @__PURE__ */ ((EventType2) => {
+  EventType2["TEXT_START"] = "TEXT_START";
+  EventType2["TEXT_DELTA"] = "TEXT_DELTA";
+  EventType2["TEXT_END"] = "TEXT_END";
+  EventType2["TOOL_CALL_START"] = "TOOL_CALL_START";
+  EventType2["TOOL_CALL_ARGS"] = "TOOL_CALL_ARGS";
+  EventType2["TOOL_CALL_ARGS_DELTA"] = "TOOL_CALL_ARGS_DELTA";
+  EventType2["TOOL_CALL_END"] = "TOOL_CALL_END";
+  EventType2["TOOL_CALL_RESULT"] = "TOOL_CALL_RESULT";
+  EventType2["RUN_STARTED"] = "RUN_STARTED";
+  EventType2["RUN_FINISHED"] = "RUN_FINISHED";
+  EventType2["RUN_ERROR"] = "RUN_ERROR";
+  EventType2["RUN_METADATA"] = "RUN_METADATA";
+  EventType2["REASONING_START"] = "REASONING_START";
+  EventType2["REASONING_DELTA"] = "REASONING_DELTA";
+  EventType2["REASONING_END"] = "REASONING_END";
+  return EventType2;
+})(EventType || {});
+
+// src/types/run-lifecycle.ts
+function getStopDisabledReason(run) {
+  if (!run) return null;
+  if (run.remoteStopCapable && run.remoteRunId) return null;
+  if (run.remoteStopCapable) return "__preparing__";
+  return run.remoteStopReason ?? "";
+}
+
+// src/utils/ui-message.ts
+var tryParseJson = (jsonString) => {
+  try {
+    return JSON.parse(jsonString);
+  } catch {
+    return void 0;
+  }
+};
+var toolCallToToolInvocation = (toolCall) => {
+  return {
+    toolCallId: toolCall.id,
+    toolName: toolCall.function.name,
+    args: toolCall.function.arguments,
+    parsedArgs: tryParseJson(toolCall.function.arguments),
+    status: "call" /* CALL */
+  };
+};
+function finalizePendingToolInvocations(messages, options) {
+  const stub = options?.stubResult ?? {
+    error: "tool_call_interrupted",
+    note: "User continued before tool produced a result."
+  };
+  return messages.map((msg) => {
+    if (!msg.parts?.length) return msg;
+    return {
+      ...msg,
+      parts: msg.parts.map((part) => {
+        if (part.type !== "tool-invocation") return part;
+        if (!["call" /* CALL */, "partial-call" /* PARTIAL_CALL */].includes(part.toolInvocation.status)) return part;
+        let parsedArgs;
+        if (typeof part.toolInvocation.args === "string") {
+          try {
+            parsedArgs = JSON.parse(part.toolInvocation.args);
+          } catch {
+            return {
+              ...part,
+              toolInvocation: {
+                ...part.toolInvocation,
+                args: JSON.stringify({}),
+                parsedArgs,
+                status: "result" /* RESULT */,
+                result: { error: "invalid_args", raw: part.toolInvocation.args }
+              }
+            };
+          }
+        }
+        return {
+          ...part,
+          toolInvocation: {
+            ...part.toolInvocation,
+            args: part.toolInvocation.args,
+            parsedArgs,
+            status: "result" /* RESULT */,
+            result: stub
+          }
+        };
+      })
+    };
+  });
+}
+
+// src/utils/run-utils.ts
+function isAbortLikeError(error) {
+  if (error instanceof DOMException && error.name === "AbortError") {
+    return true;
+  }
+  if (error instanceof Error) {
+    if (error.name === "AbortError") {
+      return true;
+    }
+    const lower = error.message.toLowerCase();
+    return lower.includes("aborted") || lower.includes("abort");
+  }
+  return false;
+}
+function formatSendError(error) {
+  if (error instanceof Error) {
+    const message = error.message.trim();
+    if (message) {
+      return message;
+    }
+  }
+  const raw = String(error ?? "").trim();
+  return raw || "Failed to send message";
+}
+function buildLocalAssistantMessage(text, options) {
+  return {
+    id: `local-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+    role: "assistant",
+    parts: [{ type: "text", text }],
+    meta: {
+      source: "local",
+      status: options?.status ?? "final",
+      sessionKey: options?.sessionKey,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
+
+// src/services/agent-event-handler.ts
+import { v4 } from "uuid";
+
+// src/utils/message-utils.ts
+function extractTextFromMessage(message) {
+  const textParts = [];
+  for (const part of message.parts) {
+    if (part.type === "text") {
+      textParts.push(part.text);
+    }
+  }
+  return textParts.join("\n\n");
+}
+function hasCopyableText(message) {
+  return message.parts.some((part) => part.type === "text" && part.text.trim().length > 0);
+}
+function getMessagePreview(message, maxLength = 100) {
+  const text = extractTextFromMessage(message);
+  if (text.length <= maxLength) {
+    return text;
+  }
+  return text.substring(0, maxLength) + "...";
+}
+
+// src/utils/tool.ts
+var getToolDefFromTool = (tool) => {
+  return {
+    name: tool.name,
+    description: tool.description,
+    parameters: tool.parameters
+  };
+};
+var toolInvocationToToolCall = (toolInvocation) => {
+  return {
+    id: toolInvocation.toolCallId,
+    type: "function",
+    function: {
+      name: toolInvocation.toolName,
+      arguments: JSON.stringify(toolInvocation.args)
+    }
+  };
+};
+
+// src/services/agent-event-handler.ts
+var AgentEventHandler = class {
+  constructor(sessionManager) {
+    this.sessionManager = sessionManager;
+  }
+  currentMessageId;
+  currentReasoningMessageId;
+  currentReasoningContent = "";
+  currentToolCallId;
+  currentToolCallMessageId;
+  currentToolCallName;
+  currentToolCallArgs = "";
+  emittedToolCallIds = /* @__PURE__ */ new Set();
+  findAssistantMessageById(messageId) {
+    const targetId = messageId?.trim();
+    if (!targetId) {
+      return null;
+    }
+    const currentMessages = this.sessionManager.getMessages();
+    return currentMessages.find((message) => message.role === "assistant" && message.id === targetId) ?? null;
+  }
+  findAssistantMessageByToolCallId(toolCallId) {
+    if (!toolCallId) {
+      return null;
+    }
+    const currentMessages = this.sessionManager.getMessages();
+    for (let i = currentMessages.length - 1; i >= 0; i -= 1) {
+      const message = currentMessages[i];
+      if (message.role !== "assistant") {
+        continue;
+      }
+      const hasTargetTool = message.parts?.some(
+        (part) => part.type === "tool-invocation" && part.toolInvocation.toolCallId === toolCallId
+      );
+      if (hasTargetTool) {
+        return message;
+      }
+    }
+    return null;
+  }
+  findAssistantMessageForCurrentTool(toolCallId) {
+    const exactMessage = this.findAssistantMessageById(this.currentToolCallMessageId);
+    if (exactMessage?.parts?.some((part) => part.type === "tool-invocation" && part.toolInvocation.toolCallId === toolCallId)) {
+      return exactMessage;
+    }
+    return this.findAssistantMessageByToolCallId(toolCallId);
+  }
+  reset() {
+    this.currentMessageId = void 0;
+    this.currentReasoningMessageId = void 0;
+    this.currentReasoningContent = "";
+    this.currentToolCallId = void 0;
+    this.currentToolCallMessageId = void 0;
+    this.currentToolCallName = void 0;
+    this.currentToolCallArgs = "";
+    this.emittedToolCallIds.clear();
+  }
+  emitToolCallEvents() {
+    const currentMessages = this.sessionManager.getMessages();
+    for (const message of currentMessages) {
+      if (message.role !== "assistant" || !message.parts) {
+        continue;
+      }
+      for (const part of message.parts) {
+        if (part.type !== "tool-invocation") continue;
+        const inv = part.toolInvocation;
+        if (inv.status === "call" /* CALL */ && !this.emittedToolCallIds.has(inv.toolCallId)) {
+          this.emittedToolCallIds.add(inv.toolCallId);
+          this.sessionManager.toolCall$.next({
+            toolCall: {
+              id: inv.toolCallId,
+              type: "function",
+              function: {
+                name: inv.toolName,
+                arguments: inv.args
+              }
+            }
+          });
+        }
+      }
+    }
+  }
+  handleEvent(event) {
+    switch (event.type) {
+      case "RUN_STARTED" /* RUN_STARTED */:
+        break;
+      case "TEXT_START" /* TEXT_START */:
+        this.handleTextStart(event);
+        break;
+      case "TEXT_DELTA" /* TEXT_DELTA */:
+        this.handleTextContent(event);
+        break;
+      case "TEXT_END" /* TEXT_END */:
+        this.handleTextEnd();
+        break;
+      case "REASONING_START" /* REASONING_START */:
+        this.handleReasoningStart(event);
+        break;
+      case "REASONING_DELTA" /* REASONING_DELTA */:
+        this.handleReasoningContent(event);
+        break;
+      case "REASONING_END" /* REASONING_END */:
+        this.handleReasoningEnd();
+        break;
+      case "TOOL_CALL_START" /* TOOL_CALL_START */:
+        this.handleToolCallStart(event);
+        break;
+      case "TOOL_CALL_ARGS_DELTA" /* TOOL_CALL_ARGS_DELTA */:
+        this.handleToolCallArgsDelta(event);
+        break;
+      case "TOOL_CALL_ARGS" /* TOOL_CALL_ARGS */:
+        this.handleToolCallArgs(event);
+        break;
+      case "TOOL_CALL_END" /* TOOL_CALL_END */:
+        this.handleToolCallEnd();
+        this.emitToolCallEvents();
+        break;
+      case "TOOL_CALL_RESULT" /* TOOL_CALL_RESULT */:
+        this.handleToolCallResult(event);
+        break;
+      default:
+        break;
+    }
+  }
+  handleTextStart(event) {
+    this.currentMessageId = event.messageId;
+  }
+  appendTextDelta(message, delta) {
+    const parts = [...message.parts || []];
+    const lastPart = parts[parts.length - 1];
+    if (lastPart && lastPart.type === "text") {
+      return {
+        ...message,
+        parts: [
+          ...parts.slice(0, -1),
+          { type: "text", text: `${lastPart.text}${delta}` }
+        ]
+      };
+    }
+    return {
+      ...message,
+      parts: [...parts, { type: "text", text: delta }]
+    };
+  }
+  handleTextContent(event) {
+    if (!event.delta || this.currentMessageId !== event.messageId) return;
+    const currentMessages = this.sessionManager.getMessages();
+    const existingMessage = currentMessages.find(
+      (message) => message.role === "assistant" && message.id === this.currentMessageId
+    );
+    if (existingMessage) {
+      this.sessionManager.updateMessage(this.appendTextDelta(existingMessage, event.delta));
+    } else {
+      this.sessionManager.addMessages([
+        {
+          id: this.currentMessageId,
+          role: "assistant",
+          parts: [
+            {
+              type: "text",
+              text: event.delta
+            }
+          ]
+        }
+      ]);
+    }
+  }
+  handleTextEnd() {
+    this.currentMessageId = void 0;
+  }
+  updateReasoningPart(message, reasoning) {
+    const parts = [...message.parts || []];
+    let reasoningPartIndex = -1;
+    for (let index = parts.length - 1; index >= 0; index -= 1) {
+      if (parts[index]?.type === "reasoning") {
+        reasoningPartIndex = index;
+        break;
+      }
+    }
+    if (reasoningPartIndex >= 0) {
+      return {
+        ...message,
+        parts: [
+          ...parts.slice(0, reasoningPartIndex),
+          { type: "reasoning", reasoning, details: [] },
+          ...parts.slice(reasoningPartIndex + 1)
+        ]
+      };
+    }
+    return {
+      ...message,
+      parts: [...parts, { type: "reasoning", reasoning, details: [] }]
+    };
+  }
+  handleReasoningStart(event) {
+    this.currentReasoningMessageId = event.messageId;
+    this.currentReasoningContent = "";
+  }
+  handleReasoningContent(event) {
+    if (!event.delta || this.currentReasoningMessageId !== event.messageId) return;
+    this.currentReasoningContent += event.delta;
+    const reasoningContent = this.currentReasoningContent;
+    const messageId = this.currentReasoningMessageId;
+    const currentMessages = this.sessionManager.getMessages();
+    const existingMessage = currentMessages.find((message) => message.role === "assistant" && message.id === messageId);
+    if (existingMessage) {
+      this.sessionManager.updateMessage(this.updateReasoningPart(existingMessage, reasoningContent));
+    } else {
+      this.sessionManager.addMessages([
+        {
+          id: messageId,
+          role: "assistant",
+          parts: [
+            {
+              type: "reasoning",
+              reasoning: reasoningContent,
+              details: []
+            }
+          ]
+        }
+      ]);
+    }
+  }
+  handleReasoningEnd() {
+    this.currentReasoningMessageId = void 0;
+    this.currentReasoningContent = "";
+  }
+  handleToolCallStart(event) {
+    this.currentToolCallId = event.toolCallId;
+    this.currentToolCallName = event.toolName;
+    this.currentToolCallArgs = "";
+    this.currentToolCallMessageId = event.messageId;
+    const invocationPart = {
+      type: "tool-invocation",
+      toolInvocation: {
+        status: "partial-call" /* PARTIAL_CALL */,
+        toolCallId: this.currentToolCallId,
+        toolName: this.currentToolCallName,
+        args: ""
+      }
+    };
+    const currentMessages = this.sessionManager.getMessages();
+    const messageId = event.messageId?.trim();
+    const exactMessage = this.findAssistantMessageById(messageId);
+    if (exactMessage) {
+      this.currentToolCallMessageId = exactMessage.id;
+      const existingPart = exactMessage.parts.find(
+        (part) => part.type === "tool-invocation" && part.toolInvocation.toolCallId === this.currentToolCallId
+      );
+      if (existingPart && existingPart.type === "tool-invocation") {
+        this.currentToolCallArgs = existingPart.toolInvocation.args;
+        return;
+      }
+      this.sessionManager.updateMessage({
+        ...exactMessage,
+        parts: [...exactMessage.parts || [], invocationPart]
+      });
+      return;
+    }
+    if (messageId) {
+      this.currentToolCallMessageId = messageId;
+      this.sessionManager.addMessages([
+        {
+          id: messageId,
+          role: "assistant",
+          parts: [invocationPart]
+        }
+      ]);
+      return;
+    }
+    const existingMessage = this.findAssistantMessageByToolCallId(this.currentToolCallId);
+    if (existingMessage) {
+      this.currentToolCallMessageId = existingMessage.id;
+      const existingPart = existingMessage.parts.find(
+        (part) => part.type === "tool-invocation" && part.toolInvocation.toolCallId === this.currentToolCallId
+      );
+      this.currentToolCallArgs = existingPart?.type === "tool-invocation" ? existingPart.toolInvocation.args : "";
+      return;
+    }
+    const lastMessage = currentMessages[currentMessages.length - 1];
+    if (lastMessage && lastMessage.role === "assistant") {
+      this.currentToolCallMessageId = lastMessage.id;
+      this.sessionManager.updateMessage({
+        ...lastMessage,
+        parts: [...lastMessage.parts || [], invocationPart]
+      });
+    } else {
+      const fallbackMessageId = v4();
+      this.currentToolCallMessageId = fallbackMessageId;
+      this.sessionManager.addMessages([
+        {
+          id: fallbackMessageId,
+          role: "assistant",
+          parts: [invocationPart]
+        }
+      ]);
+    }
+  }
+  handleToolCallArgsDelta(event) {
+    if (this.currentToolCallId !== event.toolCallId) return;
+    this.currentToolCallArgs += event.argsDelta;
+    const targetMessage = this.findAssistantMessageForCurrentTool(event.toolCallId);
+    if (!targetMessage || targetMessage.role !== "assistant" || !targetMessage.parts?.length) return;
+    const updatedParts = [...targetMessage.parts];
+    for (let i = updatedParts.length - 1; i >= 0; i--) {
+      const part = updatedParts[i];
+      if (part.type === "tool-invocation" && part.toolInvocation.toolCallId === event.toolCallId) {
+        let parsed;
+        try {
+          parsed = JSON.parse(this.currentToolCallArgs);
+        } catch {
+        }
+        updatedParts[i] = {
+          ...part,
+          toolInvocation: {
+            ...part.toolInvocation,
+            status: "partial-call" /* PARTIAL_CALL */,
+            args: this.currentToolCallArgs,
+            parsedArgs: parsed
+          }
+        };
+        break;
+      }
+    }
+    this.sessionManager.updateMessage({
+      ...targetMessage,
+      parts: updatedParts
+    });
+  }
+  handleToolCallArgs(event) {
+    if (this.currentToolCallId !== event.toolCallId) return;
+    this.currentToolCallArgs = event.args;
+    this.handleToolCallArgsDelta({
+      type: "TOOL_CALL_ARGS_DELTA" /* TOOL_CALL_ARGS_DELTA */,
+      toolCallId: event.toolCallId,
+      argsDelta: ""
+    });
+  }
+  handleToolCallEnd() {
+    if (!this.currentToolCallId || !this.currentToolCallName) return;
+    try {
+      const toolCall = {
+        id: this.currentToolCallId,
+        type: "function",
+        function: {
+          name: this.currentToolCallName,
+          arguments: this.currentToolCallArgs
+        }
+      };
+      const targetMessage = this.findAssistantMessageForCurrentTool(this.currentToolCallId);
+      if (targetMessage && targetMessage.role === "assistant") {
+        const updatedParts = [...targetMessage.parts || []];
+        for (let i = updatedParts.length - 1; i >= 0; i--) {
+          const part = updatedParts[i];
+          if (part.type === "tool-invocation" && part.toolInvocation.toolCallId === this.currentToolCallId) {
+            updatedParts[i] = {
+              ...part,
+              toolInvocation: {
+                ...toolCallToToolInvocation(toolCall),
+                status: "call" /* CALL */
+              }
+            };
+            break;
+          }
+        }
+        this.sessionManager.updateMessage({
+          ...targetMessage,
+          parts: updatedParts
+        });
+      } else {
+        const fallbackMessageId = this.currentToolCallMessageId?.trim() || v4();
+        this.sessionManager.addMessages([
+          {
+            id: fallbackMessageId,
+            role: "assistant",
+            parts: [
+              {
+                type: "tool-invocation",
+                toolInvocation: {
+                  ...toolCallToToolInvocation(toolCall),
+                  status: "call" /* CALL */
+                }
+              }
+            ]
+          }
+        ]);
+      }
+    } catch {
+    }
+    this.currentToolCallId = void 0;
+    this.currentToolCallMessageId = void 0;
+    this.currentToolCallName = void 0;
+    this.currentToolCallArgs = "";
+  }
+  handleToolCallResult(event) {
+    this.sessionManager.addToolResult({
+      toolCallId: event.toolCallId,
+      result: event.content,
+      status: "result" /* RESULT */
+    });
+  }
+};
+
+// src/services/agent-chat-controller.ts
+var Disposable = class {
+  disposables = [];
+  addDisposable = (disposable) => {
+    this.disposables.push(disposable);
+  };
+  dispose = () => {
+    this.disposables.forEach((disposable) => disposable());
+    this.disposables = [];
+  };
+};
+var AgentChatController = class extends Disposable {
+  constructor(agentProvider = null, options) {
+    super();
+    this.agentProvider = agentProvider;
+    const { initialMessages = [], metadataParsers, callbacks = {} } = options || {};
+    this.metadataParsers = metadataParsers ?? null;
+    this.callbacks = callbacks;
+    this._messages$.next(initialMessages);
+    this.messages$ = this._messages$.asObservable();
+    if (this.agentProvider) {
+      this.addDisposable(this.connectToolExecutor());
+    }
+  }
+  _messages$ = new BehaviorSubject([]);
+  messages$;
+  threadId$ = new BehaviorSubject(null);
+  isAgentResponding$ = new BehaviorSubject(false);
+  activeRun$ = new BehaviorSubject(null);
+  lastError$ = new BehaviorSubject(null);
+  isAwaitingResponse$ = new BehaviorSubject(false);
+  runCompleted$ = new Subject();
+  runError$ = new Subject();
+  runMetadata$ = new Subject();
+  activeSubscription = null;
+  addMessagesEvent$ = new Subject();
+  updateMessageEvent$ = new Subject();
+  setMessagesEvent$ = new Subject();
+  toolCall$ = new Subject();
+  eventHandler = new AgentEventHandler(this);
+  runIdCounter = 0;
+  metadataParsers;
+  callbacks;
+  getMessages = () => {
+    return this._messages$.getValue();
+  };
+  setMessages = (messages) => {
+    this._messages$.next(messages);
+    this.setMessagesEvent$.next({ messages });
+  };
+  handleEvent = (event) => {
+    this.eventHandler.handleEvent(event);
+  };
+  setCallbacks = (callbacks) => {
+    this.callbacks = callbacks;
+  };
+  reset = () => {
+    this.abortAgentRun();
+    this._messages$.next([]);
+    this.eventHandler.reset();
+    this.threadId$.next(null);
+    this.isAgentResponding$.next(false);
+    this.activeRun$.next(null);
+    this.lastError$.next(null);
+    this.isAwaitingResponse$.next(false);
+    this.runIdCounter += 1;
+  };
+  addMessages = (messages) => {
+    const current = this.getMessages();
+    const next = [...current];
+    for (const message of messages) {
+      const existingIndex = next.findIndex((item) => item.id === message.id);
+      if (existingIndex >= 0) {
+        next[existingIndex] = message;
+      } else {
+        next.push(message);
+      }
+    }
+    this._messages$.next(next);
+    this.addMessagesEvent$.next({ messages });
+    if (this.isAwaitingResponse$.getValue() && messages.some((m) => m.role === "assistant")) {
+      this.isAwaitingResponse$.next(false);
+    }
+  };
+  removeMessages = (messageIds) => {
+    if (messageIds.length === 0) return;
+    this._messages$.next(this.getMessages().filter((msg) => !messageIds.includes(msg.id)));
+  };
+  updateMessage = (message) => {
+    this._messages$.next(this.getMessages().map((msg) => msg.id === message.id ? message : msg));
+    this.updateMessageEvent$.next({ message });
+    if (this.isAwaitingResponse$.getValue() && message.role === "assistant") {
+      this.isAwaitingResponse$.next(false);
+    }
+  };
+  addToolResult = (result, _options) => {
+    const targetMessage = this.getMessages().find(
+      (msg) => msg.parts.find(
+        (part) => part.type === "tool-invocation" && part.toolInvocation.toolCallId === result.toolCallId
+      )
+    );
+    if (!targetMessage) {
+      return;
+    }
+    const newMessage = {
+      ...targetMessage,
+      parts: targetMessage.parts.map((part) => {
+        if (part.type === "tool-invocation" && part.toolInvocation.toolCallId === result.toolCallId) {
+          return {
+            ...part,
+            toolInvocation: {
+              ...part.toolInvocation,
+              result: result.result ?? void 0,
+              status: result.status,
+              error: result.error ?? void 0,
+              cancelled: result.cancelled ?? void 0
+            }
+          };
+        }
+        return part;
+      })
+    };
+    this.updateMessage(newMessage);
+  };
+  send = async (options) => {
+    if (this.activeRun$.getValue() || this.activeSubscription) {
+      this.abortAgentRun();
+    }
+    this.lastError$.next(null);
+    const message = options.message.trim();
+    if (!message) return;
+    this.addMessages([
+      {
+        id: v42(),
+        role: "user",
+        parts: [{ type: "text", text: message }]
+      }
+    ]);
+    await this.runAgent({
+      metadata: options.metadata,
+      sessionId: options.sessionId,
+      agentId: options.agentId,
+      stopCapable: options.stopCapable,
+      stopReason: options.stopReason,
+      sourceMessage: message,
+      restoreDraftOnError: options.restoreDraftOnError
+    });
+  };
+  resume = async (options) => {
+    const remoteRunId = options.remoteRunId?.trim();
+    const sessionId = options.sessionId?.trim();
+    if (!remoteRunId) return;
+    const currentRun = this.activeRun$.getValue();
+    if (currentRun?.remoteRunId === remoteRunId) return;
+    if (currentRun) return;
+    this.lastError$.next(null);
+    await this.runAgent({
+      metadata: options.metadata,
+      sessionId,
+      agentId: options.agentId,
+      stopCapable: options.stopCapable,
+      stopReason: options.stopReason
+    });
+  };
+  stop = async () => {
+    const activeRun = this.activeRun$.getValue();
+    if (!activeRun) return;
+    const sourceSessionId = activeRun.sessionId;
+    this.abortAgentRun();
+    if (sourceSessionId) {
+      await this.callbacks.onRunSettled?.({ sourceSessionId });
+    }
+  };
+  handleAgentResponse = (response) => {
+    if (this.activeSubscription) {
+      this.activeSubscription.unsubscribe();
+    }
+    this.activeSubscription = response.subscribe((event) => {
+      if (event.type === "RUN_METADATA" /* RUN_METADATA */) {
+        const metaEvent = event;
+        const activeRun = this.activeRun$.getValue();
+        const runId = metaEvent.runId?.trim() || (activeRun ? `ui-${activeRun.localRunId}` : "");
+        if (this.metadataParsers && activeRun && this.isMatchingRun(activeRun, runId)) {
+          this.processRunMetadata(activeRun, metaEvent.metadata);
+        }
+        this.runMetadata$.next({ runId, metadata: metaEvent.metadata });
+        return;
+      }
+      this.handleEvent(event);
+      if (event.type === "RUN_FINISHED" /* RUN_FINISHED */) {
+        this.isAgentResponding$.next(false);
+        this.isAwaitingResponse$.next(false);
+        this.activeSubscription = null;
+        const activeRun = this.activeRun$.getValue();
+        const runId = event.runId?.trim() || (activeRun ? `ui-${activeRun.localRunId}` : "");
+        if (!activeRun || !this.isMatchingRun(activeRun, runId)) {
+          return;
+        }
+        const sourceSessionId = activeRun.sessionId;
+        this.activeRun$.next(null);
+        if (sourceSessionId) {
+          void this.callbacks.onRunSettled?.({ sourceSessionId });
+        }
+      } else if (event.type === "RUN_ERROR" /* RUN_ERROR */) {
+        this.isAgentResponding$.next(false);
+        this.isAwaitingResponse$.next(false);
+        this.activeSubscription = null;
+        const activeRun = this.activeRun$.getValue();
+        const runId = event.runId?.trim() || (activeRun ? `ui-${activeRun.localRunId}` : "");
+        const isAbort = isAbortLikeError(event.error);
+        this.runError$.next({ runId, error: event.error, isAbort });
+        if (!activeRun || !this.isMatchingRun(activeRun, runId)) {
+          this.activeRun$.next(null);
+          return;
+        }
+        const sourceSessionId = activeRun.sessionId;
+        if (isAbort) {
+          this.activeRun$.next(null);
+          if (sourceSessionId) {
+            void this.callbacks.onRunSettled?.({ sourceSessionId });
+          }
+          return;
+        }
+        const sendError = formatSendError(event.error);
+        this.lastError$.next(sendError);
+        this.activeRun$.next(null);
+        if (sourceSessionId) {
+          this.addMessages([
+            buildLocalAssistantMessage(sendError, {
+              sessionKey: sourceSessionId,
+              status: "error"
+            })
+          ]);
+        }
+        this.callbacks.onRunError?.({
+          error: sendError,
+          sourceMessage: activeRun.sourceMessage,
+          restoreDraft: activeRun.restoreDraftOnError
+        });
+      }
+    });
+  };
+  abortAgentRun = () => {
+    this.agentProvider?.agent.abortRun?.();
+    if (this.activeSubscription) {
+      this.activeSubscription.unsubscribe();
+      this.activeSubscription = null;
+      this.isAgentResponding$.next(false);
+      this.isAwaitingResponse$.next(false);
+    }
+    this.activeRun$.next(null);
+  };
+  runAgent = async (options) => {
+    if (!this.agentProvider) {
+      return;
+    }
+    if (this.activeRun$.getValue() || this.activeSubscription) {
+      this.abortAgentRun();
+    }
+    const localRunId = ++this.runIdCounter;
+    const runId = `ui-${localRunId}`;
+    const activeRun = {
+      localRunId,
+      sessionId: options?.sessionId,
+      ...options?.agentId ? { agentId: options.agentId } : {},
+      remoteStopCapable: Boolean(options?.stopCapable),
+      ...options?.stopReason ? { remoteStopReason: options.stopReason } : {},
+      sourceMessage: options?.sourceMessage,
+      restoreDraftOnError: options?.restoreDraftOnError
+    };
+    this.activeRun$.next(activeRun);
+    this.isAgentResponding$.next(true);
+    this.isAwaitingResponse$.next(true);
+    try {
+      const safeMessages = finalizePendingToolInvocations(this.getMessages());
+      const threadId = typeof options?.threadId === "string" && options.threadId.trim() ? options.threadId : this.threadId$.getValue() ?? "";
+      const response = await this.agentProvider.agent.run({
+        threadId,
+        runId,
+        messages: safeMessages,
+        tools: this.agentProvider.getToolDefs(),
+        context: this.agentProvider.getContexts(),
+        ...options?.metadata ? { metadata: options.metadata } : {}
+      });
+      this.handleAgentResponse(response);
+    } catch (error) {
+      const isAbort = isAbortLikeError(error);
+      if (isAbort) {
+        console.info("Agent run aborted");
+      } else {
+        console.error("Error running agent:", error);
+      }
+      this.isAgentResponding$.next(false);
+      this.isAwaitingResponse$.next(false);
+      const currentActiveRun = this.activeRun$.getValue();
+      this.activeRun$.next(null);
+      this.runError$.next({ runId, error, isAbort });
+      if (!isAbort && currentActiveRun) {
+        const sendError = formatSendError(error);
+        this.lastError$.next(sendError);
+        if (currentActiveRun.sessionId) {
+          this.addMessages([
+            buildLocalAssistantMessage(sendError, {
+              sessionKey: currentActiveRun.sessionId,
+              status: "error"
+            })
+          ]);
+        }
+        this.callbacks.onRunError?.({
+          error: sendError,
+          sourceMessage: currentActiveRun.sourceMessage,
+          restoreDraft: currentActiveRun.restoreDraftOnError
+        });
+      } else if (isAbort && currentActiveRun?.sessionId) {
+        void this.callbacks.onRunSettled?.({ sourceSessionId: currentActiveRun.sessionId });
+      }
+    }
+  };
+  processRunMetadata = (activeRun, metadata) => {
+    if (!this.metadataParsers) return;
+    const ready = this.metadataParsers.parseReady(metadata);
+    if (ready) {
+      this.applyReadyMetadata(activeRun, ready);
+      return;
+    }
+    const final = this.metadataParsers.parseFinal(metadata);
+    if (final) {
+      this.applyFinalMetadata(activeRun, final);
+    }
+  };
+  applyReadyMetadata = (activeRun, ready) => {
+    const updatedRun = { ...activeRun };
+    if (ready.remoteRunId?.trim()) {
+      updatedRun.remoteRunId = ready.remoteRunId.trim();
+    }
+    if (typeof ready.stopCapable === "boolean") {
+      updatedRun.remoteStopCapable = ready.stopCapable;
+    }
+    if (ready.stopReason?.trim()) {
+      updatedRun.remoteStopReason = ready.stopReason.trim();
+    }
+    if (ready.sessionId?.trim()) {
+      updatedRun.sessionId = ready.sessionId.trim();
+      this.callbacks.onSessionChanged?.(updatedRun.sessionId);
+    }
+    this.activeRun$.next(updatedRun);
+  };
+  applyFinalMetadata = (activeRun, final) => {
+    const sourceSessionId = activeRun.sessionId;
+    const resultSessionId = final.sessionId;
+    if (resultSessionId && resultSessionId !== sourceSessionId) {
+      this.callbacks.onSessionChanged?.(resultSessionId);
+    }
+    this.activeRun$.next(null);
+    if (sourceSessionId) {
+      void this.callbacks.onRunSettled?.({ sourceSessionId, resultSessionId });
+    }
+  };
+  isMatchingRun = (activeRun, runId) => {
+    if (!runId.trim()) return false;
+    return runId === `ui-${activeRun.localRunId}`;
+  };
+  connectToolExecutor = () => {
+    const sub = this.toolCall$.subscribe(async ({ toolCall }) => {
+      const executor = this.agentProvider?.getToolExecutor(toolCall.function.name);
+      if (executor) {
+        try {
+          const toolCallArgs = JSON.parse(toolCall.function.arguments);
+          const result = await executor(toolCallArgs);
+          this.addToolResult({ toolCallId: toolCall.id, result, status: "result" /* RESULT */ });
+          this.runAgent();
+        } catch (err) {
+          console.error("[AgentChatController] handleAddToolResult error", err);
+          this.addToolResult({
+            toolCallId: toolCall.id,
+            error: err instanceof Error ? err.message : String(err),
+            status: "error" /* ERROR */
+          });
+          this.runAgent();
+        }
+      }
+    });
+    return () => sub.unsubscribe();
+  };
+};
+export {
+  AgentChatController,
+  AgentEventHandler,
+  Disposable,
+  EventType,
+  ToolInvocationStatus,
+  buildLocalAssistantMessage,
+  extractTextFromMessage,
+  finalizePendingToolInvocations,
+  formatSendError,
+  getMessagePreview,
+  getStopDisabledReason,
+  getToolDefFromTool,
+  hasCopyableText,
+  isAbortLikeError,
+  toolCallToToolInvocation,
+  toolInvocationToToolCall
+};