@prestyj/ai 4.2.16 → 4.2.45

package/dist/index.js

@@ -16,9 +16,6 @@ var ProviderError = class extends GGAIError {
   }
 };
 
-// src/providers/anthropic.ts
-import Anthropic from "@anthropic-ai/sdk";
-
 // src/utils/event-stream.ts
 var EventStream = class {
   queue = [];
@@ -26,8 +23,8 @@ var EventStream = class {
   done = false;
   error = null;
   push(event) {
-    if (this.queue.length > 5e4) {
-      this.queue.splice(0, this.queue.length - 25e3);
+    if (this.queue.length > 1e4) {
+      this.queue.splice(0, this.queue.length - 5e3);
     }
     this.queue.push(event);
     this.resolve?.();
@@ -101,6 +98,9 @@ var StreamResult = class {
   }
 };
 
+// src/providers/anthropic.ts
+import Anthropic from "@anthropic-ai/sdk";
+
 // src/utils/zod-to-json-schema.ts
 import { z } from "zod";
 function zodToJsonSchema(schema) {
@@ -280,15 +280,24 @@ function remapToolCallId(id, idMap) {
   idMap.set(id, mapped);
   return mapped;
 }
-function toOpenAIMessages(messages) {
+function toOpenAIMessages(messages, options) {
   const out = [];
   const idMap = /* @__PURE__ */ new Map();
+  const mergeToolResultText = options?.provider === "glm";
   for (const msg of messages) {
     if (msg.role === "system") {
       out.push({ role: "system", content: msg.content });
       continue;
     }
     if (msg.role === "user") {
+      if (mergeToolResultText && out.length > 0 && out[out.length - 1].role === "tool") {
+        const userText = typeof msg.content === "string" ? msg.content : msg.content.filter((p) => p.type === "text").map((p) => p.text).join("");
+        if (userText) {
+          const lastTool = out[out.length - 1];
+          lastTool.content = (lastTool.content ?? "") + "\n\n" + userText;
+          continue;
+        }
+      }
       if (typeof msg.content === "string") {
         out.push({ role: "user", content: msg.content });
       } else {
@@ -403,10 +412,24 @@ async function runStream(options, result) {
   const isOAuth = options.apiKey?.startsWith("sk-ant-oat");
   const client = new Anthropic({
     ...isOAuth ? { apiKey: null, authToken: options.apiKey } : { apiKey: options.apiKey },
-    ...options.baseUrl ? { baseURL: options.baseUrl } : {}
+    ...options.baseUrl ? { baseURL: options.baseUrl } : {},
+    ...options.fetch ? { fetch: options.fetch } : {},
+    ...isOAuth ? {
+      defaultHeaders: {
+        "user-agent": "claude-cli/2.1.75",
+        "x-app": "cli"
+      }
+    } : {}
   });
   const cacheControl = toAnthropicCacheControl(options.cacheRetention, options.baseUrl);
-  const { system, messages } = toAnthropicMessages(options.messages, cacheControl);
+  const { system: rawSystem, messages } = toAnthropicMessages(options.messages, cacheControl);
+  const system = isOAuth ? [
+    {
+      type: "text",
+      text: "You are Claude Code, Anthropic's official CLI for Claude."
+    },
+    ...rawSystem ?? []
+  ] : rawSystem;
   let maxTokens = options.maxTokens ?? 4096;
   let thinking;
   let outputConfig;
@@ -440,7 +463,7 @@ async function runStream(options, result) {
     stream: true
   };
   const betaHeaders = [
-    ...isOAuth ? ["oauth-2025-04-20"] : [],
+    ...isOAuth ? ["claude-code-20250219", "oauth-2025-04-20"] : [],
     ...options.compaction ? ["compact-2026-01-12"] : []
   ];
   const stream2 = client.messages.stream(params, {
@@ -583,16 +606,19 @@ function streamOpenAI(options) {
 async function runStream2(options, result) {
   const client = new OpenAI({
     apiKey: options.apiKey,
-    ...options.baseUrl ? { baseURL: options.baseUrl } : {}
+    ...options.baseUrl ? { baseURL: options.baseUrl } : {},
+    ...options.fetch ? { fetch: options.fetch } : {}
   });
   const usesThinkingParam = options.provider === "glm" || options.provider === "moonshot";
-  const messages = toOpenAIMessages(options.messages);
+  const messages = toOpenAIMessages(options.messages, { provider: options.provider });
+  const defaultTemp = options.provider === "glm" ? 0.6 : void 0;
+  const effectiveTemp = options.temperature ?? defaultTemp;
   const params = {
     model: options.model,
     messages,
     stream: true,
     ...options.maxTokens ? { max_tokens: options.maxTokens } : {},
-    ...options.temperature != null && !options.thinking ? { temperature: options.temperature } : {},
+    ...effectiveTemp != null && !options.thinking ? { temperature: effectiveTemp } : {},
     ...options.topP != null ? { top_p: options.topP } : {},
     ...options.stop ? { stop: options.stop } : {},
     ...options.thinking && !usesThinkingParam ? { reasoning_effort: toOpenAIReasoningEffort(options.thinking) } : {},
@@ -709,7 +735,7 @@ async function runStream2(options, result) {
   result.push({ type: "done", stopReason });
   result.complete(response);
 }
-function toError2(err, provider) {
+function toError2(err, provider = "openai") {
   if (err instanceof OpenAI.APIError) {
     let msg = err.message;
     const body = err.error;
@@ -1035,37 +1061,129 @@ function toError3(err) {
   return new ProviderError("openai", String(err));
 }
 
+// src/provider-registry.ts
+var ProviderRegistryImpl = class {
+  providers = /* @__PURE__ */ new Map();
+  /**
+   * Register a provider. Overwrites any existing provider with the same name.
+   *
+   * ```ts
+   * import { providerRegistry } from "@prestyj/ai";
+   *
+   * providerRegistry.register("deepseek", {
+   *   stream: (options) => streamOpenAI({ ...options, baseUrl: "https://api.deepseek.com/v1" }),
+   * });
+   * ```
+   */
+  register(name, entry) {
+    this.providers.set(name, entry);
+  }
+  /** Remove a registered provider. */
+  unregister(name) {
+    return this.providers.delete(name);
+  }
+  /** Get a provider entry by name. */
+  get(name) {
+    return this.providers.get(name);
+  }
+  /** Check if a provider is registered. */
+  has(name) {
+    return this.providers.has(name);
+  }
+  /** List all registered provider names. */
+  list() {
+    return [...this.providers.keys()];
+  }
+};
+var providerRegistry = new ProviderRegistryImpl();
+
 // src/stream.ts
+var GLM_CODING_BASE_URL = "https://api.z.ai/api/coding/paas/v4";
+var GLM_REGULAR_BASE_URL = "https://api.z.ai/api/paas/v4";
+providerRegistry.register("anthropic", {
+  stream: (options) => streamAnthropic(options)
+});
+providerRegistry.register("openai", {
+  stream: (options) => {
+    if (options.accountId) {
+      return streamOpenAICodex(options);
+    }
+    return streamOpenAI(options);
+  }
+});
+providerRegistry.register("glm", {
+  stream: (options) => {
+    if (options.baseUrl) {
+      return streamOpenAI(options);
+    }
+    return streamGLMWithFallback(options);
+  }
+});
+providerRegistry.register("moonshot", {
+  stream: (options) => streamOpenAI({
+    ...options,
+    baseUrl: options.baseUrl ?? "https://api.moonshot.ai/v1"
+  })
+});
 function stream(options) {
-  switch (options.provider) {
-    case "anthropic":
-      return streamAnthropic(options);
-    case "openai":
-      if (options.accountId) {
-        return streamOpenAICodex(options);
+  const entry = providerRegistry.get(options.provider);
+  if (!entry) {
+    throw new GGAIError(
+      `Unknown provider: "${options.provider}". Registered: ${providerRegistry.list().join(", ")}`
+    );
+  }
+  return entry.stream(options);
+}
+function streamGLMWithFallback(options) {
+  const result = new StreamResult();
+  runGLMWithFallback(options, result).catch((err) => {
+    result.abort(err instanceof Error ? err : new Error(String(err)));
+  });
+  return result;
+}
+async function runGLMWithFallback(options, result) {
+  const codingResult = streamOpenAI({ ...options, baseUrl: GLM_CODING_BASE_URL });
+  try {
+    for await (const event of codingResult) {
+      result.push(event);
+    }
+    const response = await codingResult.response;
+    result.complete(response);
+  } catch (err) {
+    if (isEndpointMismatchError(err)) {
+      const regularResult = streamOpenAI({ ...options, baseUrl: GLM_REGULAR_BASE_URL });
+      try {
+        for await (const event of regularResult) {
+          result.push(event);
+        }
+        const response = await regularResult.response;
+        result.complete(response);
+      } catch (fallbackErr) {
+        result.abort(fallbackErr instanceof Error ? fallbackErr : new Error(String(fallbackErr)));
       }
-      return streamOpenAI(options);
-    case "glm":
-      return streamOpenAI({
-        ...options,
-        baseUrl: options.baseUrl ?? "https://api.z.ai/api/coding/paas/v4"
-      });
-    case "moonshot":
-      return streamOpenAI({
-        ...options,
-        baseUrl: options.baseUrl ?? "https://api.moonshot.ai/v1"
-      });
-    default:
-      throw new GGAIError(
-        `Unknown provider: ${options.provider}. Supported: "anthropic", "openai", "glm", "moonshot"`
-      );
+    } else {
+      result.abort(err instanceof Error ? err : new Error(String(err)));
+    }
+  }
+}
+function isEndpointMismatchError(err) {
+  if (err instanceof ProviderError) {
+    if (err.statusCode === 404 || err.statusCode === 403) return true;
+  }
+  if (err instanceof Error) {
+    const msg = err.message.toLowerCase();
+    if (msg.includes("model_not_found") || msg.includes("does not exist") || /model.*not.*exist/.test(msg) || /not have access/.test(msg) || msg.includes("resource not found")) {
+      return true;
+    }
   }
+  return false;
 }
 export {
   EventStream,
   GGAIError,
   ProviderError,
   StreamResult,
+  providerRegistry,
   stream
 };
 //# sourceMappingURL=index.js.map