@mcpstack/agent-sdk 1.0.0-pr.18.bbb0c016bc21.17.1 → 1.0.0

package/dist/index.js

@@ -43,15 +43,12 @@ function* parseEventBlocks(input) {
         dataLines.push("");
       }
     }
-    if (dataLines.length === 0) {
+    if (!eventType || dataLines.length === 0) {
       continue;
     }
     try {
       const parsed = JSON.parse(dataLines.join("\n"));
-      const parsedType = typeof parsed?.type === "string" ? parsed.type : "";
-      const resolvedType = eventType || parsedType;
-      if (!resolvedType) continue;
-      yield { type: resolvedType, data: parsed };
+      yield { type: eventType, data: parsed };
     } catch {
     }
   }
@@ -379,20 +376,6 @@ function clearPersistedMcpAuth() {
 }
 
 // src/core/EmcyAgent.ts
-var AG_UI_EVENT = {
-  RUN_STARTED: "RUN_STARTED",
-  RUN_FINISHED: "RUN_FINISHED",
-  RUN_ERROR: "RUN_ERROR",
-  TEXT_MESSAGE_START: "TEXT_MESSAGE_START",
-  TEXT_MESSAGE_CONTENT: "TEXT_MESSAGE_CONTENT",
-  TEXT_MESSAGE_END: "TEXT_MESSAGE_END",
-  TOOL_CALL_START: "TOOL_CALL_START",
-  TOOL_CALL_ARGS: "TOOL_CALL_ARGS",
-  TOOL_CALL_END: "TOOL_CALL_END",
-  TOOL_CALL_RESULT: "TOOL_CALL_RESULT",
-  STATE_SNAPSHOT: "STATE_SNAPSHOT",
-  CUSTOM: "CUSTOM"
-};
 var DEFAULT_MCP_PROTOCOL_VERSION = "2025-11-25";
 var DEFAULT_LOCAL_PUBLIC_APP_PORT = "3100";
 var DEFAULT_OAUTH_CALLBACK_URL = "https://mcpstack.com/oauth/callback";
@@ -886,69 +869,6 @@ var McpStackAgent = class {
       selection: def.selection
     }));
   }
-  clientToolsToAgUiTools() {
-    if (!this.config.clientTools) return [];
-    return Object.entries(this.config.clientTools).map(([name, def]) => {
-      const metadata = {};
-      if (def.selection) {
-        metadata.mcpstack = { selection: def.selection };
-        metadata["x-mcpstack-selection"] = def.selection;
-      }
-      return {
-        name,
-        description: def.description,
-        parameters: parametersToJsonSchema(def.parameters),
-        metadata: Object.keys(metadata).length > 0 ? metadata : void 0
-      };
-    });
-  }
-  buildAgUiContext() {
-    if (!this.config.context) return [];
-    return Object.entries(this.config.context).filter(([, value]) => value != null).map(([key, value]) => ({
-      description: key,
-      value: typeof value === "string" ? value : JSON.stringify(value)
-    }));
-  }
-  buildAgUiForwardedProps() {
-    const externalUser = this.buildExternalUserContext();
-    const mcpstack = {
-      conversationId: this.conversationId ?? void 0,
-      externalUserId: this.resolveExternalUserId(),
-      context: this.config.context
-    };
-    if (externalUser) {
-      mcpstack.externalUser = externalUser;
-    }
-    return { mcpstack };
-  }
-  buildAgUiUserRunInput(message) {
-    return {
-      threadId: this.conversationId ?? `thread_${crypto.randomUUID()}`,
-      runId: `run_${crypto.randomUUID()}`,
-      state: this.config.context ?? {},
-      messages: [{ id: crypto.randomUUID(), role: "user", content: message }],
-      tools: this.clientToolsToAgUiTools(),
-      context: this.buildAgUiContext(),
-      forwardedProps: this.buildAgUiForwardedProps()
-    };
-  }
-  buildAgUiToolResultRunInput(toolCall, content, error) {
-    return {
-      threadId: this.conversationId ?? `thread_${crypto.randomUUID()}`,
-      runId: `run_${crypto.randomUUID()}`,
-      state: this.config.context ?? {},
-      messages: [{
-        id: crypto.randomUUID(),
-        role: "tool",
-        toolCallId: toolCall.toolCallId,
-        content,
-        error
-      }],
-      tools: this.clientToolsToAgUiTools(),
-      context: this.buildAgUiContext(),
-      forwardedProps: this.buildAgUiForwardedProps()
-    };
-  }
   resolveExternalUserId() {
     const hostIdentity = this.config.embeddedAuth?.hostIdentity;
     return this.config.externalUserId ?? hostIdentity?.subject ?? hostIdentity?.email ?? void 0;
@@ -2191,44 +2111,109 @@ var McpStackAgent = class {
   // ================================================================
   /**
    * The core orchestration loop:
-   * 1. Send message to the AG-UI run endpoint
-   * 2. Stream assistant text, server MCP tool progress, and frontend tool requests
-   * 3. If an AG-UI frontend tool is requested, execute the matching clientTool locally
-   * 4. Send the frontend tool result back as an AG-UI tool message and continue
+   * 1. Send message to chat API
+   * 2. Stream response
+   * 3. If tool_call → execute tool via MCP → send result → continue
+   * 4. If message_end → done
    */
   async runChatLoop(message) {
     this.abortController = new AbortController();
     this.emit("thinking", true);
-    let response = await this.callAgUiApi(this.buildAgUiUserRunInput(message));
+    const chatBody = {
+      agentId: this.config.agentId,
+      conversationId: this.conversationId,
+      message,
+      externalUserId: this.resolveExternalUserId(),
+      context: this.config.context
+    };
+    const externalUser = this.buildExternalUserContext();
+    if (externalUser) {
+      chatBody.externalUser = externalUser;
+    }
+    const clientToolSchemas = this.clientToolsToSchemas();
+    if (clientToolSchemas.length > 0) {
+      chatBody.clientTools = clientToolSchemas;
+    }
+    let response = await this.callChatApi(chatBody, "chat");
     while (true) {
-      const result = await this.processAgUiStream(response);
-      if (result.type === "done") {
+      const result = await this.processSseStream(response);
+      if (result.type === "message_end") {
         break;
       }
-      if (result.type === "frontend_tool") {
+      if (result.type === "tool_call") {
         const toolCall = result.data;
         const startTime = Date.now();
         try {
-          const toolResult = await this.executeClientTool(toolCall);
+          const toolResult = await this.executeTool(toolCall);
           const duration = Date.now() - startTime;
-          this.recordToolResult(toolCall, toolResult, duration);
+          const toolCallMsg = this.messages.find(
+            (m) => m.role === "tool_call" && m.toolCallId === toolCall.toolCallId
+          );
+          if (toolCallMsg) {
+            toolCallMsg.toolCallStatus = "completed";
+            toolCallMsg.toolCallDuration = duration;
+            toolCallMsg.toolResult = typeof toolResult === "string" ? toolResult : JSON.stringify(toolResult);
+          }
+          this.emit("tool_result", { toolCallId: toolCall.toolCallId, result: toolResult, duration });
+          const toolResultMsg = {
+            id: crypto.randomUUID(),
+            role: "tool_result",
+            content: typeof toolResult === "string" ? toolResult : JSON.stringify(toolResult),
+            toolCallId: toolCall.toolCallId,
+            toolName: toolCall.toolName,
+            timestamp: /* @__PURE__ */ new Date()
+          };
+          this.messages.push(toolResultMsg);
           this.emit("thinking", true);
-          response = await this.callAgUiApi(this.buildAgUiToolResultRunInput(
-            toolCall,
-            this.serializeToolContent(toolResult)
-          ));
+          const toolResultBody = {
+            conversationId: this.conversationId,
+            toolCallId: toolCall.toolCallId,
+            result: toolResult,
+            durationMs: duration,
+            context: this.config.context
+          };
+          const clientToolSchemas2 = this.clientToolsToSchemas();
+          if (clientToolSchemas2.length > 0) {
+            toolResultBody.clientTools = clientToolSchemas2;
+          }
+          response = await this.callChatApi(toolResultBody, "chat/tool-result");
         } catch (err) {
           const duration = Date.now() - startTime;
           const errorMsg = err instanceof Error ? err.message : "Tool execution failed";
+          const toolCallMsg = this.messages.find(
+            (m) => m.role === "tool_call" && m.toolCallId === toolCall.toolCallId
+          );
+          if (toolCallMsg) {
+            toolCallMsg.toolCallStatus = "error";
+            toolCallMsg.toolCallDuration = duration;
+            toolCallMsg.toolError = errorMsg;
+          }
+          this.emit("tool_error", { toolCallId: toolCall.toolCallId, error: errorMsg, duration });
           const errorResult = `Error: ${errorMsg}`;
-          this.recordToolError(toolCall, errorMsg, errorResult, duration);
+          const toolResultMsg = {
+            id: crypto.randomUUID(),
+            role: "tool_result",
+            content: errorResult,
+            toolCallId: toolCall.toolCallId,
+            toolName: toolCall.toolName,
+            timestamp: /* @__PURE__ */ new Date()
+          };
+          this.messages.push(toolResultMsg);
           this.emit("thinking", true);
           try {
-            response = await this.callAgUiApi(this.buildAgUiToolResultRunInput(
-              toolCall,
-              errorResult,
-              errorMsg
-            ));
+            const toolResultBody = {
+              conversationId: this.conversationId,
+              toolCallId: toolCall.toolCallId,
+              result: errorResult,
+              isError: true,
+              durationMs: duration,
+              context: this.config.context
+            };
+            const clientToolSchemas2 = this.clientToolsToSchemas();
+            if (clientToolSchemas2.length > 0) {
+              toolResultBody.clientTools = clientToolSchemas2;
+            }
+            response = await this.callChatApi(toolResultBody, "chat/tool-result");
           } catch {
             this.emit("error", { code: "tool_error", message: errorMsg });
             break;
@@ -2240,35 +2225,17 @@ var McpStackAgent = class {
       }
     }
   }
-  async executeClientTool(toolCall) {
-    const def = this.config.clientTools?.[toolCall.toolName];
-    if (!def) {
-      throw new Error(`Unknown client tool: ${toolCall.toolName}`);
-    }
-    return def.execute(toolCall.arguments ?? {});
-  }
-  async callAgUiApi(input) {
+  async callChatApi(body, endpoint) {
     const token = await this.resolveAuthToken();
-    const headers = {
-      "Content-Type": "application/json",
-      Accept: "text/event-stream",
-      Authorization: `Bearer ${token}`
-    };
-    if (this.config.auth?.mode === "app-token") {
-      const appToken = await this.config.auth.getToken();
-      if (appToken?.trim()) {
-        headers["X-MCPStack-App-Token"] = appToken.trim();
-      }
-      if (this.config.auth.appId?.trim()) {
-        headers["X-MCPStack-Embedded-App-Id"] = this.config.auth.appId.trim();
-      }
-    }
     const response = await fetch(
-      `${this.config.agentServiceUrl}/api/v1/agents/${encodeURIComponent(this.config.agentId)}/ag-ui`,
+      `${this.config.agentServiceUrl}/api/v1/${endpoint}`,
       {
         method: "POST",
-        headers,
-        body: JSON.stringify(input),
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${token}`
+        },
+        body: JSON.stringify(body),
         signal: this.abortController?.signal
       }
     );
@@ -2277,281 +2244,6 @@ var McpStackAgent = class {
     }
     return response;
   }
-  async processAgUiStream(response) {
-    let assistantContent = "";
-    let emittedThinkingFalse = false;
-    let pendingFrontendTool = null;
-    const toolCalls = /* @__PURE__ */ new Map();
-    const stopThinking = () => {
-      if (!emittedThinkingFalse) {
-        this.emit("thinking", false);
-        emittedThinkingFalse = true;
-      }
-    };
-    const flushAssistantMessage = () => {
-      if (!assistantContent) {
-        return;
-      }
-      const assistantMsg = {
-        id: crypto.randomUUID(),
-        role: "assistant",
-        content: assistantContent,
-        timestamp: /* @__PURE__ */ new Date()
-      };
-      this.messages.push(assistantMsg);
-      this.emit("message", assistantMsg);
-      assistantContent = "";
-    };
-    for await (const event of parseSseStream(response, this.abortController?.signal)) {
-      const data = event.data;
-      switch (event.type) {
-        case AG_UI_EVENT.RUN_STARTED: {
-          const threadId = this.getStringField(data, "threadId");
-          if (threadId) {
-            this.conversationId = threadId;
-          }
-          break;
-        }
-        case AG_UI_EVENT.STATE_SNAPSHOT: {
-          const snapshot = this.getRecordField(data, "snapshot");
-          const conversationId = snapshot ? this.getStringField(snapshot, "conversationId") : void 0;
-          if (conversationId) {
-            this.conversationId = conversationId;
-          }
-          const budget = snapshot?.budget;
-          if (budget && typeof budget === "object") {
-            this.budgetSnapshot = budget;
-            this.emit("budget_snapshot", this.budgetSnapshot);
-          }
-          break;
-        }
-        case AG_UI_EVENT.TEXT_MESSAGE_CONTENT: {
-          stopThinking();
-          const delta = this.getStringField(data, "delta") ?? "";
-          assistantContent += delta;
-          this.emit("content_delta", { text: delta });
-          break;
-        }
-        case AG_UI_EVENT.TOOL_CALL_START: {
-          stopThinking();
-          const toolCallId = this.getStringField(data, "toolCallId");
-          const toolName = this.getStringField(data, "toolCallName");
-          if (!toolCallId || !toolName) {
-            break;
-          }
-          const mcpstack = this.getRecordField(data, "mcpstack");
-          const sourceValue = mcpstack ? this.getStringField(mcpstack, "source") : void 0;
-          const source = sourceValue === "mcp" ? "mcp" : sourceValue === "client" ? "client" : void 0;
-          toolCalls.set(toolCallId, {
-            toolCallId,
-            toolName,
-            toolLabel: mcpstack ? this.getStringField(mcpstack, "label") : void 0,
-            mcpServerName: mcpstack ? this.getStringField(mcpstack, "mcpServerName") : void 0,
-            source,
-            argumentsJson: "",
-            startedAt: Date.now()
-          });
-          break;
-        }
-        case AG_UI_EVENT.TOOL_CALL_ARGS: {
-          const toolCallId = this.getStringField(data, "toolCallId");
-          const state = toolCallId ? toolCalls.get(toolCallId) : void 0;
-          if (state) {
-            state.argumentsJson += this.getStringField(data, "delta") ?? "";
-          }
-          break;
-        }
-        case AG_UI_EVENT.TOOL_CALL_END: {
-          const toolCallId = this.getStringField(data, "toolCallId");
-          const state = toolCallId ? toolCalls.get(toolCallId) : void 0;
-          if (!state) {
-            break;
-          }
-          flushAssistantMessage();
-          const toolCall = {
-            toolCallId: state.toolCallId,
-            toolName: state.toolName,
-            toolLabel: state.toolLabel,
-            mcpServerName: state.mcpServerName,
-            source: state.source,
-            arguments: this.parseToolArguments(state.argumentsJson)
-          };
-          const toolCallMsg = {
-            id: crypto.randomUUID(),
-            role: "tool_call",
-            content: `Calling ${toolCall.toolLabel ?? toolCall.toolName}...`,
-            toolName: toolCall.toolName,
-            toolLabel: toolCall.toolLabel,
-            toolCallId: toolCall.toolCallId,
-            timestamp: /* @__PURE__ */ new Date(),
-            toolCallStatus: "calling",
-            toolCallStartTime: state.startedAt
-          };
-          this.messages.push(toolCallMsg);
-          this.emit("tool_call", toolCall);
-          if (state.source !== "mcp") {
-            pendingFrontendTool = toolCall;
-          }
-          break;
-        }
-        case AG_UI_EVENT.TOOL_CALL_RESULT: {
-          const toolCallId = this.getStringField(data, "toolCallId");
-          const state = toolCallId ? toolCalls.get(toolCallId) : void 0;
-          if (!toolCallId) {
-            break;
-          }
-          const content = this.getStringField(data, "content") ?? "";
-          const toolCall = {
-            toolCallId,
-            toolName: state?.toolName ?? this.getStringField(data, "toolCallName") ?? toolCallId,
-            toolLabel: state?.toolLabel,
-            mcpServerName: state?.mcpServerName,
-            source: state?.source,
-            arguments: state ? this.parseToolArguments(state.argumentsJson) : {}
-          };
-          const duration = state ? Date.now() - state.startedAt : 0;
-          this.recordToolResult(toolCall, this.parseToolContent(content), duration);
-          if (pendingFrontendTool?.toolCallId === toolCallId) {
-            pendingFrontendTool = null;
-          }
-          break;
-        }
-        case AG_UI_EVENT.CUSTOM: {
-          const name = this.getStringField(data, "name");
-          if (name === "mcpstack.budget_snapshot") {
-            const value = data.value;
-            if (value && typeof value === "object") {
-              this.budgetSnapshot = value;
-              this.emit("budget_snapshot", this.budgetSnapshot);
-            }
-          }
-          break;
-        }
-        case AG_UI_EVENT.RUN_FINISHED: {
-          const result = this.getRecordField(data, "result");
-          const conversationId = result ? this.getStringField(result, "conversationId") : void 0;
-          if (conversationId) {
-            this.conversationId = conversationId;
-          }
-          if (pendingFrontendTool) {
-            return { type: "frontend_tool", data: pendingFrontendTool };
-          }
-          flushAssistantMessage();
-          const messageEnd2 = {
-            inputTokens: this.getNumberField(result, "inputTokens") ?? 0,
-            outputTokens: this.getNumberField(result, "outputTokens") ?? 0,
-            toolCalls: this.getNumberField(result, "toolCalls") ?? toolCalls.size
-          };
-          this.emit("message_end", messageEnd2);
-          return { type: "done" };
-        }
-        case AG_UI_EVENT.RUN_ERROR: {
-          const error = {
-            code: this.getStringField(data, "code") ?? "run_error",
-            message: this.getStringField(data, "message") ?? "Agent run failed."
-          };
-          const errorMsg = {
-            id: crypto.randomUUID(),
-            role: "error",
-            content: error.message,
-            timestamp: /* @__PURE__ */ new Date(),
-            errorCode: error.code
-          };
-          this.messages.push(errorMsg);
-          this.emit("message", errorMsg);
-          this.emit("error", error);
-          return { type: "error", data: error };
-        }
-      }
-    }
-    flushAssistantMessage();
-    const messageEnd = {
-      inputTokens: 0,
-      outputTokens: 0,
-      toolCalls: toolCalls.size
-    };
-    this.emit("message_end", messageEnd);
-    return { type: "done" };
-  }
-  recordToolResult(toolCall, result, duration) {
-    const toolCallMsg = this.messages.find(
-      (m) => m.role === "tool_call" && m.toolCallId === toolCall.toolCallId
-    );
-    if (toolCallMsg) {
-      toolCallMsg.toolCallStatus = "completed";
-      toolCallMsg.toolCallDuration = duration;
-      toolCallMsg.toolResult = this.serializeToolContent(result);
-    }
-    this.emit("tool_result", { toolCallId: toolCall.toolCallId, result, duration });
-    const toolResultMsg = {
-      id: crypto.randomUUID(),
-      role: "tool_result",
-      content: this.serializeToolContent(result),
-      toolCallId: toolCall.toolCallId,
-      toolName: toolCall.toolName,
-      timestamp: /* @__PURE__ */ new Date()
-    };
-    this.messages.push(toolResultMsg);
-  }
-  recordToolError(toolCall, error, resultContent, duration) {
-    const toolCallMsg = this.messages.find(
-      (m) => m.role === "tool_call" && m.toolCallId === toolCall.toolCallId
-    );
-    if (toolCallMsg) {
-      toolCallMsg.toolCallStatus = "error";
-      toolCallMsg.toolCallDuration = duration;
-      toolCallMsg.toolError = error;
-    }
-    this.emit("tool_error", { toolCallId: toolCall.toolCallId, error, duration });
-    const toolResultMsg = {
-      id: crypto.randomUUID(),
-      role: "tool_result",
-      content: resultContent,
-      toolCallId: toolCall.toolCallId,
-      toolName: toolCall.toolName,
-      timestamp: /* @__PURE__ */ new Date()
-    };
-    this.messages.push(toolResultMsg);
-  }
-  serializeToolContent(result) {
-    if (result == null) {
-      return "";
-    }
-    return typeof result === "string" ? result : JSON.stringify(result);
-  }
-  parseToolContent(content) {
-    if (!content) {
-      return "";
-    }
-    try {
-      return JSON.parse(content);
-    } catch {
-      return content;
-    }
-  }
-  parseToolArguments(argumentsJson) {
-    if (!argumentsJson.trim()) {
-      return {};
-    }
-    try {
-      const parsed = JSON.parse(argumentsJson);
-      return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
-    } catch {
-      return {};
-    }
-  }
-  getRecordField(record, key) {
-    const value = record?.[key];
-    return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
-  }
-  getStringField(record, key) {
-    const value = record?.[key];
-    return typeof value === "string" && value ? value : void 0;
-  }
-  getNumberField(record, key) {
-    const value = record?.[key];
-    return typeof value === "number" && Number.isFinite(value) ? value : void 0;
-  }
   async fetchConversationMessages(conversationId, cursor, pageSize = 50) {
     const token = await this.resolveAuthToken();
     const params = new URLSearchParams();
@@ -2599,7 +2291,7 @@ var McpStackAgent = class {
     };
   }
   /**
-   * Process a legacy chat SSE stream.
+   * Process an SSE stream from the chat API.
    * Returns when the stream ends (either message_end or tool_call).
    */
   async processSseStream(response) {