@ai-sdk/moonshotai 2.0.48 → 2.0.51

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

@@ -34,10 +34,12 @@ import {
   type MoonshotAIChatTokenUsage,
 } from './moonshotai-chat-api-types';
 import {
-  getModelThinkingKeepSupport,
+  getMoonshotAIModelFamily,
+  isMoonshotAIKimiModel,
   moonshotaiLanguageModelOptions,
   type MoonshotAIChatModelId,
 } from './moonshotai-chat-options';
+import { normalizeJsonSchemaForMFJS } from './normalize-json-schema-for-mfjs';
 import { prepareTools } from './moonshotai-prepare-tools';
 
 export type MoonshotAIChatConfig = {
@@ -115,30 +117,150 @@ export class MoonshotAIChatLanguageModel implements LanguageModelV3 {
       allWarnings.push({ type: 'unsupported', feature: 'seed' });
     }
 
+    const supportsSamplingOptions = !isMoonshotAIKimiModel(this.modelId);
+
+    if (!supportsSamplingOptions && temperature != null) {
+      allWarnings.push({
+        type: 'unsupported',
+        feature: 'temperature',
+        details: `temperature is fixed by model "${this.modelId}" and has been omitted.`,
+      });
+    }
+    if (!supportsSamplingOptions && topP != null) {
+      allWarnings.push({
+        type: 'unsupported',
+        feature: 'topP',
+        details: `topP is fixed by model "${this.modelId}" and has been omitted.`,
+      });
+    }
+    if (!supportsSamplingOptions && frequencyPenalty != null) {
+      allWarnings.push({
+        type: 'unsupported',
+        feature: 'frequencyPenalty',
+        details: `frequencyPenalty is fixed by model "${this.modelId}" and has been omitted.`,
+      });
+    }
+    if (!supportsSamplingOptions && presencePenalty != null) {
+      allWarnings.push({
+        type: 'unsupported',
+        feature: 'presencePenalty',
+        details: `presencePenalty is fixed by model "${this.modelId}" and has been omitted.`,
+      });
+    }
+
     const {
       tools: moonshotTools,
       toolChoice: moonshotToolChoice,
       toolWarnings,
-    } = prepareTools({ tools, toolChoice });
-
-    // Thinking is configured through explicit provider options only.
-    const thinking = moonshotOptions.thinking;
-
-    // Moonshot has no reasoning_history field; the API silently ignores it
-    // (verified against the live API). Preserved Thinking maps to
-    // thinking.keep, which only accepts 'all' and only on some models
-    // (verified: k2.6, k2.7-code, k3 accept it; k2.5 rejects it). Other
-    // reasoningHistory values use the server default.
-    let keep: 'all' | undefined;
-    if (moonshotOptions.reasoningHistory === 'preserved') {
-      if (getModelThinkingKeepSupport(this.modelId)) {
-        keep = 'all';
-      } else {
+    } = prepareTools({ tools, toolChoice, modelId: this.modelId });
+
+    const modelFamily = getMoonshotAIModelFamily(this.modelId);
+    const requestedThinking = moonshotOptions.thinking;
+    const requestedReasoningEffort = moonshotOptions.reasoningEffort;
+    const preserveReasoning = moonshotOptions.reasoningHistory === 'preserved';
+
+    if (requestedThinking?.budgetTokens != null) {
+      allWarnings.push({
+        type: 'other',
+        message:
+          'providerOptions.moonshotai.thinking.budgetTokens is deprecated because Moonshot Chat Completions does not support budget_tokens. The option has been omitted.',
+      });
+    }
+
+    let thinking: { type: 'enabled' | 'disabled'; keep?: 'all' } | undefined;
+    let reasoningEffort: 'low' | 'high' | 'max' | undefined;
+
+    const warnUnsupportedReasoningEffort = () => {
+      if (requestedReasoningEffort != null) {
         allWarnings.push({
           type: 'unsupported',
-          feature: `reasoningHistory 'preserved' is not supported by model "${this.modelId}"`,
+          feature: 'reasoningEffort',
+          details: `reasoningEffort is only supported by Kimi K3 and has been omitted for model "${this.modelId}".`,
         });
       }
+    };
+
+    switch (modelFamily) {
+      case 'kimi-k3': {
+        if (requestedThinking != null) {
+          allWarnings.push({
+            type: 'unsupported',
+            feature: 'thinking',
+            details:
+              'Kimi K3 always reasons and does not accept the thinking field. The option has been omitted.',
+          });
+        }
+        reasoningEffort = requestedReasoningEffort;
+        break;
+      }
+      case 'kimi-k2.7': {
+        warnUnsupportedReasoningEffort();
+        if (requestedThinking?.type === 'disabled') {
+          allWarnings.push({
+            type: 'unsupported',
+            feature: 'thinking.type "disabled"',
+            details: 'Kimi K2.7 thinking cannot be disabled.',
+          });
+        } else if (requestedThinking?.type === 'enabled') {
+          thinking = { type: 'enabled' };
+        }
+        break;
+      }
+      case 'kimi-k2.6': {
+        warnUnsupportedReasoningEffort();
+        const thinkingType = requestedThinking?.type;
+        if (thinkingType != null || preserveReasoning) {
+          thinking = {
+            type: thinkingType ?? 'enabled',
+            ...(preserveReasoning ? { keep: 'all' as const } : {}),
+          };
+        }
+        break;
+      }
+      case 'kimi-k2.5': {
+        warnUnsupportedReasoningEffort();
+        const thinkingType = requestedThinking?.type;
+        if (thinkingType != null) {
+          thinking = { type: thinkingType };
+        }
+        if (preserveReasoning) {
+          allWarnings.push({
+            type: 'unsupported',
+            feature: `reasoningHistory 'preserved' is not supported by model "${this.modelId}"`,
+          });
+        }
+        break;
+      }
+      case 'moonshot-v1': {
+        warnUnsupportedReasoningEffort();
+        if (requestedThinking != null) {
+          allWarnings.push({
+            type: 'unsupported',
+            feature: 'thinking',
+            details: `thinking is not supported by model "${this.modelId}" and has been omitted.`,
+          });
+        }
+        if (preserveReasoning) {
+          allWarnings.push({
+            type: 'unsupported',
+            feature: `reasoningHistory 'preserved' is not supported by model "${this.modelId}"`,
+          });
+        }
+        break;
+      }
+      case 'unknown': {
+        reasoningEffort = requestedReasoningEffort;
+        if (requestedThinking?.type != null) {
+          thinking = { type: requestedThinking.type };
+        }
+        if (preserveReasoning) {
+          allWarnings.push({
+            type: 'unsupported',
+            feature: `reasoningHistory 'preserved' is not supported by model "${this.modelId}"`,
+          });
+        }
+        break;
+      }
     }
 
     let response_format: Record<string, unknown> | undefined;
@@ -158,10 +280,8 @@ export class MoonshotAIChatLanguageModel implements LanguageModelV3 {
           type: 'json_schema',
           json_schema: {
             name: responseFormat.name ?? 'response',
-            schema: schemaWithoutDollarSchema,
-            ...(responseFormat.description != null && {
-              description: responseFormat.description,
-            }),
+            strict: moonshotOptions.strictJsonSchema ?? true,
+            schema: normalizeJsonSchemaForMFJS(schemaWithoutDollarSchema),
           },
         };
       } else {
@@ -172,29 +292,21 @@ export class MoonshotAIChatLanguageModel implements LanguageModelV3 {
     return {
       args: {
         model: this.modelId,
-        max_tokens: maxOutputTokens,
-        temperature,
-        top_p: topP,
-        frequency_penalty: frequencyPenalty,
-        presence_penalty: presencePenalty,
+        max_completion_tokens: maxOutputTokens,
+        temperature: supportsSamplingOptions ? temperature : undefined,
+        top_p: supportsSamplingOptions ? topP : undefined,
+        frequency_penalty: supportsSamplingOptions
+          ? frequencyPenalty
+          : undefined,
+        presence_penalty: supportsSamplingOptions ? presencePenalty : undefined,
         response_format,
         stop: stopSequences,
         messages,
         tools: moonshotTools,
         tool_choice: moonshotToolChoice,
-        ...(thinking != null || keep != null
-          ? {
-              thinking: {
-                ...(thinking?.type != null && { type: thinking.type }),
-                ...(thinking?.budgetTokens !== undefined && {
-                  budget_tokens: thinking.budgetTokens,
-                }),
-                ...(keep != null && { keep }),
-              },
-            }
-          : {}),
-        ...(moonshotOptions.reasoningEffort != null && {
-          reasoning_effort: moonshotOptions.reasoningEffort,
+        ...(thinking != null ? { thinking } : {}),
+        ...(reasoningEffort != null && {
+          reasoning_effort: reasoningEffort,
         }),
         ...(moonshotOptions.promptCacheKey != null && {
           prompt_cache_key: moonshotOptions.promptCacheKey,
@@ -314,7 +426,8 @@ export class MoonshotAIChatLanguageModel implements LanguageModelV3 {
       unified: 'other',
       raw: undefined,
     };
-    let usage: MoonshotAIChatTokenUsage | undefined = undefined;
+    let topLevelUsage: MoonshotAIChatTokenUsage | undefined = undefined;
+    let choiceUsage: MoonshotAIChatTokenUsage | undefined = undefined;
     let isFirstChunk = true;
     let isActiveReasoning = false;
     let isActiveText = false;
@@ -360,11 +473,15 @@ export class MoonshotAIChatLanguageModel implements LanguageModelV3 {
             }
 
             if (value.usage != null) {
-              usage = value.usage;
+              topLevelUsage = value.usage;
             }
 
             const choice = value.choices[0];
 
+            if (choice?.usage != null) {
+              choiceUsage = choice.usage;
+            }
+
             if (choice?.finish_reason != null) {
               finishReason = {
                 unified: mapMoonshotAIFinishReason(choice.finish_reason),
@@ -428,8 +545,11 @@ export class MoonshotAIChatLanguageModel implements LanguageModelV3 {
                 isActiveReasoning = false;
               }
 
-              for (const toolCallDelta of delta.tool_calls) {
-                const index = toolCallDelta.index;
+              for (const [
+                fallbackIndex,
+                toolCallDelta,
+              ] of delta.tool_calls.entries()) {
+                const index = toolCallDelta.index ?? fallbackIndex;
 
                 if (toolCalls[index] == null) {
                   if (toolCallDelta.id == null) {
@@ -531,7 +651,7 @@ export class MoonshotAIChatLanguageModel implements LanguageModelV3 {
             controller.enqueue({
               type: 'finish',
               finishReason,
-              usage: convertMoonshotAIChatUsage(usage),
+              usage: convertMoonshotAIChatUsage(topLevelUsage ?? choiceUsage),
             });
           },
         }),

package/src/moonshotai-chat-options.ts

@@ -4,6 +4,10 @@ export type MoonshotAIChatModelId =
   | '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'
@@ -13,7 +17,39 @@ export type MoonshotAIChatModelId =
   | 'kimi-k3'
   | (string & {});
 
+export function isMoonshotAIKimiModel(modelId: MoonshotAIChatModelId): boolean {
+  return getMoonshotAIModelFamily(modelId).startsWith('kimi-');
+}
+
+export type MoonshotAIModelFamily =
+  | 'kimi-k2.5'
+  | 'kimi-k2.6'
+  | 'kimi-k2.7'
+  | 'kimi-k3'
+  | 'moonshot-v1'
+  | 'unknown';
+
+export function getMoonshotAIModelFamily(
+  modelId: MoonshotAIChatModelId,
+): MoonshotAIModelFamily {
+  if (modelId === 'kimi-k2.5') return 'kimi-k2.5';
+  if (modelId === 'kimi-k2.6') return 'kimi-k2.6';
+  if (modelId === 'kimi-k2.7-code' || modelId === 'kimi-k2.7-code-highspeed') {
+    return 'kimi-k2.7';
+  }
+  if (modelId === 'kimi-k3') return 'kimi-k3';
+  if (modelId.startsWith('moonshot-v1-')) return 'moonshot-v1';
+  return 'unknown';
+}
+
 export const moonshotaiLanguageModelOptions = z.object({
+  /**
+   * Whether to use strict JSON schema validation for structured outputs.
+   *
+   * @default true
+   */
+  strictJsonSchema: z.boolean().optional(),
+
   /**
    * Reasoning effort for Kimi K3.
    */
@@ -22,6 +58,8 @@ export const moonshotaiLanguageModelOptions = z.object({
   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.
       budgetTokens: z.number().int().min(1024).optional(),
     })
     .optional(),
@@ -41,21 +79,29 @@ export const moonshotaiLanguageModelOptions = z.object({
   safetyIdentifier: z.string().optional(),
 });
 
-export type MoonshotAILanguageModelOptions = z.infer<
-  typeof moonshotaiLanguageModelOptions
->;
+export type MoonshotAILanguageModelOptions = {
+  /**
+   * Whether to use strict JSON schema validation for structured outputs.
+   *
+   * @default true
+   */
+  strictJsonSchema?: boolean;
 
-/**
- * Whether the model accepts `thinking.keep` (Preserved Thinking). Verified
- * against the live API: kimi-k2.6, kimi-k2.7-code(+highspeed), and kimi-k3
- * accept `keep: 'all'`; other models reject it with a 400.
- */
-export function getModelThinkingKeepSupport(
-  modelId: MoonshotAIChatModelId,
-): boolean {
-  return (
-    modelId === 'kimi-k2.6' ||
-    modelId === 'kimi-k3' ||
-    modelId.startsWith('kimi-k2.7-code')
-  );
-}
+  /** Reasoning effort for Kimi K3. */
+  reasoningEffort?: 'low' | 'high' | 'max';
+
+  /** Controls thinking on Kimi K2.5 and K2.6. K2.7 is always enabled. */
+  thinking?: {
+    type?: 'enabled' | 'disabled';
+
+    /**
+     * @deprecated Moonshot Chat Completions does not support thinking budgets.
+     * This value is ignored with a warning.
+     */
+    budgetTokens?: number;
+  };
+
+  reasoningHistory?: 'disabled' | 'interleaved' | 'preserved';
+  promptCacheKey?: string;
+  safetyIdentifier?: string;
+};

package/src/moonshotai-prepare-tools.ts

@@ -3,14 +3,17 @@ import {
   type LanguageModelV3CallOptions,
   type SharedV3Warning,
 } from '@ai-sdk/provider';
+import type { MoonshotAIChatModelId } from './moonshotai-chat-options';
 import { normalizeJsonSchemaForMFJS } from './normalize-json-schema-for-mfjs';
 
 export function prepareTools({
   tools,
   toolChoice,
+  modelId,
 }: {
   tools: LanguageModelV3CallOptions['tools'];
   toolChoice?: LanguageModelV3CallOptions['toolChoice'];
+  modelId: MoonshotAIChatModelId;
 }): {
   tools:
     | undefined
@@ -78,7 +81,25 @@ export function prepareTools({
   switch (type) {
     case 'auto':
     case 'none':
+      return { tools: moonshotTools, toolChoice: type, toolWarnings };
     case 'required':
+      if (
+        modelId === 'kimi-k2.6' ||
+        modelId === 'kimi-k2.7-code' ||
+        modelId === 'kimi-k2.7-code-highspeed'
+      ) {
+        toolWarnings.push({
+          type: 'unsupported',
+          feature: `tool choice "required" for model "${modelId}"`,
+          details:
+            'Moonshot AI rejects required tool choice for this model. The setting has been omitted; use "auto" or select a specific tool instead.',
+        });
+        return {
+          tools: moonshotTools,
+          toolChoice: undefined,
+          toolWarnings,
+        };
+      }
       return { tools: moonshotTools, toolChoice: type, toolWarnings };
     case 'tool':
       return {

package/src/moonshotai-provider.ts

@@ -58,8 +58,16 @@ const defaultBaseURL = 'https://api.moonshot.ai/v1';
 export function getModelStructuredOutputSupport(
   modelId: MoonshotAIChatModelId,
 ): boolean {
-  if (modelId.startsWith('kimi-k')) return true;
-  return false;
+  return (
+    modelId.startsWith('kimi-k') ||
+    modelId === 'moonshot-v1-8k' ||
+    modelId === 'moonshot-v1-32k' ||
+    modelId === 'moonshot-v1-128k' ||
+    modelId === 'moonshot-v1-auto' ||
+    modelId === 'moonshot-v1-8k-vision-preview' ||
+    modelId === 'moonshot-v1-32k-vision-preview' ||
+    modelId === 'moonshot-v1-128k-vision-preview'
+  );
 }
 
 export function createMoonshotAI(