@kenkaiiii/gg-ai 4.4.0 → 4.5.0

package/dist/index.cjs

@@ -79,6 +79,12 @@ var GGAIError = class extends Error {
     this.hint = options?.hint;
   }
 };
+var VideoUnsupportedError = class extends GGAIError {
+  constructor() {
+    super("This model can't analyze video.", { source: "capability" });
+    this.name = "VideoUnsupportedError";
+  }
+};
 var ProviderError = class extends GGAIError {
   provider;
   statusCode;
@@ -194,6 +200,14 @@ function finaliseBySource(source, message, requestId, hint) {
         guidance: hint ?? providerGuidance(void 0, message, void 0),
         ...requestId ? { requestId } : {}
       };
+    case "capability":
+      return {
+        headline: message,
+        source,
+        message: "",
+        guidance: hint ?? "Only Kimi, Gemini, and MiniMax can analyze video. Switch with /model.",
+        ...requestId ? { requestId } : {}
+      };
     case "ggcoder":
       return {
         headline: "ggcoder hit an unexpected error.",
@@ -554,6 +568,10 @@ function toolResultImages(content) {
   if (typeof content === "string") return [];
   return content.filter((b) => b.type === "image");
 }
+function toolResultVideos(content) {
+  if (typeof content === "string") return [];
+  return content.filter((b) => b.type === "video");
+}
 function toAnthropicCacheControl(retention, baseUrl) {
   const resolved = retention ?? "short";
   if (resolved === "none") return void 0;
@@ -564,6 +582,12 @@ function toAnthropicToolResultContent(content) {
   if (typeof content === "string") return content;
   return content.map((block) => {
     if (block.type === "text") return { type: "text", text: block.text };
+    if (block.type === "video") {
+      return {
+        type: "video",
+        source: { type: "base64", media_type: block.mediaType, data: block.data }
+      };
+    }
     return {
       type: "image",
       source: {
@@ -633,6 +657,8 @@ function toAnthropicMessages(messages, cacheControl) {
     if (msg.role === "tool") {
       out.push({
         role: "user",
+        // Cast covers the video block (used by the Anthropic-compatible MiniMax
+        // API), which isn't in the first-party Anthropic tool_result types.
         content: msg.content.map((result) => ({
           type: "tool_result",
           tool_use_id: remapAnthropicToolCallId(result.toolCallId, idMap),
@@ -773,11 +799,10 @@ function toOpenAIMessages(messages, options) {
             (part) => {
               if (part.type === "text") return { type: "text", text: part.text };
               if (part.type === "video") {
+                const videoUrl = part.fileId ? { url: `ms://${part.fileId}`, id: part.fileId } : { url: `data:${part.mediaType};base64,${part.data}` };
                 return {
                   type: "video_url",
-                  video_url: {
-                    url: `data:${part.mediaType};base64,${part.data}`
-                  }
+                  video_url: videoUrl
                 };
               }
               return {
@@ -822,11 +847,27 @@ function toOpenAIMessages(messages, options) {
       continue;
     }
     if (msg.role === "tool") {
+      const isMoonshot = options?.provider === "moonshot";
       const imageBlocks = [];
       for (const result of msg.content) {
         const text = toolResultText(result.content);
         const images = toolResultImages(result.content);
+        const videos = isMoonshot ? toolResultVideos(result.content) : [];
         const hasText = text.length > 0;
+        if (videos.length > 0) {
+          const parts = [];
+          if (hasText) parts.push({ type: "text", text });
+          const videoParts = videos.map((v) => {
+            const videoUrl = v.fileId ? { url: `ms://${v.fileId}`, id: v.fileId } : { url: `data:${v.mediaType};base64,${v.data}` };
+            return { type: "video_url", video_url: videoUrl };
+          });
+          out.push({
+            role: "tool",
+            tool_call_id: remapToolCallId(result.toolCallId, idMap),
+            content: [...parts, ...videoParts]
+          });
+          continue;
+        }
         out.push({
           role: "tool",
           tool_call_id: remapToolCallId(result.toolCallId, idMap),
@@ -1411,6 +1452,75 @@ function fnv1aHash(value) {
   return (hash >>> 0).toString(16).padStart(8, "0");
 }
 
+// src/utils/diag.ts
+var _diagFn = null;
+function setProviderDiagnostic(fn) {
+  _diagFn = fn;
+}
+function providerDiag(phase, data) {
+  _diagFn?.(phase, data);
+}
+
+// src/providers/moonshot-video.ts
+async function uploadMoonshotVideos(client, messages, signal) {
+  for (const msg of messages) {
+    if (typeof msg.content === "string") continue;
+    for (const part of msg.content) {
+      if (part.type === "video") {
+        await ensureUploaded(client, part, signal);
+        continue;
+      }
+      if (part.type === "tool_result" && Array.isArray(part.content)) {
+        for (const inner of part.content) {
+          if (inner.type === "video") {
+            await ensureUploaded(client, inner, signal);
+          }
+        }
+      }
+    }
+  }
+}
+async function ensureUploaded(client, video, signal) {
+  if (video.fileId) {
+    providerDiag("moonshot_video_cached", { fileId: video.fileId });
+    return;
+  }
+  if (!video.data) {
+    providerDiag("moonshot_video_skipped_no_data", {});
+    return;
+  }
+  providerDiag("moonshot_video_upload_start", {
+    mediaType: video.mediaType,
+    bytes: Math.floor(video.data.length * 3 / 4)
+  });
+  video.fileId = await uploadOne(client, video, signal);
+  providerDiag("moonshot_video_upload_done", { fileId: video.fileId });
+}
+async function uploadOne(client, video, signal) {
+  const bytes = Buffer.from(video.data, "base64");
+  const mediaType = video.mediaType || "video/mp4";
+  const filename = `upload.${extForMime(mediaType)}`;
+  const file = new File([new Uint8Array(bytes)], filename, { type: mediaType });
+  const uploaded = await client.files.create(
+    { file, purpose: "video" },
+    signal ? { signal } : void 0
+  );
+  return uploaded.id;
+}
+var MIME_TO_EXT = {
+  "video/mp4": "mp4",
+  "video/mpeg": "mpeg",
+  "video/quicktime": "mov",
+  "video/webm": "webm",
+  "video/x-matroska": "mkv",
+  "video/x-msvideo": "avi",
+  "video/x-flv": "flv",
+  "video/3gpp": "3gp"
+};
+function extForMime(mediaType) {
+  return MIME_TO_EXT[mediaType.toLowerCase()] ?? "mp4";
+}
+
 // src/utils/env.ts
 function getEnvironment() {
   return globalThis.process?.env;
@@ -1440,7 +1550,8 @@ function createClient2(options) {
   return new import_openai.default({
     apiKey: options.apiKey,
     ...options.baseUrl ? { baseURL: options.baseUrl } : {},
-    ...options.fetch ? { fetch: options.fetch } : {}
+    ...options.fetch ? { fetch: options.fetch } : {},
+    ...options.defaultHeaders ? { defaultHeaders: options.defaultHeaders } : {}
   });
 }
 function streamOpenAI(options) {
@@ -1453,6 +1564,13 @@ async function* runStream2(options) {
   const usesThinkingParam = options.provider === "glm" || options.provider === "moonshot" || options.provider === "xiaomi";
   const downgradedImages = downgradeUnsupportedImages(options.messages, options.supportsImages);
   const downgradedMessages = downgradeUnsupportedVideos(downgradedImages, options.supportsVideo);
+  if (options.provider === "moonshot") {
+    try {
+      await uploadMoonshotVideos(client, downgradedMessages, options.signal);
+    } catch (err) {
+      throw toError2(err, providerName);
+    }
+  }
   const messages = toOpenAIMessages(downgradedMessages, {
     provider: options.provider,
     thinking: !!options.thinking,
@@ -1756,15 +1874,6 @@ function toError2(err, provider = "openai") {
 // src/providers/openai-codex.ts
 var import_node_os = __toESM(require("os"), 1);
 
-// src/utils/diag.ts
-var _diagFn = null;
-function setProviderDiagnostic(fn) {
-  _diagFn = fn;
-}
-function providerDiag(phase, data) {
-  _diagFn?.(phase, data);
-}
-
 // src/utils/sse.ts
 function parseSseBuffer(buffer) {
   const events = [];
@@ -2413,6 +2522,13 @@ ${msg.content}` : msg.content;
             }
           }
         });
+        if (typeof result.content !== "string") {
+          for (const block of result.content) {
+            if (block.type === "video") {
+              parts.push({ inlineData: { mimeType: block.mediaType, data: block.data } });
+            }
+          }
+        }
       }
       if (parts.length > 0) contents.push({ role: "user", parts });
     }
@@ -2810,6 +2926,7 @@ var providerRegistry = new ProviderRegistryImpl();
 
 // src/stream.ts
 var GLM_CODING_BASE_URL = "https://api.z.ai/api/coding/paas/v4";
+var KIMI_CODE_USER_AGENT = `kimi-code-cli/${process.env.KIMI_CODE_VERSION ?? "1.0.11"}`;
 providerRegistry.register("anthropic", {
   stream: (options) => streamAnthropic(options)
 });
@@ -2838,10 +2955,11 @@ providerRegistry.register("glm", {
   })
 });
 providerRegistry.register("moonshot", {
-  stream: (options) => streamOpenAI({
-    ...options,
-    baseUrl: options.baseUrl ?? "https://api.moonshot.ai/v1"
-  })
+  stream: (options) => {
+    const baseUrl = options.baseUrl ?? "https://api.moonshot.ai/v1";
+    const defaultHeaders = baseUrl.includes("api.kimi.com") ? { "User-Agent": KIMI_CODE_USER_AGENT, ...options.defaultHeaders } : options.defaultHeaders;
+    return streamOpenAI({ ...options, baseUrl, defaultHeaders });
+  }
 });
 providerRegistry.register("deepseek", {
   stream: (options) => streamOpenAI({
@@ -2874,8 +2992,23 @@ function stream(options) {
       `Unknown provider: "${options.provider}". Registered: ${providerRegistry.list().join(", ")}`
     );
   }
+  if (options.supportsVideo !== true && messagesContainVideo(options.messages)) {
+    throw new VideoUnsupportedError();
+  }
   return entry.stream(options);
 }
+function messagesContainVideo(messages) {
+  for (const msg of messages) {
+    if (typeof msg.content === "string" || !Array.isArray(msg.content)) continue;
+    for (const part of msg.content) {
+      if (part.type === "video") return true;
+      if (part.type === "tool_result" && Array.isArray(part.content)) {
+        if (part.content.some((block) => block.type === "video")) return true;
+      }
+    }
+  }
+  return false;
+}
 
 // src/error-classification.ts
 var CONTEXT_OVERFLOW_PATTERNS = [