@yushaw/sanqian-chat 0.1.1 → 0.2.1

package/dist/core/index.js

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,16 +17,514 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/core/index.ts
 var core_exports = {};
 __export(core_exports, {
-  createSdkAdapter: () => createSdkAdapter
+  createChatAdapter: () => createChatAdapter,
+  createSdkAdapter: () => createSdkAdapter,
+  mergeConsecutiveAssistantMessages: () => mergeConsecutiveAssistantMessages,
+  parseToolCalls: () => parseToolCalls
 });
 module.exports = __toCommonJS(core_exports);
 
+// src/core/history.ts
+function safeParseArgs(value) {
+  if (!value) return void 0;
+  if (typeof value === "object") return value;
+  if (typeof value === "string") {
+    try {
+      return JSON.parse(value);
+    } catch {
+      return void 0;
+    }
+  }
+  return void 0;
+}
+function parseToolCalls(toolCalls) {
+  if (!toolCalls) return void 0;
+  let calls = toolCalls;
+  if (typeof calls === "string") {
+    try {
+      calls = JSON.parse(calls);
+    } catch {
+      return void 0;
+    }
+  }
+  if (!Array.isArray(calls)) return void 0;
+  return calls.map((tc) => {
+    const fn = tc.function || void 0;
+    const name = fn?.name || tc.name || tc.tool_name || "";
+    const rawArgs = fn?.arguments ?? tc.args ?? tc.arguments;
+    const args = safeParseArgs(rawArgs);
+    const id = tc.id || tc.tool_call_id || tc.call_id;
+    return {
+      id,
+      name,
+      args,
+      status: "completed",
+      result: tc.result
+    };
+  }).filter((tc) => tc.name || tc.id);
+}
+function getNumericMessageId(message) {
+  if (typeof message.message_id === "number") {
+    return message.message_id;
+  }
+  if (typeof message.id === "string" && /^\d+$/.test(message.id)) {
+    return Number(message.id);
+  }
+  return void 0;
+}
+function mergeConsecutiveAssistantMessages(rawMessages) {
+  const result = [];
+  let i = 0;
+  while (i < rawMessages.length) {
+    const msg = rawMessages[i];
+    const numericMessageId = getNumericMessageId(msg);
+    const messageId = numericMessageId ? `history-${numericMessageId}` : msg.id || `history-${i}`;
+    if (msg.role === "assistant") {
+      const consecutiveAssistantMsgs = [msg];
+      const toolMessages = [];
+      let j = i + 1;
+      while (j < rawMessages.length) {
+        if (rawMessages[j].role === "assistant") {
+          consecutiveAssistantMsgs.push(rawMessages[j]);
+          j++;
+        } else if (rawMessages[j].role === "tool") {
+          toolMessages.push(rawMessages[j]);
+          j++;
+        } else {
+          break;
+        }
+      }
+      const blocks = [];
+      let blockTime = Date.now();
+      let fallbackToolCalls;
+      let lastEffectiveToolCalls;
+      for (let k = 0; k < consecutiveAssistantMsgs.length; k++) {
+        const assistantMsg = consecutiveAssistantMsgs[k];
+        const msgToolCalls = parseToolCalls(assistantMsg.toolCalls || assistantMsg.tool_calls);
+        const isLastAssistant = k === consecutiveAssistantMsgs.length - 1;
+        const fallbackCalls = isLastAssistant && toolMessages.length > 0 ? toolMessages.map((toolMessage, idx) => ({
+          id: (toolMessage.tool_call_id || void 0) ?? `tool-${idx}`,
+          name: "",
+          args: void 0,
+          status: "completed",
+          result: toolMessage.content
+        })) : void 0;
+        const effectiveToolCalls = msgToolCalls && msgToolCalls.length > 0 ? msgToolCalls : fallbackCalls;
+        if (!msgToolCalls || msgToolCalls.length === 0) {
+          if (effectiveToolCalls && effectiveToolCalls.length > 0) {
+            fallbackToolCalls = effectiveToolCalls;
+          }
+        }
+        lastEffectiveToolCalls = effectiveToolCalls;
+        const hasToolCalls = effectiveToolCalls && effectiveToolCalls.length > 0;
+        if (assistantMsg.thinking && assistantMsg.thinking.trim()) {
+          blocks.push({
+            type: "thinking",
+            content: assistantMsg.thinking,
+            timestamp: blockTime++,
+            isIntermediate: true
+          });
+        }
+        const shouldDeferText = Boolean(hasToolCalls && isLastAssistant && toolMessages.length === 0);
+        const hasContent = Boolean(assistantMsg.content && assistantMsg.content.trim());
+        if (hasContent && !shouldDeferText) {
+          blocks.push({
+            type: "text",
+            content: assistantMsg.content,
+            timestamp: blockTime++,
+            isIntermediate: hasToolCalls || !isLastAssistant
+          });
+        }
+        if (effectiveToolCalls) {
+          const toolResultBlocks = [];
+          for (const tc of effectiveToolCalls) {
+            const toolIndex = effectiveToolCalls.indexOf(tc);
+            blocks.push({
+              type: "tool_call",
+              content: "",
+              timestamp: blockTime++,
+              toolName: tc.name,
+              toolArgs: tc.args,
+              toolCallId: tc.id,
+              toolStatus: "completed",
+              isIntermediate: true
+            });
+            const toolResultById = tc.id ? toolMessages.find((tm) => tm.tool_call_id === tc.id) : void 0;
+            const toolResultByIndex = toolMessages[toolIndex];
+            const toolResult = toolResultById || toolResultByIndex;
+            const resultContent = tc.result ?? toolResult?.content;
+            const toolResultId = toolResult?.tool_call_id || void 0;
+            if (resultContent) {
+              toolResultBlocks.push({
+                type: "tool_result",
+                content: resultContent,
+                timestamp: blockTime++,
+                toolName: tc.name,
+                toolCallId: tc.id || toolResultId,
+                isIntermediate: true
+              });
+              tc.result = resultContent;
+            }
+          }
+          blocks.push(...toolResultBlocks);
+        }
+        if (hasContent && shouldDeferText) {
+          blocks.push({
+            type: "text",
+            content: assistantMsg.content,
+            timestamp: blockTime++,
+            isIntermediate: false
+          });
+        }
+      }
+      if (consecutiveAssistantMsgs.length > 1) {
+        let contentMessages = consecutiveAssistantMsgs.filter(
+          (m) => !m.toolCalls && !m.tool_calls
+        );
+        if (contentMessages.length === 0) {
+          contentMessages = [consecutiveAssistantMsgs[consecutiveAssistantMsgs.length - 1]];
+        }
+        const mergedContent = contentMessages.map((m) => m.content).filter((c) => c && c.trim()).join("\n\n");
+        const mergedToolCalls = consecutiveAssistantMsgs.flatMap((m) => parseToolCalls(m.toolCalls || m.tool_calls) || []);
+        const effectiveMergedToolCalls = mergedToolCalls.length > 0 ? mergedToolCalls : fallbackToolCalls || [];
+        for (const toolMsg of toolMessages) {
+          const toolCallId = toolMsg.tool_call_id;
+          const matchingToolCall = effectiveMergedToolCalls.find(
+            (tc) => toolCallId && tc.id === toolCallId || !tc.result
+          );
+          if (matchingToolCall) {
+            matchingToolCall.result = toolMsg.content;
+          }
+        }
+        const thinkingParts = consecutiveAssistantMsgs.map((m) => m.thinking).filter((t) => t && t.trim());
+        const mergedThinking = thinkingParts.length > 1 ? thinkingParts.join("\n\u2500\u2500\u2500\u2500\u2500\n") : thinkingParts[0] || "";
+        const lastAssistantMsg = consecutiveAssistantMsgs[consecutiveAssistantMsgs.length - 1];
+        const lastToolMsg = toolMessages[toolMessages.length - 1];
+        const lastMsgId = Math.max(
+          getNumericMessageId(lastAssistantMsg) || 0,
+          lastToolMsg ? getNumericMessageId(lastToolMsg) || 0 : 0
+        );
+        const mergedMessageId = lastMsgId > 0 ? `history-${lastMsgId}` : messageId;
+        result.push({
+          id: mergedMessageId,
+          role: "assistant",
+          content: mergedContent,
+          timestamp: msg.timestamp || msg.created_at || (/* @__PURE__ */ new Date()).toISOString(),
+          toolCalls: effectiveMergedToolCalls.length > 0 ? effectiveMergedToolCalls : void 0,
+          thinking: mergedThinking || void 0,
+          filePaths: msg.filePaths,
+          blocks: blocks.length > 0 ? blocks : void 0,
+          isComplete: true
+        });
+        i = j;
+      } else {
+        result.push({
+          id: messageId,
+          role: "assistant",
+          content: msg.content || "",
+          timestamp: msg.timestamp || msg.created_at || (/* @__PURE__ */ new Date()).toISOString(),
+          toolCalls: lastEffectiveToolCalls,
+          thinking: msg.thinking || void 0,
+          filePaths: msg.filePaths,
+          blocks: blocks.length > 0 ? blocks : void 0,
+          isComplete: true
+        });
+        i++;
+      }
+    } else if (msg.role === "tool") {
+      i++;
+    } else {
+      result.push({
+        id: messageId,
+        role: msg.role,
+        content: msg.content || "",
+        timestamp: msg.timestamp || msg.created_at || (/* @__PURE__ */ new Date()).toISOString(),
+        toolCalls: parseToolCalls(msg.toolCalls || msg.tool_calls),
+        thinking: msg.thinking || void 0,
+        filePaths: msg.filePaths
+      });
+      i++;
+    }
+  }
+  return result;
+}
+
 // src/core/adapter.ts
+function createChatAdapter(config) {
+  let sdkInstance = null;
+  let sdkPromise = null;
+  let connectionStatus = "disconnected";
+  const connectionListeners = /* @__PURE__ */ new Set();
+  let currentRunId = null;
+  let reconnectAcquired = false;
+  const updateStatus = (status, error, errorCode) => {
+    connectionStatus = status;
+    connectionListeners.forEach((cb) => cb(status, error, errorCode));
+  };
+  const ensureSdk = async () => {
+    if (sdkInstance) return sdkInstance;
+    if (sdkPromise) return sdkPromise;
+    sdkPromise = (async () => {
+      const { SanqianSDK: SDK } = await import("@yushaw/sanqian-sdk");
+      const tools = config.tools?.map((t) => ({
+        name: t.name,
+        description: t.description,
+        parameters: t.parameters,
+        handler: t.handler
+      })).filter((t) => !!t.handler) || [];
+      sdkInstance = new SDK({
+        appName: config.appName,
+        appVersion: config.appVersion,
+        tools
+      });
+      return sdkInstance;
+    })();
+    return sdkPromise;
+  };
+  return {
+    async connect() {
+      if (reconnectAcquired) {
+        return;
+      }
+      updateStatus("connecting");
+      try {
+        const sdk = await ensureSdk();
+        sdk.on("connected", () => updateStatus("connected"));
+        sdk.on("disconnected", () => {
+          if (reconnectAcquired && connectionStatus !== "disconnected") {
+            updateStatus("reconnecting");
+          }
+        });
+        sdk.on("error", (err) => updateStatus("error", err.message, "CONNECTION_FAILED"));
+        sdk.acquireReconnect();
+        reconnectAcquired = true;
+        await sdk.ensureReady();
+        updateStatus("connected");
+      } catch (e) {
+        updateStatus("error", e instanceof Error ? e.message : "Connection failed", "CONNECTION_FAILED");
+        throw e;
+      }
+    },
+    async disconnect() {
+      if (sdkInstance) {
+        if (reconnectAcquired) {
+          sdkInstance.releaseReconnect();
+          reconnectAcquired = false;
+        }
+        sdkInstance.removeAllListeners();
+        await sdkInstance.disconnect();
+        sdkInstance = null;
+        sdkPromise = null;
+      }
+      updateStatus("disconnected");
+    },
+    isConnected() {
+      return sdkInstance?.isConnected() ?? false;
+    },
+    getConnectionStatus() {
+      return connectionStatus;
+    },
+    onConnectionChange(callback) {
+      connectionListeners.add(callback);
+      callback(connectionStatus);
+      return () => connectionListeners.delete(callback);
+    },
+    async listConversations(options) {
+      const sdk = await ensureSdk();
+      await sdk.ensureReady();
+      const result = await sdk.listConversations({ agentId: config.agentId, ...options });
+      return {
+        conversations: result.conversations.map((c) => ({
+          id: c.conversation_id,
+          title: c.title || "Untitled",
+          createdAt: c.created_at || "",
+          updatedAt: c.updated_at || "",
+          messageCount: c.message_count,
+          agentId: c.agent_id || null
+        })),
+        total: result.total
+      };
+    },
+    async getConversation(id, options) {
+      const sdk = await ensureSdk();
+      await sdk.ensureReady();
+      const detail = await sdk.getConversation(id, { messageLimit: options?.messageLimit });
+      let rawMessages = detail.messages || [];
+      const sdkWithHistory = sdk;
+      if (typeof sdkWithHistory.getMessages === "function") {
+        try {
+          const history = await sdkWithHistory.getMessages(id, { limit: options?.messageLimit });
+          if (history?.messages && history.messages.length > 0) {
+            rawMessages = history.messages;
+          }
+        } catch (e) {
+          console.warn("[sanqian-chat] getMessages failed, fallback to getConversation:", e);
+        }
+      }
+      const normalizedMessages = mergeConsecutiveAssistantMessages(
+        rawMessages.map((m, i) => ({
+          id: m.id || `msg-${i}`,
+          role: m.role,
+          content: m.content,
+          created_at: m.created_at || void 0,
+          tool_calls: m.tool_calls || m.toolCalls,
+          tool_call_id: m.tool_call_id ?? null,
+          thinking: m.thinking || void 0,
+          message_id: m.message_id,
+          filePaths: m.file_paths || m.filePaths
+        }))
+      );
+      return {
+        id: detail.conversation_id,
+        title: detail.title || "Untitled",
+        createdAt: detail.created_at || "",
+        updatedAt: detail.updated_at || "",
+        messageCount: detail.message_count,
+        agentId: detail.agent_id || null,
+        messages: normalizedMessages
+      };
+    },
+    async deleteConversation(id) {
+      const sdk = await ensureSdk();
+      await sdk.ensureReady();
+      await sdk.deleteConversation(id);
+    },
+    async chatStream(messages, conversationId, onEvent, options) {
+      const sdk = await ensureSdk();
+      await sdk.ensureReady();
+      const agentId = options?.agentId ?? config.agentId;
+      const sdkMessages = messages.map((m) => ({ role: m.role, content: m.content }));
+      const stream = sdk.chatStream(
+        agentId,
+        sdkMessages,
+        {
+          conversationId,
+          persistHistory: config.persistHistory ?? false
+        }
+      );
+      return processStreamEvents(stream, onEvent, sdk, (id) => {
+        currentRunId = id;
+      });
+    },
+    sendHitlResponse(response, runId) {
+      if (!sdkInstance) return;
+      const id = runId || currentRunId;
+      if (id) {
+        sdkInstance.sendHitlResponse(id, response);
+      }
+    }
+  };
+}
+function processStreamEvents(stream, onEvent, sdk, setCurrentRunId) {
+  const controller = new AbortController();
+  const signal = controller.signal;
+  let currentRunId = null;
+  (async () => {
+    try {
+      for await (const event of stream) {
+        if (signal.aborted) break;
+        switch (event.type) {
+          case "start":
+            if (event.run_id) {
+              currentRunId = event.run_id;
+              setCurrentRunId(event.run_id);
+              onEvent({ type: "start", run_id: event.run_id, conversationId: event.conversationId });
+            }
+            break;
+          case "text":
+            onEvent({ type: "text", content: event.content || "" });
+            break;
+          case "thinking":
+            onEvent({ type: "thinking", content: event.content || "" });
+            break;
+          case "tool_call":
+            if (event.tool_call) {
+              onEvent({ type: "tool_call", tool_call: event.tool_call });
+            }
+            break;
+          case "tool_args_chunk":
+            onEvent({
+              type: "tool_args_chunk",
+              tool_call_id: event.tool_call_id || "",
+              tool_name: event.tool_name,
+              chunk: event.chunk || ""
+            });
+            break;
+          case "tool_args":
+            onEvent({
+              type: "tool_args",
+              tool_call_id: event.tool_call_id || "",
+              tool_name: event.tool_name,
+              args: event.args || {}
+            });
+            break;
+          case "tool_result":
+            onEvent({ type: "tool_result", tool_call_id: event.tool_call_id || "", result: event.result });
+            break;
+          case "done":
+            onEvent({ type: "done", conversationId: event.conversationId || "", title: event.title });
+            currentRunId = null;
+            setCurrentRunId(null);
+            break;
+          case "cancelled":
+            onEvent({ type: "cancelled", run_id: event.run_id });
+            currentRunId = null;
+            setCurrentRunId(null);
+            break;
+          case "error":
+            onEvent({ type: "error", error: event.error || "Unknown error" });
+            currentRunId = null;
+            setCurrentRunId(null);
+            break;
+          default: {
+            const evt = event;
+            if (evt.type === "interrupt") {
+              currentRunId = evt.run_id || null;
+              setCurrentRunId(evt.run_id || null);
+              onEvent({
+                type: "interrupt",
+                interrupt_type: evt.interrupt_type || "",
+                interrupt_payload: evt.interrupt_payload,
+                run_id: evt.run_id
+              });
+            }
+            break;
+          }
+        }
+      }
+    } catch (e) {
+      if (!signal.aborted) {
+        onEvent({ type: "error", error: e instanceof Error ? e.message : "Stream error" });
+      }
+    }
+  })();
+  return {
+    cancel: () => {
+      controller.abort();
+      const sdkWithCancel = sdk;
+      if (currentRunId && typeof sdkWithCancel.cancelRun === "function") {
+        try {
+          sdkWithCancel.cancelRun(currentRunId);
+        } catch (e) {
+          console.warn("[chat adapter] Failed to cancel run:", e);
+        }
+      }
+    }
+  };
+}
 function createSdkAdapter(config) {
   let connectionStatus = "disconnected";
   const connectionListeners = /* @__PURE__ */ new Set();
@@ -47,6 +547,10 @@ function createSdkAdapter(config) {
       }
     },
     async disconnect() {
+      const sdk = config.getSdk();
+      if (sdk) {
+        await sdk.disconnect();
+      }
       updateStatus("disconnected");
     },
     isConnected() {
@@ -72,7 +576,8 @@ function createSdkAdapter(config) {
           title: c.title || "Untitled",
           createdAt: c.created_at || "",
           updatedAt: c.updated_at || "",
-          messageCount: c.message_count
+          messageCount: c.message_count,
+          agentId: c.agent_id || null
         })),
         total: result.total
       };
@@ -81,18 +586,39 @@ function createSdkAdapter(config) {
       const sdk = config.getSdk();
       if (!sdk) throw new Error("SDK not ready");
       const detail = await sdk.getConversation(id, { messageLimit: options?.messageLimit });
+      let rawMessages = detail.messages || [];
+      const sdkWithHistory = sdk;
+      if (typeof sdkWithHistory.getMessages === "function") {
+        try {
+          const history = await sdkWithHistory.getMessages(id, { limit: options?.messageLimit });
+          if (history?.messages && history.messages.length > 0) {
+            rawMessages = history.messages;
+          }
+        } catch (e) {
+          console.warn("[sanqian-chat] getMessages failed, fallback to getConversation:", e);
+        }
+      }
+      const normalizedMessages = mergeConsecutiveAssistantMessages(
+        rawMessages.map((m, i) => ({
+          id: m.id || `msg-${i}`,
+          role: m.role,
+          content: m.content,
+          created_at: m.created_at || void 0,
+          tool_calls: m.tool_calls || m.toolCalls,
+          tool_call_id: m.tool_call_id ?? null,
+          thinking: m.thinking || void 0,
+          message_id: m.message_id,
+          filePaths: m.file_paths || m.filePaths
+        }))
+      );
       return {
         id: detail.conversation_id,
         title: detail.title || "Untitled",
         createdAt: detail.created_at || "",
         updatedAt: detail.updated_at || "",
         messageCount: detail.message_count,
-        messages: (detail.messages || []).map((m, i) => ({
-          id: `msg-${i}`,
-          role: m.role,
-          content: m.content,
-          timestamp: m.created_at || (/* @__PURE__ */ new Date()).toISOString()
-        }))
+        agentId: detail.agent_id || null,
+        messages: normalizedMessages
       };
     },
     async deleteConversation(id) {
@@ -100,65 +626,20 @@ function createSdkAdapter(config) {
       if (!sdk) throw new Error("SDK not ready");
       await sdk.deleteConversation(id);
     },
-    async chatStream(messages, conversationId, onEvent) {
+    async chatStream(messages, conversationId, onEvent, options) {
       const sdk = config.getSdk();
-      const agentId = config.getAgentId();
+      const agentId = options?.agentId ?? config.getAgentId();
       if (!sdk || !agentId) throw new Error("SDK or agent not ready");
       await sdk.ensureReady();
       const sdkMessages = messages.map((m) => ({ role: m.role, content: m.content }));
-      const stream = sdk.chatStream(agentId, sdkMessages, { conversationId });
-      const controller = new AbortController();
-      const signal = controller.signal;
-      (async () => {
-        try {
-          for await (const event of stream) {
-            if (signal.aborted) break;
-            switch (event.type) {
-              case "text":
-                onEvent({ type: "text", content: event.content || "" });
-                break;
-              case "thinking":
-                onEvent({ type: "thinking", content: event.content || "" });
-                break;
-              case "tool_call":
-                if (event.tool_call) {
-                  onEvent({ type: "tool_call", tool_call: event.tool_call });
-                }
-                break;
-              case "tool_result":
-                onEvent({ type: "tool_result", tool_call_id: event.tool_call_id || "", result: event.result });
-                break;
-              case "done":
-                onEvent({ type: "done", conversationId: event.conversationId || "", title: event.title });
-                break;
-              case "error":
-                onEvent({ type: "error", error: event.error || "Unknown error" });
-                break;
-              default:
-                const evt = event;
-                if (evt.type === "interrupt") {
-                  currentRunId = evt.run_id || null;
-                  onEvent({
-                    type: "interrupt",
-                    interrupt_type: evt.interrupt_type || "",
-                    interrupt_payload: evt.interrupt_payload,
-                    run_id: evt.run_id
-                  });
-                }
-                break;
-            }
-          }
-        } catch (e) {
-          if (!signal.aborted) {
-            onEvent({ type: "error", error: e instanceof Error ? e.message : "Stream error" });
-          }
-        }
-      })();
-      return {
-        cancel: () => {
-          controller.abort();
-        }
-      };
+      const stream = sdk.chatStream(
+        agentId,
+        sdkMessages,
+        { conversationId }
+      );
+      return processStreamEvents(stream, onEvent, sdk, (id) => {
+        currentRunId = id;
+      });
     },
     sendHitlResponse(response, runId) {
       const sdk = config.getSdk();
@@ -172,5 +653,8 @@ function createSdkAdapter(config) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  createSdkAdapter
+  createChatAdapter,
+  createSdkAdapter,
+  mergeConsecutiveAssistantMessages,
+  parseToolCalls
 });