@ai-sdk/moonshotai 2.0.51 → 2.0.54

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(),
@@ -141,6 +189,7 @@ export const moonshotAIChatChunkSchema = lazySchema(() =>
                     z.object({
                       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,6 +199,7 @@ export const moonshotAIChatChunkSchema = lazySchema(() =>
                   .nullish(),
               })
               .nullish(),
+            logprobs: moonshotAIChatLogprobsSchema,
             finish_reason: z.string().nullish(),
             usage: tokenUsageSchema,
           }),

package/src/moonshotai-chat-language-model.ts

@@ -31,6 +31,7 @@ import {
   moonshotAIChatChunkSchema,
   moonshotAIChatResponseSchema,
   moonshotAIErrorSchema,
+  type MoonshotAIChatLogprob,
   type MoonshotAIChatTokenUsage,
 } from './moonshotai-chat-api-types';
 import {
@@ -107,8 +108,6 @@ export class MoonshotAIChatLanguageModel implements LanguageModelV3 {
         schema: moonshotaiLanguageModelOptions,
       })) ?? {};
 
-    const messages = convertToMoonshotAIChatMessages(prompt);
-
     const allWarnings: SharedV3Warning[] = [];
     if (topK != null) {
       allWarnings.push({ type: 'unsupported', feature: 'topK' });
@@ -289,9 +288,23 @@ export class MoonshotAIChatLanguageModel implements LanguageModelV3 {
       }
     }
 
+    const { messages, warnings: messageWarnings } =
+      convertToMoonshotAIChatMessages({
+        modelId: this.modelId,
+        prompt,
+        providerOptionsName: this.providerOptionsName,
+        responseFormat: response_format,
+      });
+    allWarnings.push(...messageWarnings);
+
     return {
       args: {
         model: this.modelId,
+        ...((moonshotOptions.logprobs === true ||
+          moonshotOptions.topLogprobs != null) && { logprobs: true }),
+        ...(moonshotOptions.topLogprobs != null && {
+          top_logprobs: moonshotOptions.topLogprobs,
+        }),
         max_completion_tokens: maxOutputTokens,
         temperature: supportsSamplingOptions ? temperature : undefined,
         top_p: supportsSamplingOptions ? topP : undefined,
@@ -304,6 +317,9 @@ export class MoonshotAIChatLanguageModel implements LanguageModelV3 {
         messages,
         tools: moonshotTools,
         tool_choice: moonshotToolChoice,
+        ...(moonshotOptions.prediction != null && {
+          prediction: moonshotOptions.prediction,
+        }),
         ...(thinking != null ? { thinking } : {}),
         ...(reasoningEffort != null && {
           reasoning_effort: reasoningEffort,
@@ -377,6 +393,23 @@ export class MoonshotAIChatLanguageModel implements LanguageModelV3 {
         raw: choice.finish_reason ?? undefined,
       },
       usage: convertMoonshotAIChatUsage(responseBody.usage),
+      providerMetadata: {
+        [this.providerOptionsName]: {
+          ...(responseBody.object != null && {
+            responseObject: responseBody.object,
+          }),
+          ...(choice.index != null && { choiceIndex: choice.index }),
+          ...(choice.message.role != null && {
+            messageRole: choice.message.role,
+          }),
+          ...(choice.message.tool_calls != null && {
+            toolCallTypes: choice.message.tool_calls
+              .map(toolCall => toolCall.type)
+              .filter(type => type != null),
+          }),
+          ...(choice.logprobs != null && { logprobs: choice.logprobs }),
+        },
+      },
       request: { body: args },
       response: {
         ...getResponseMetadata(responseBody),
@@ -428,9 +461,15 @@ export class MoonshotAIChatLanguageModel implements LanguageModelV3 {
     };
     let topLevelUsage: MoonshotAIChatTokenUsage | undefined = undefined;
     let choiceUsage: MoonshotAIChatTokenUsage | undefined = undefined;
+    const contentLogprobs: MoonshotAIChatLogprob[] = [];
+    const providerOptionsName = this.providerOptionsName;
     let isFirstChunk = true;
     let isActiveReasoning = false;
     let isActiveText = false;
+    let responseObject: 'chat.completion.chunk' | undefined;
+    let choiceIndex: number | undefined;
+    let messageRole: 'assistant' | undefined;
+    const toolCallTypes = new Map<number, 'function'>();
 
     return {
       stream: response.pipeThrough(
@@ -459,7 +498,7 @@ export class MoonshotAIChatLanguageModel implements LanguageModelV3 {
             // handle error chunks:
             if ('error' in value) {
               finishReason = { unified: 'error', raw: undefined };
-              controller.enqueue({ type: 'error', error: value.error.message });
+              controller.enqueue({ type: 'error', error: value.error });
               return;
             }
 
@@ -476,12 +515,20 @@ export class MoonshotAIChatLanguageModel implements LanguageModelV3 {
               topLevelUsage = value.usage;
             }
 
+            if (value.object != null) {
+              responseObject = value.object;
+            }
+
             const choice = value.choices[0];
 
             if (choice?.usage != null) {
               choiceUsage = choice.usage;
             }
 
+            if (choice?.index != null) {
+              choiceIndex = choice.index;
+            }
+
             if (choice?.finish_reason != null) {
               finishReason = {
                 unified: mapMoonshotAIFinishReason(choice.finish_reason),
@@ -489,12 +536,20 @@ export class MoonshotAIChatLanguageModel implements LanguageModelV3 {
               };
             }
 
+            if (choice?.logprobs?.content != null) {
+              contentLogprobs.push(...choice.logprobs.content);
+            }
+
             if (choice?.delta == null) {
               return;
             }
 
             const delta = choice.delta;
 
+            if (delta.role != null) {
+              messageRole = delta.role;
+            }
+
             // enqueue reasoning before text deltas:
             const reasoningContent = delta.reasoning_content;
             if (reasoningContent) {
@@ -551,6 +606,10 @@ export class MoonshotAIChatLanguageModel implements LanguageModelV3 {
               ] of delta.tool_calls.entries()) {
                 const index = toolCallDelta.index ?? fallbackIndex;
 
+                if (toolCallDelta.type != null) {
+                  toolCallTypes.set(index, toolCallDelta.type);
+                }
+
                 if (toolCalls[index] == null) {
                   if (toolCallDelta.id == null) {
                     throw new InvalidResponseDataError({
@@ -652,6 +711,23 @@ export class MoonshotAIChatLanguageModel implements LanguageModelV3 {
               type: 'finish',
               finishReason,
               usage: convertMoonshotAIChatUsage(topLevelUsage ?? choiceUsage),
+              providerMetadata: {
+                [providerOptionsName]: {
+                  ...(responseObject != null && { responseObject }),
+                  ...(choiceIndex != null && { choiceIndex }),
+                  ...(messageRole != null && { messageRole }),
+                  ...(toolCallTypes.size > 0 && {
+                    toolCallTypes: [...toolCallTypes.entries()]
+                      .sort(([left], [right]) => left - right)
+                      .map(([, type]) => type),
+                  }),
+                  ...(contentLogprobs.length > 0 && {
+                    logprobs: {
+                      content: contentLogprobs,
+                    },
+                  }),
+                },
+              },
             });
           },
         }),

package/src/moonshotai-chat-options.ts

@@ -1,19 +1,18 @@
+import type { LanguageModelV3FunctionTool } from '@ai-sdk/provider';
 import { z } from 'zod/v4';
 
 export type MoonshotAIChatModelId =
+  | 'moonshot-v1-auto'
   | 'moonshot-v1-8k'
   | 'moonshot-v1-32k'
   | 'moonshot-v1-128k'
-  | 'moonshot-v1-auto'
   | 'moonshot-v1-8k-vision-preview'
   | 'moonshot-v1-32k-vision-preview'
   | 'moonshot-v1-128k-vision-preview'
-  | 'kimi-k2'
-  | 'kimi-k2-0905'
-  | 'kimi-k2-thinking'
-  | 'kimi-k2-thinking-turbo'
-  | 'kimi-k2-turbo'
   | 'kimi-k2.5'
+  | 'kimi-k2.6'
+  | 'kimi-k2.7-code'
+  | 'kimi-k2.7-code-highspeed'
   | 'kimi-k3'
   | (string & {});
 
@@ -51,19 +50,60 @@ export const moonshotaiLanguageModelOptions = z.object({
   strictJsonSchema: z.boolean().optional(),
 
   /**
-   * Reasoning effort for Kimi K3.
+   * Whether to return log probabilities for generated tokens.
+   */
+  logprobs: z.boolean().optional(),
+
+  /**
+   * Number of most likely tokens to return at each token position.
+   *
+   * Setting this option automatically enables `logprobs`.
+   */
+  topLogprobs: z.number().int().min(0).max(20).optional(),
+
+  /**
+   * Reasoning effort for Kimi K3. Supports `low`, `high`, and `max`;
+   * defaults to `max`.
    */
   reasoningEffort: z.enum(['low', 'high', 'max']).optional(),
 
+  /**
+   * Static predicted content that can accelerate responses when much of the
+   * output is known ahead of time.
+   */
+  prediction: z
+    .object({
+      type: z.literal('content'),
+      content: z.union([
+        z.string(),
+        z.array(z.object({ type: z.literal('text'), text: z.string() })),
+      ]),
+    })
+    .optional(),
+
+  /**
+   * Thinking configuration for Kimi K2.x models. Kimi K2.5 and K2.6 support
+   * enabling or disabling thinking. Kimi K2.7 Code always has thinking
+   * enabled.
+   */
   thinking: z
     .object({
       type: z.enum(['enabled', 'disabled']).optional(),
-      // Accepted so existing callers receive a migration warning. It remains
-      // in the public compatibility type below as a deprecated property.
+      /**
+       * @deprecated Moonshot Chat Completions does not support thinking
+       * budgets. Accepted for backwards compatibility, then omitted with a
+       * warning.
+       */
       budgetTokens: z.number().int().min(1024).optional(),
     })
     .optional(),
 
+  /**
+   * Controls preserved reasoning behavior in multi-turn conversations.
+   * `disabled` and `interleaved` are compatibility values that leave the
+   * request unchanged. `preserved` maps to `thinking.keep: 'all'` for Kimi
+   * K2.6. Kimi K2.7 and K3 preserve reasoning by default.
+   */
   reasoningHistory: z.enum(['disabled', 'interleaved', 'preserved']).optional(),
 
   /**
@@ -87,9 +127,27 @@ export type MoonshotAILanguageModelOptions = {
    */
   strictJsonSchema?: boolean;
 
+  /** Whether to return log probabilities for generated tokens. */
+  logprobs?: boolean;
+
+  /**
+   * Number of most likely tokens to return at each token position.
+   * Setting this option automatically enables `logprobs`.
+   */
+  topLogprobs?: number;
+
   /** Reasoning effort for Kimi K3. */
   reasoningEffort?: 'low' | 'high' | 'max';
 
+  /**
+   * Static predicted content that can accelerate responses when much of the
+   * output is known ahead of time.
+   */
+  prediction?: {
+    type: 'content';
+    content: string | Array<{ type: 'text'; text: string }>;
+  };
+
   /** Controls thinking on Kimi K2.5 and K2.6. K2.7 is always enabled. */
   thinking?: {
     type?: 'enabled' | 'disabled';
@@ -101,7 +159,65 @@ export type MoonshotAILanguageModelOptions = {
     budgetTokens?: number;
   };
 
+  /**
+   * Controls preserved reasoning behavior in multi-turn conversations.
+   * `disabled` and `interleaved` are compatibility values that leave the
+   * request unchanged. `preserved` maps to `thinking.keep: 'all'` for Kimi
+   * K2.6. Kimi K2.7 and K3 preserve reasoning by default.
+   */
   reasoningHistory?: 'disabled' | 'interleaved' | 'preserved';
   promptCacheKey?: string;
   safetyIdentifier?: string;
 };
+
+export const moonshotaiMessageProviderOptions = z.object({
+  /**
+   * The name of the participant represented by the message.
+   *
+   * Supported on system, user, and assistant messages.
+   */
+  name: z.string().optional(),
+});
+
+export type MoonshotAIMessageProviderOptions = z.infer<
+  typeof moonshotaiMessageProviderOptions
+>;
+
+export const moonshotaiAssistantMessageProviderOptions =
+  moonshotaiMessageProviderOptions.extend({
+    /**
+     * Whether the assistant message content is a partial response that Moonshot
+     * should continue. Only supported on the final assistant message and cannot
+     * be combined with JSON object response format.
+     */
+    partial: z.literal(true).optional(),
+  });
+
+export type MoonshotAIAssistantMessageProviderOptions = z.infer<
+  typeof moonshotaiAssistantMessageProviderOptions
+>;
+
+const moonshotaiDynamicToolSchema = z.object({
+  type: z.literal('function'),
+  name: z.string(),
+  description: z.string().optional(),
+  inputSchema: z.record(z.string(), z.unknown()),
+  strict: z.boolean().optional(),
+});
+
+export const moonshotaiAllMessageProviderOptions =
+  moonshotaiAssistantMessageProviderOptions.extend({
+    /** Function tools to load at this point in a Kimi K3 conversation. */
+    tools: z.array(moonshotaiDynamicToolSchema).optional(),
+  });
+
+export type MoonshotAISystemMessageProviderOptions =
+  MoonshotAIMessageProviderOptions & {
+    /** Function tools to load at this point in a Kimi K3 conversation. */
+    tools?: Array<
+      Pick<
+        LanguageModelV3FunctionTool,
+        'type' | 'name' | 'description' | 'inputSchema' | 'strict'
+      >
+    >;
+  };

package/src/moonshotai-prepare-tools.ts

@@ -3,6 +3,7 @@ import {
   type LanguageModelV3CallOptions,
   type SharedV3Warning,
 } from '@ai-sdk/provider';
+import type { MoonshotAIFunctionTool } from './moonshotai-chat-api-types';
 import type { MoonshotAIChatModelId } from './moonshotai-chat-options';
 import { normalizeJsonSchemaForMFJS } from './normalize-json-schema-for-mfjs';
 
@@ -15,17 +16,7 @@ export function prepareTools({
   toolChoice?: LanguageModelV3CallOptions['toolChoice'];
   modelId: MoonshotAIChatModelId;
 }): {
-  tools:
-    | undefined
-    | Array<{
-        type: 'function';
-        function: {
-          name: string;
-          description: string | undefined;
-          parameters: unknown;
-          strict?: boolean;
-        };
-      }>;
+  tools: undefined | Array<MoonshotAIFunctionTool>;
   toolChoice:
     | { type: 'function'; function: { name: string } }
     | 'auto'
@@ -43,15 +34,7 @@ export function prepareTools({
     return { tools: undefined, toolChoice: undefined, toolWarnings };
   }
 
-  const moonshotTools: Array<{
-    type: 'function';
-    function: {
-      name: string;
-      description: string | undefined;
-      parameters: unknown;
-      strict?: boolean;
-    };
-  }> = [];
+  const moonshotTools: Array<MoonshotAIFunctionTool> = [];
 
   for (const tool of tools) {
     if (tool.type === 'provider') {