@ai-sdk/moonshotai 3.0.38 → 3.0.42

package/CHANGELOG.md

@@ -1,5 +1,52 @@
 # @ai-sdk/moonshotai
 
+## 3.0.42
+
+### Patch Changes
+
+- Updated dependencies [90192f1]
+  - @ai-sdk/provider-utils@5.0.33
+
+## 3.0.41
+
+### Patch Changes
+
+- 87b49a2: fix(provider/moonshotai): preserve complete raw usage objects
+- 48c5f46: Preserve documented Moonshot API error codes in HTTP and streaming errors.
+- Updated dependencies [3e125ba]
+  - @ai-sdk/provider-utils@5.0.32
+
+## 3.0.40
+
+### Patch Changes
+
+- a336b12: Add first-class Moonshot V1 auto and vision-preview model IDs while preserving custom and retired model ID support.
+- e4f665c: Preserve documented Moonshot AI chat response metadata for generate and stream.
+- 85463b9: Add Moonshot AI Partial Mode support for continuing a final assistant message.
+- d354a42: fix(provider/moonshotai): send max output tokens with the current Moonshot request field
+- e5d5cbe: feat(provider/moonshotai): add predicted output support
+- 3da2b7d: Support Kimi K3 dynamic tool-loading system messages.
+
+## 3.0.39
+
+### Patch Changes
+
+- a06a14a: fix(provider/moonshotai): align thinking and reasoning options by model
+- 8fca314: Support inline text file data and native `ms://` image and video provider references in Moonshot chat prompts.
+- 35841f5: feat: normalize mid-stream provider error events across supported providers into public StreamProviderError instances and preserve provider-owned type, code, status, retry, and raw payload metadata
+- 1d19b2a: Add Moonshot Chat Completions log probability options and provider metadata.
+- d53589a: Accept Moonshot streaming tool calls without indices and preserve choice-level usage.
+- 462c498: Normalize Moonshot structured output schemas and enable strict validation by default.
+- 8037158: Use native JSON Schema structured outputs for official Moonshot V1 models.
+- c88b272: Reject unsupported image and video media types before sending Moonshot chat requests.
+- 4cf7c85: Add provider-specific names for Moonshot AI system, user, and assistant messages.
+- 1cb0493: fix(provider/moonshotai): omit unsupported sampling settings for Kimi models
+- 9645259: Omit required tool choice with a warning for Moonshot Kimi models that reject it.
+- Updated dependencies [a9782e1]
+- Updated dependencies [35841f5]
+- Updated dependencies [d2f3353]
+  - @ai-sdk/provider-utils@5.0.31
+
 ## 3.0.38
 
 ### Patch Changes

package/README.md

@@ -1,6 +1,6 @@
 # AI SDK - Moonshot AI Provider
 
-The **[Moonshot AI provider](https://ai-sdk.dev/providers/ai-sdk-providers/moonshotai)** for the [AI SDK](https://ai-sdk.dev/docs) contains language model support for the [Moonshot AI](https://platform.moonshot.cn) platform, including the Kimi model series.
+The **[Moonshot AI provider](https://ai-sdk.dev/providers/ai-sdk-providers/moonshotai)** for the [AI SDK](https://ai-sdk.dev/docs) contains language model support for the [Kimi API Platform](https://platform.kimi.ai/docs), including the Kimi model series.
 
 > **Deploying to Vercel?** With Vercel's AI Gateway you can access Moonshot AI (and hundreds of models from other providers) — no additional packages, API keys, or extra cost. [Get started with AI Gateway](https://vercel.com/ai-gateway).
 
@@ -40,23 +40,56 @@ const { text } = await generateText({
 });
 ```
 
-## Thinking Mode Example (Kimi K2 Thinking)
+## Reasoning Effort Example (Kimi K3)
 
 ```ts
-import { moonshotai } from '@ai-sdk/moonshotai';
+import {
+  moonshotai,
+  type MoonshotAILanguageModelOptions,
+} from '@ai-sdk/moonshotai';
 import { generateText } from 'ai';
 
-const { text } = await generateText({
-  model: moonshotai('kimi-k2-thinking'),
+const { text, reasoningText } = await generateText({
+  model: moonshotai('kimi-k3'),
   prompt: 'Solve this problem step by step: What is 15% of 240?',
-  moonshotai: {
-    thinking: {
-      type: 'enabled',
-      budgetTokens: 2048,
-    },
-    reasoningHistory: 'interleaved',
+  providerOptions: {
+    moonshotai: {
+      reasoningEffort: 'high',
+    } satisfies MoonshotAILanguageModelOptions,
   },
 });
+
+console.log(reasoningText);
+console.log(text);
+```
+
+Kimi K2.6 supports thinking and non-thinking modes. Enable it with
+`thinking: { type: 'enabled' }` or disable it with
+`thinking: { type: 'disabled' }`.
+
+Kimi K2.7 Code always has thinking enabled and uses Preserved Thinking. Keep
+reasoning history in multi-turn conversations:
+
+```ts
+import {
+  moonshotai,
+  type MoonshotAILanguageModelOptions,
+} from '@ai-sdk/moonshotai';
+import { generateText } from 'ai';
+
+const { text, reasoningText } = await generateText({
+  model: moonshotai('kimi-k2.7-code'),
+  prompt: 'Solve this problem step by step: What is 15% of 240?',
+  providerOptions: {
+    moonshotai: {
+      thinking: { type: 'enabled' },
+      reasoningHistory: 'preserved',
+    } satisfies MoonshotAILanguageModelOptions,
+  },
+});
+
+console.log(reasoningText);
+console.log(text);
 ```
 
 ## Documentation

package/dist/index.d.ts

@@ -1,30 +1,67 @@
-import { ProviderV4, LanguageModelV4 } from '@ai-sdk/provider';
+import { LanguageModelV4FunctionTool, ProviderV4, LanguageModelV4 } from '@ai-sdk/provider';
 import { FetchFunction } from '@ai-sdk/provider-utils';
 import { z } from 'zod/v4';
 
-type MoonshotAIChatModelId = 'moonshot-v1-8k' | 'moonshot-v1-32k' | 'moonshot-v1-128k' | 'kimi-k2.5' | 'kimi-k2.6' | 'kimi-k2.7-code' | 'kimi-k2.7-code-highspeed' | 'kimi-k3' | (string & {});
-declare const moonshotaiLanguageModelOptions: z.ZodObject<{
-    reasoningEffort: z.ZodOptional<z.ZodEnum<{
-        low: "low";
-        high: "high";
-        max: "max";
-    }>>;
-    thinking: z.ZodOptional<z.ZodObject<{
-        type: z.ZodOptional<z.ZodEnum<{
-            enabled: "enabled";
-            disabled: "disabled";
-        }>>;
-        budgetTokens: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
-    reasoningHistory: z.ZodOptional<z.ZodEnum<{
-        disabled: "disabled";
-        interleaved: "interleaved";
-        preserved: "preserved";
-    }>>;
-    promptCacheKey: z.ZodOptional<z.ZodString>;
-    safetyIdentifier: z.ZodOptional<z.ZodString>;
+type MoonshotAIChatModelId = 'moonshot-v1-auto' | 'moonshot-v1-8k' | 'moonshot-v1-32k' | 'moonshot-v1-128k' | 'moonshot-v1-8k-vision-preview' | 'moonshot-v1-32k-vision-preview' | 'moonshot-v1-128k-vision-preview' | 'kimi-k2.5' | 'kimi-k2.6' | 'kimi-k2.7-code' | 'kimi-k2.7-code-highspeed' | 'kimi-k3' | (string & {});
+type MoonshotAILanguageModelOptions = {
+    /**
+     * Whether to use strict JSON schema validation for structured outputs.
+     *
+     * @default true
+     */
+    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';
+        /**
+         * @deprecated Moonshot Chat Completions does not support thinking budgets.
+         * This value is ignored with a warning.
+         */
+        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;
+};
+declare const moonshotaiMessageProviderOptions: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type MoonshotAIMessageProviderOptions = z.infer<typeof moonshotaiMessageProviderOptions>;
+declare const moonshotaiAssistantMessageProviderOptions: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    partial: z.ZodOptional<z.ZodLiteral<true>>;
 }, z.core.$strip>;
-type MoonshotAILanguageModelOptions = z.infer<typeof moonshotaiLanguageModelOptions>;
+type MoonshotAIAssistantMessageProviderOptions = z.infer<typeof moonshotaiAssistantMessageProviderOptions>;
+type MoonshotAISystemMessageProviderOptions = MoonshotAIMessageProviderOptions & {
+    /** Function tools to load at this point in a Kimi K3 conversation. */
+    tools?: Array<Pick<LanguageModelV4FunctionTool, 'type' | 'name' | 'description' | 'inputSchema' | 'strict'>>;
+};
 
 interface MoonshotAIProviderSettings {
     /**
@@ -65,4 +102,4 @@ declare const moonshotai: MoonshotAIProvider;
 
 declare const VERSION: string;
 
-export { type MoonshotAIChatModelId, type MoonshotAILanguageModelOptions, type MoonshotAIProvider, type MoonshotAILanguageModelOptions as MoonshotAIProviderOptions, type MoonshotAIProviderSettings, VERSION, createMoonshotAI, moonshotai };
+export { type MoonshotAIAssistantMessageProviderOptions, type MoonshotAIChatModelId, type MoonshotAILanguageModelOptions, type MoonshotAIMessageProviderOptions, type MoonshotAIProvider, type MoonshotAILanguageModelOptions as MoonshotAIProviderOptions, type MoonshotAIProviderSettings, type MoonshotAISystemMessageProviderOptions, VERSION, createMoonshotAI, moonshotai };