@ai-sdk/moonshotai 3.0.38 → 3.0.42

package/src/convert-to-moonshotai-chat-messages.ts

@@ -1,27 +1,167 @@
 import {
+  InvalidPromptError,
   UnsupportedFunctionalityError,
+  type LanguageModelV4FilePart,
   type LanguageModelV4Prompt,
+  type SharedV4Warning,
 } from '@ai-sdk/provider';
 import {
   convertBase64ToUint8Array,
   convertToBase64,
   getTopLevelMediaType,
+  parseProviderOptions,
+  resolveProviderReference,
   resolveFullMediaType,
 } from '@ai-sdk/provider-utils';
 
 import type { MoonshotAIMessages } from './moonshotai-chat-api-types';
+import {
+  getMoonshotAIModelFamily,
+  moonshotaiAllMessageProviderOptions,
+  type MoonshotAIChatModelId,
+} from './moonshotai-chat-options';
+import { prepareTools } from './moonshotai-prepare-tools';
+
+const supportedImageMediaTypes = [
+  'image/jpeg',
+  'image/png',
+  'image/gif',
+  'image/webp',
+  'image/bmp',
+  'image/heic',
+  'image/heif',
+] as const;
+
+const supportedVideoMediaTypes = [
+  'video/mp4',
+  'video/mpeg',
+  'video/mov',
+  'video/avi',
+  'video/x-flv',
+  'video/mpg',
+  'video/webm',
+  'video/wmv',
+  'video/3gpp',
+] as const;
+
+function formatMediaUrl({
+  part,
+  supportedMediaTypes,
+  topLevelMediaType,
+}: {
+  part: LanguageModelV4FilePart;
+  supportedMediaTypes: readonly string[];
+  topLevelMediaType: 'image' | 'video';
+}): string {
+  if (part.data.type !== 'url' && part.data.type !== 'data') {
+    throw new UnsupportedFunctionalityError({
+      functionality: `file part data type ${part.data.type}`,
+    });
+  }
+
+  const mediaType =
+    part.data.type === 'url' ? part.mediaType : resolveFullMediaType({ part });
+
+  if (
+    !supportedMediaTypes.includes(mediaType) &&
+    !(
+      part.data.type === 'url' &&
+      (mediaType === topLevelMediaType ||
+        mediaType === `${topLevelMediaType}/*`)
+    )
+  ) {
+    throw new UnsupportedFunctionalityError({
+      functionality: `file part media type ${mediaType}`,
+    });
+  }
+
+  return part.data.type === 'url'
+    ? part.data.url.toString()
+    : `data:${mediaType};base64,${convertToBase64(part.data.data)}`;
+}
 
 // Moonshot AI chat completions accepts text, image_url, and video_url content
 // parts only. Anything else (audio, PDF, other file types) throws here rather
 // than being rejected by the API with a 400.
-export function convertToMoonshotAIChatMessages(
-  prompt: LanguageModelV4Prompt,
-): MoonshotAIMessages {
+export async function convertToMoonshotAIChatMessages({
+  modelId,
+  prompt,
+  providerOptionsName = 'moonshotai',
+  responseFormat,
+}: {
+  modelId?: MoonshotAIChatModelId;
+  prompt: LanguageModelV4Prompt;
+  providerOptionsName?: string;
+  responseFormat?: Record<string, unknown>;
+}): Promise<{
+  messages: MoonshotAIMessages;
+  warnings: Array<SharedV4Warning>;
+}> {
   const messages: MoonshotAIMessages = [];
-  for (const { role, content } of prompt) {
+  const warnings: Array<SharedV4Warning> = [];
+  const modelFamily =
+    modelId == null ? 'unknown' : getMoonshotAIModelFamily(modelId);
+
+  for (const [index, { role, content, providerOptions }] of prompt.entries()) {
+    const moonshotMessageOptions = await parseProviderOptions({
+      provider: providerOptionsName,
+      providerOptions,
+      schema: moonshotaiAllMessageProviderOptions,
+    });
+
+    if (moonshotMessageOptions?.partial === true && role !== 'assistant') {
+      throw new InvalidPromptError({
+        prompt,
+        message:
+          'Moonshot AI Partial Mode requires `partial: true` on an assistant message.',
+      });
+    }
+
+    if (moonshotMessageOptions?.tools != null && role !== 'system') {
+      throw new InvalidPromptError({
+        prompt,
+        message:
+          'Moonshot dynamic tools must be configured on a system message.',
+      });
+    }
+
     switch (role) {
       case 'system': {
-        messages.push({ role: 'system', content });
+        if (moonshotMessageOptions?.tools?.length) {
+          if (content.length > 0) {
+            throw new InvalidPromptError({
+              prompt,
+              message:
+                'A Moonshot dynamic-tool system message must use empty content because the API forbids content alongside tools.',
+            });
+          }
+
+          if (modelFamily !== 'kimi-k3' && modelFamily !== 'unknown') {
+            warnings.push({
+              type: 'unsupported',
+              feature: `dynamic tool loading for model "${modelId}"`,
+              details:
+                'Moonshot documents dynamic tool loading only for Kimi K3. The dynamic system message has been omitted.',
+            });
+            break;
+          }
+
+          const { tools, toolWarnings } = prepareTools({
+            modelId: modelId ?? 'custom-model',
+            tools: moonshotMessageOptions.tools,
+          });
+          warnings.push(...toolWarnings);
+          messages.push({ role: 'system', tools: tools ?? [] });
+          break;
+        }
+
+        messages.push({
+          role: 'system',
+          content,
+          ...(moonshotMessageOptions?.name != null && {
+            name: moonshotMessageOptions.name,
+          }),
+        });
         break;
       }
 
@@ -30,6 +170,9 @@ export function convertToMoonshotAIChatMessages(
           messages.push({
             role: 'user',
             content: content[0].text,
+            ...(moonshotMessageOptions?.name != null && {
+              name: moonshotMessageOptions.name,
+            }),
           });
           break;
         }
@@ -42,29 +185,61 @@ export function convertToMoonshotAIChatMessages(
                 return { type: 'text', text: part.text };
               }
               case 'file': {
+                const topLevel = getTopLevelMediaType(part.mediaType);
+
                 switch (part.data.type) {
                   case 'reference': {
-                    throw new UnsupportedFunctionalityError({
-                      functionality: 'file parts with provider references',
+                    if (topLevel !== 'image' && topLevel !== 'video') {
+                      throw new UnsupportedFunctionalityError({
+                        functionality: `file part media type ${part.mediaType}`,
+                      });
+                    }
+
+                    const reference = resolveProviderReference({
+                      reference: part.data.reference,
+                      provider: 'moonshotai',
                     });
+
+                    if (!reference.startsWith('ms://')) {
+                      throw new UnsupportedFunctionalityError({
+                        functionality:
+                          'Moonshot file provider references without an ms:// URL',
+                      });
+                    }
+
+                    return topLevel === 'image'
+                      ? {
+                          type: 'image_url' as const,
+                          image_url: { url: reference },
+                        }
+                      : {
+                          type: 'video_url' as const,
+                          video_url: { url: reference },
+                        };
                   }
                   case 'text': {
+                    if (topLevel === 'text') {
+                      return {
+                        type: 'text' as const,
+                        text: part.data.text,
+                      };
+                    }
+
                     throw new UnsupportedFunctionalityError({
-                      functionality: 'text file parts',
+                      functionality: `file part media type ${part.mediaType}`,
                     });
                   }
                   case 'url':
                   case 'data': {
-                    const topLevel = getTopLevelMediaType(part.mediaType);
-
                     if (topLevel === 'image') {
                       return {
                         type: 'image_url' as const,
                         image_url: {
-                          url:
-                            part.data.type === 'url'
-                              ? part.data.url.toString()
-                              : `data:${resolveFullMediaType({ part })};base64,${convertToBase64(part.data.data)}`,
+                          url: formatMediaUrl({
+                            part,
+                            supportedMediaTypes: supportedImageMediaTypes,
+                            topLevelMediaType: 'image',
+                          }),
                         },
                       };
                     }
@@ -73,10 +248,11 @@ export function convertToMoonshotAIChatMessages(
                       return {
                         type: 'video_url' as const,
                         video_url: {
-                          url:
-                            part.data.type === 'url'
-                              ? part.data.url.toString()
-                              : `data:${resolveFullMediaType({ part })};base64,${convertToBase64(part.data.data)}`,
+                          url: formatMediaUrl({
+                            part,
+                            supportedMediaTypes: supportedVideoMediaTypes,
+                            topLevelMediaType: 'video',
+                          }),
                         },
                       };
                     }
@@ -105,12 +281,33 @@ export function convertToMoonshotAIChatMessages(
               }
             }
           }),
+          ...(moonshotMessageOptions?.name != null && {
+            name: moonshotMessageOptions.name,
+          }),
         });
 
         break;
       }
 
       case 'assistant': {
+        if (moonshotMessageOptions?.partial === true) {
+          if (index !== prompt.length - 1) {
+            throw new InvalidPromptError({
+              prompt,
+              message:
+                'Moonshot AI Partial Mode requires the partial assistant message to be the final message.',
+            });
+          }
+
+          if (responseFormat?.type === 'json_object') {
+            throw new InvalidPromptError({
+              prompt,
+              message:
+                'Moonshot AI Partial Mode cannot be combined with JSON object response format.',
+            });
+          }
+        }
+
         let text = '';
         let reasoning = '';
         const toolCalls: Array<{
@@ -146,6 +343,12 @@ export function convertToMoonshotAIChatMessages(
         messages.push({
           role: 'assistant',
           content: toolCalls.length > 0 ? text || null : text,
+          ...(moonshotMessageOptions?.name != null && {
+            name: moonshotMessageOptions.name,
+          }),
+          ...(moonshotMessageOptions?.partial === true && {
+            partial: true,
+          }),
           ...(reasoning.length > 0 ? { reasoning_content: reasoning } : {}),
           tool_calls: toolCalls.length > 0 ? toolCalls : undefined,
         });
@@ -154,6 +357,13 @@ export function convertToMoonshotAIChatMessages(
       }
 
       case 'tool': {
+        if (moonshotMessageOptions?.name != null) {
+          warnings.push({
+            type: 'unsupported',
+            feature: 'message name on tool messages',
+          });
+        }
+
         for (const toolResponse of content) {
           if (toolResponse.type === 'tool-approval-response') {
             continue;
@@ -193,5 +403,5 @@ export function convertToMoonshotAIChatMessages(
     }
   }
 
-  return messages;
+  return { messages, warnings };
 }

package/src/index.ts

@@ -4,8 +4,11 @@ export type {
   MoonshotAIProviderSettings,
 } from './moonshotai-provider';
 export type {
+  MoonshotAIAssistantMessageProviderOptions,
   MoonshotAIChatModelId,
   MoonshotAILanguageModelOptions,
+  MoonshotAIMessageProviderOptions,
+  MoonshotAISystemMessageProviderOptions,
   /** @deprecated Use `MoonshotAILanguageModelOptions` instead. */
   MoonshotAILanguageModelOptions as MoonshotAIProviderOptions,
 } from './moonshotai-chat-options';

package/src/moonshotai-chat-api-types.ts

@@ -9,14 +9,31 @@ export type MoonshotAIMessage =
   | MoonshotAIAssistantMessage
   | MoonshotAIToolMessage;
 
-export interface MoonshotAISystemMessage {
-  role: 'system';
-  content: string;
+export type MoonshotAISystemMessage =
+  | {
+      role: 'system';
+      content: string;
+      name?: string;
+    }
+  | {
+      role: 'system';
+      tools: Array<MoonshotAIFunctionTool>;
+    };
+
+export interface MoonshotAIFunctionTool {
+  type: 'function';
+  function: {
+    name: string;
+    description: string | undefined;
+    parameters: unknown;
+    strict?: boolean;
+  };
 }
 
 export interface MoonshotAIUserMessage {
   role: 'user';
   content: string | Array<MoonshotAIContentPart>;
+  name?: string;
 }
 
 export type MoonshotAIContentPart =
@@ -42,6 +59,8 @@ export interface MoonshotAIContentPartVideo {
 export interface MoonshotAIAssistantMessage {
   role: 'assistant';
   content?: string | null;
+  name?: string;
+  partial?: true;
   reasoning_content?: string;
   tool_calls?: Array<MoonshotAIMessageToolCall>;
 }
@@ -64,19 +83,20 @@ export interface MoonshotAIToolMessage {
 // Schemas below are limited versions focused on what the implementation
 // needs. This limits breakages when the API changes and increases efficiency.
 
+// Loose, nested objects included: the parsed value is returned as `usage.raw`.
 const tokenUsageSchema = z
-  .object({
+  .looseObject({
     prompt_tokens: z.number().nullish(),
     completion_tokens: z.number().nullish(),
     cached_tokens: z.number().nullish(),
     total_tokens: z.number().nullish(),
     prompt_tokens_details: z
-      .object({
+      .looseObject({
         cached_tokens: z.number().nullish(),
       })
       .nullish(),
     completion_tokens_details: z
-      .object({
+      .looseObject({
         reasoning_tokens: z.number().nullish(),
       })
       .nullish(),
@@ -89,17 +109,41 @@ export const moonshotAIErrorSchema = z.object({
   error: z.object({
     message: z.string(),
     type: z.string().nullish(),
+    code: z.string().nullish(),
   }),
 });
 
 export type MoonshotAIErrorData = z.infer<typeof moonshotAIErrorSchema>;
 
+const moonshotAIChatLogprobSchema = z.object({
+  token: z.string(),
+  logprob: z.number(),
+  bytes: z.array(z.number()).nullable(),
+  top_logprobs: z.array(
+    z.object({
+      token: z.string(),
+      logprob: z.number(),
+      bytes: z.array(z.number()).nullable(),
+    }),
+  ),
+});
+
+const moonshotAIChatLogprobsSchema = z
+  .object({
+    content: z.array(moonshotAIChatLogprobSchema).nullish(),
+  })
+  .nullish();
+
+export type MoonshotAIChatLogprob = z.infer<typeof moonshotAIChatLogprobSchema>;
+
 export const moonshotAIChatResponseSchema = z.object({
   id: z.string().nullish(),
   created: z.number().nullish(),
   model: z.string().nullish(),
+  object: z.literal('chat.completion').nullish(),
   choices: z.array(
     z.object({
+      index: z.number().nullish(),
       message: z.object({
         role: z.literal('assistant').nullish(),
         content: z.string().nullish(),
@@ -108,6 +152,7 @@ export const moonshotAIChatResponseSchema = z.object({
           .array(
             z.object({
               id: z.string().nullish(),
+              type: z.literal('function').nullish(),
               function: z.object({
                 name: z.string(),
                 arguments: z.string(),
@@ -116,6 +161,7 @@ export const moonshotAIChatResponseSchema = z.object({
           )
           .nullish(),
       }),
+      logprobs: moonshotAIChatLogprobsSchema,
       finish_reason: z.string().nullish(),
     }),
   ),
@@ -129,8 +175,10 @@ export const moonshotAIChatChunkSchema = lazySchema(() =>
         id: z.string().nullish(),
         created: z.number().nullish(),
         model: z.string().nullish(),
+        object: z.literal('chat.completion.chunk').nullish(),
         choices: z.array(
           z.object({
+            index: z.number().nullish(),
             delta: z
               .object({
                 role: z.literal('assistant').nullish(),
@@ -139,8 +187,9 @@ export const moonshotAIChatChunkSchema = lazySchema(() =>
                 tool_calls: z
                   .array(
                     z.object({
-                      index: z.number(),
+                      index: z.number().nullish(),
                       id: z.string().nullish(),
+                      type: z.literal('function').nullish(),
                       function: z.object({
                         name: z.string().nullish(),
                         arguments: z.string().nullish(),
@@ -150,7 +199,9 @@ export const moonshotAIChatChunkSchema = lazySchema(() =>
                   .nullish(),
               })
               .nullish(),
+            logprobs: moonshotAIChatLogprobsSchema,
             finish_reason: z.string().nullish(),
+            usage: tokenUsageSchema,
           }),
         ),
         usage: tokenUsageSchema,