@zhongqian97-code/ecode 0.5.36 → 0.5.37

package/dist/{chunk-BRSZMOHF.js → chunk-7DHMJ6NS.js}

@@ -202,9 +202,229 @@ function createOpenAIProvider(profile) {
   };
 }
 
+// src/providers/anthropic.ts
+import https from "https";
+import { URL as URL2 } from "url";
+function convertMessagesToAnthropic(messages) {
+  let system = "";
+  const anthropicMessages = [];
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[i];
+    if (msg.role === "system") {
+      system = msg.content;
+      continue;
+    }
+    if (msg.role === "user") {
+      anthropicMessages.push({ role: "user", content: msg.content });
+      continue;
+    }
+    if (msg.role === "tool") {
+      const toolResults = [];
+      while (i < messages.length && messages[i].role === "tool") {
+        const toolMsg = messages[i];
+        toolResults.push({
+          type: "tool_result",
+          tool_use_id: toolMsg.tool_call_id,
+          content: toolMsg.content
+        });
+        i++;
+      }
+      i--;
+      anthropicMessages.push({ role: "user", content: toolResults });
+      continue;
+    }
+    if (msg.role === "assistant") {
+      if (msg.tool_calls && msg.tool_calls.length > 0) {
+        const content = [];
+        if (msg.content) content.push({ type: "text", text: msg.content });
+        for (const tc of msg.tool_calls) {
+          let input = {};
+          try {
+            input = JSON.parse(tc.function.arguments);
+          } catch {
+            input = {};
+          }
+          content.push({ type: "tool_use", id: tc.id, name: tc.function.name, input });
+        }
+        anthropicMessages.push({ role: "assistant", content });
+      } else {
+        anthropicMessages.push({ role: "assistant", content: msg.content ?? "" });
+      }
+    }
+  }
+  return { system, anthropicMessages };
+}
+function convertToolsToAnthropic(tools) {
+  return tools.map((tool) => ({
+    name: tool.function.name,
+    description: tool.function.description,
+    input_schema: tool.function.parameters
+  }));
+}
+function createAnthropicProvider(profile) {
+  const capabilities = Object.freeze(
+    Object.defineProperties({}, {
+      supportsTools: { value: true, writable: false, enumerable: true },
+      supportsReasoningStream: { value: false, writable: false, enumerable: true },
+      supportsImages: { value: true, writable: false, enumerable: true },
+      supportsJsonSchema: { value: true, writable: false, enumerable: true }
+    })
+  );
+  return {
+    capabilities,
+    stream(messages, tools, signal) {
+      return streamAnthropicResponse(profile, messages, tools, signal);
+    }
+  };
+}
+async function* streamAnthropicResponse(profile, messages, tools, signal) {
+  const { system, anthropicMessages } = convertMessagesToAnthropic(messages);
+  const endpointUrl = new URL2(`${profile.baseUrl.replace(/\/$/, "")}/v1/messages`);
+  const requestBody = {
+    model: profile.model,
+    max_tokens: 8192,
+    messages: anthropicMessages,
+    stream: true
+  };
+  if (system) requestBody.system = system;
+  if (tools && tools.length > 0) requestBody.tools = convertToolsToAnthropic(tools);
+  const bodyStr = JSON.stringify(requestBody);
+  yield* makeHttpsStream(endpointUrl, profile.apiKey, bodyStr, signal);
+}
+async function* makeHttpsStream(url, apiKey, body, signal) {
+  var _a;
+  const queue = [];
+  let notify = null;
+  function push(item) {
+    queue.push(item);
+    if (notify) {
+      const fn = notify;
+      notify = null;
+      fn();
+    }
+  }
+  const port = url.port ? parseInt(url.port, 10) : 443;
+  const req = https.request(
+    {
+      hostname: url.hostname,
+      port,
+      path: url.pathname + url.search,
+      method: "POST",
+      headers: {
+        "x-api-key": apiKey,
+        "anthropic-version": "2023-06-01",
+        "content-type": "application/json",
+        accept: "text/event-stream",
+        "content-length": String(Buffer.byteLength(body, "utf8"))
+      }
+    },
+    (res) => {
+      const statusCode = res.statusCode;
+      if (statusCode !== 200) {
+        push(new Error(`Anthropic API error: HTTP ${statusCode}`));
+        return;
+      }
+      const r = res;
+      r.on("data", (chunk) => push(chunk));
+      r.on("end", () => push(null));
+      r.on("error", (err) => push(err));
+    }
+  );
+  req.on("error", (err) => push(err));
+  if (signal) {
+    signal.addEventListener(
+      "abort",
+      () => {
+        req.destroy();
+        push(null);
+      },
+      { once: true }
+    );
+  }
+  req.write(body);
+  req.end();
+  let buffer = "";
+  const toolBlocks = /* @__PURE__ */ new Map();
+  let stopReason = null;
+  let inputTokens = 0;
+  let outputTokens = 0;
+  while (true) {
+    let item;
+    if (queue.length > 0) {
+      item = queue.shift();
+    } else {
+      await new Promise((resolve4) => {
+        notify = resolve4;
+      });
+      item = queue.shift();
+    }
+    if (item === null) break;
+    if (item instanceof Error) throw item;
+    buffer += item.toString("utf8");
+    const lines = buffer.split("\n");
+    buffer = lines.pop() ?? "";
+    for (const line of lines) {
+      if (!line.startsWith("data: ")) continue;
+      const data = line.slice(6).trim();
+      if (data === "[DONE]") break;
+      let event;
+      try {
+        event = JSON.parse(data);
+      } catch {
+        continue;
+      }
+      const eventType = event.type;
+      if (eventType === "message_start") {
+        const msg = event.message;
+        if ((_a = msg == null ? void 0 : msg.usage) == null ? void 0 : _a.input_tokens) inputTokens = msg.usage.input_tokens;
+      } else if (eventType === "content_block_start") {
+        const block = event.content_block;
+        const index = event.index;
+        if ((block == null ? void 0 : block.type) === "tool_use" && block.id && block.name) {
+          toolBlocks.set(index, { id: block.id, name: block.name, jsonAccum: "" });
+        }
+      } else if (eventType === "content_block_delta") {
+        const delta = event.delta;
+        const index = event.index;
+        if ((delta == null ? void 0 : delta.type) === "text_delta" && delta.text) {
+          yield { text: delta.text, done: false };
+        } else if ((delta == null ? void 0 : delta.type) === "input_json_delta" && delta.partial_json) {
+          const tool = toolBlocks.get(index);
+          if (tool) tool.jsonAccum += delta.partial_json;
+        }
+      } else if (eventType === "message_delta") {
+        const delta = event.delta;
+        stopReason = (delta == null ? void 0 : delta.stop_reason) ?? null;
+        const usage = event.usage;
+        if (usage == null ? void 0 : usage.output_tokens) outputTokens = usage.output_tokens;
+      } else if (eventType === "message_stop") {
+        const toolCalls = [...toolBlocks.values()].map((t) => ({
+          id: t.id,
+          name: t.name,
+          arguments: t.jsonAccum
+        }));
+        yield {
+          done: true,
+          text: "",
+          finishReason: stopReason,
+          toolCalls: toolCalls.length > 0 ? toolCalls : void 0,
+          usage: {
+            promptTokens: inputTokens,
+            completionTokens: outputTokens,
+            totalTokens: inputTokens + outputTokens
+          }
+        };
+        return;
+      }
+    }
+  }
+  yield { done: true, text: "", finishReason: stopReason };
+}
+
 // src/providers/index.ts
 function createProvider(profile) {
-  return createOpenAIProvider(profile);
+  const useAnthropic = profile.apiFormat === "anthropic" || profile.baseUrl.includes("anthropic");
+  return useAnthropic ? createAnthropicProvider(profile) : createOpenAIProvider(profile);
 }
 function resolveActiveProfile(config, providerName) {
   var _a, _b;
@@ -646,7 +866,7 @@ async function grepFiles(params) {
 
 // src/tools/web_fetch.ts
 import * as http from "http";
-import * as https from "https";
+import * as https2 from "https";
 var WEB_FETCH_TOOL = {
   type: "function",
   function: {
@@ -807,7 +1027,7 @@ async function nodeHttpFetch(url, signal) {
   return new Promise((resolve4, reject) => {
     const parsed = new URL(url);
     const isHttps = parsed.protocol === "https:";
-    const lib = isHttps ? https : http;
+    const lib = isHttps ? https2 : http;
     const onAbort = () => {
       req.destroy();
       const err = new Error("The user aborted a request.");

package/dist/index.js

@@ -34,7 +34,7 @@ import {
   todo,
   webFetch,
   writeFile
-} from "./chunk-BRSZMOHF.js";
+} from "./chunk-7DHMJ6NS.js";
 import {
   createSessionMetadata,
   generateTitle,
@@ -231,7 +231,10 @@ var EventBus = class {
   /** 发布事件，同步调用所有当前订阅者 */
   emit(event) {
     for (const listener of this.listeners) {
-      listener(event);
+      try {
+        listener(event);
+      } catch {
+      }
     }
   }
   /** 添加事件监听器，返回取消订阅函数 */
@@ -902,6 +905,6 @@ Node.js 16/18 \u8BF7\u4F7F\u7528 --web \u6216 --pipe \u6A21\u5F0F\u3002
     );
     process.exit(1);
   }
-  const { App, React, render } = await import("./ui-QZG4SHLC.js");
+  const { App, React, render } = await import("./ui-XL5IDLH5.js");
   render(React.createElement(App, { config: finalConfig, version: VERSION, autoMode, registry, trustedSkillDirs, initialMessages }));
 }

package/dist/{ui-QZG4SHLC.js → ui-XL5IDLH5.js}

@@ -26,7 +26,7 @@ import {
   todo,
   webFetch,
   writeFile
-} from "./chunk-BRSZMOHF.js";
+} from "./chunk-7DHMJ6NS.js";
 import {
   loadJobs,
   removeJob,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhongqian97-code/ecode",
-  "version": "0.5.36",
+  "version": "0.5.37",
   "description": "A minimal Claude Code clone with REPL interface and bash tool calling",
   "type": "module",
   "author": "zhongqian97-code",