@ai-sdk/moonshotai 0.0.20 → 0.0.25

package/src/moonshotai-chat-metadata-extractor.ts

@@ -0,0 +1,112 @@
+import type { MetadataExtractor } from '@ai-sdk/openai-compatible';
+import type { JSONValue } from '@ai-sdk/provider';
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value != null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function getFirstChoice(value: Record<string, unknown>) {
+  const choices = value.choices;
+  return Array.isArray(choices) && isRecord(choices[0])
+    ? choices[0]
+    : undefined;
+}
+
+function getToolCallTypes(value: unknown): Array<'function'> | undefined {
+  if (!Array.isArray(value)) {
+    return undefined;
+  }
+
+  return value.flatMap(toolCall =>
+    isRecord(toolCall) && toolCall.type === 'function' ? [toolCall.type] : [],
+  );
+}
+
+function extractMetadata(value: unknown): Record<string, JSONValue> {
+  if (!isRecord(value)) {
+    return {};
+  }
+
+  const choice = getFirstChoice(value);
+  const message =
+    choice != null && isRecord(choice.message) ? choice.message : undefined;
+  const toolCallTypes = getToolCallTypes(message?.tool_calls);
+
+  return {
+    ...(value.object === 'chat.completion' && {
+      responseObject: value.object,
+    }),
+    ...(typeof choice?.index === 'number' && {
+      choiceIndex: choice.index,
+    }),
+    ...(message?.role === 'assistant' && {
+      messageRole: message.role,
+    }),
+    ...(toolCallTypes != null && { toolCallTypes }),
+  };
+}
+
+export const moonshotAIChatMetadataExtractor: MetadataExtractor = {
+  async extractMetadata({ parsedBody }) {
+    return { moonshotai: extractMetadata(parsedBody) };
+  },
+
+  createStreamExtractor() {
+    let responseObject: 'chat.completion.chunk' | undefined;
+    let choiceIndex: number | undefined;
+    let messageRole: 'assistant' | undefined;
+    const toolCallTypes = new Map<number, 'function'>();
+
+    return {
+      processChunk(parsedChunk) {
+        if (!isRecord(parsedChunk)) {
+          return;
+        }
+
+        if (parsedChunk.object === 'chat.completion.chunk') {
+          responseObject = parsedChunk.object;
+        }
+
+        const choice = getFirstChoice(parsedChunk);
+        if (typeof choice?.index === 'number') {
+          choiceIndex = choice.index;
+        }
+
+        const delta =
+          choice != null && isRecord(choice.delta) ? choice.delta : undefined;
+        if (delta?.role === 'assistant') {
+          messageRole = delta.role;
+        }
+
+        if (Array.isArray(delta?.tool_calls)) {
+          for (const [fallbackIndex, toolCall] of delta.tool_calls.entries()) {
+            if (!isRecord(toolCall) || toolCall.type !== 'function') {
+              continue;
+            }
+
+            const index =
+              typeof toolCall.index === 'number'
+                ? toolCall.index
+                : fallbackIndex;
+            toolCallTypes.set(index, toolCall.type);
+          }
+        }
+      },
+
+      buildMetadata() {
+        return {
+          moonshotai: {
+            ...(responseObject != null && { responseObject }),
+            ...(choiceIndex != null && { choiceIndex }),
+            ...(messageRole != null && { messageRole }),
+            ...(toolCallTypes.size > 0 && {
+              toolCallTypes: [...toolCallTypes.entries()]
+                .sort(([left], [right]) => left - right)
+                .map(([, type]) => type),
+            }),
+          },
+        };
+      },
+    };
+  },
+};

package/src/moonshotai-chat-options.ts

@@ -1,34 +1,212 @@
+import type { LanguageModelV2FunctionTool } from '@ai-sdk/provider';
 import { z } from 'zod/v4';
 
 export type MoonshotAIChatModelId =
+  | 'moonshot-v1-auto'
   | 'moonshot-v1-8k'
   | 'moonshot-v1-32k'
   | 'moonshot-v1-128k'
-  | 'kimi-k2'
-  | 'kimi-k2-0905'
-  | 'kimi-k2-thinking'
-  | 'kimi-k2-thinking-turbo'
-  | 'kimi-k2-turbo'
+  | '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 & {});
 
+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 function isMoonshotAIKimiModel(modelId: MoonshotAIChatModelId): boolean {
+  return getMoonshotAIModelFamily(modelId).startsWith('kimi-');
+}
+
 export const moonshotaiProviderOptions = z.object({
   /**
-   * Reasoning effort for Kimi K3. Currently, only `max` is supported.
+   * Whether to use strict JSON schema validation for structured outputs.
+   *
+   * @default true
+   */
+  strictJsonSchema: z.boolean().optional(),
+
+  /**
+   * 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.
    */
-  reasoningEffort: z.literal('max').optional(),
+  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(),
+      /**
+       * @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(),
 });
 
-export type MoonshotAIProviderOptions = z.infer<
-  typeof moonshotaiProviderOptions
+export type MoonshotAIProviderOptions = {
+  /**
+   * 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';
+};
+
+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<
+        LanguageModelV2FunctionTool,
+        'type' | 'name' | 'description' | 'inputSchema'
+      > & {
+        /** Whether Moonshot should enforce the tool input schema strictly. */
+        strict?: boolean;
+      }
+    >;
+  };

package/src/moonshotai-provider.ts

@@ -21,6 +21,7 @@ const moonshotaiErrorSchema = z.object({
   error: z.object({
     message: z.string(),
     type: z.string().nullish(),
+    code: z.string().nullish(),
   }),
 });
 
@@ -69,6 +70,21 @@ export interface MoonshotAIProvider extends ProviderV2 {
 
 const defaultBaseURL = 'https://api.moonshot.ai/v1';
 
+export function getModelStructuredOutputSupport(
+  modelId: MoonshotAIChatModelId,
+): boolean {
+  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(
   options: MoonshotAIProviderSettings = {},
 ): MoonshotAIProvider {
@@ -105,6 +121,7 @@ export function createMoonshotAI(
       ...getCommonModelConfig('chat'),
       includeUsage: true,
       errorStructure: moonshotaiErrorStructure,
+      supportsStructuredOutputs: getModelStructuredOutputSupport(modelId),
     });
   };
 

package/src/normalize-json-schema-for-mfjs.ts

@@ -0,0 +1,103 @@
+import { UnsupportedFunctionalityError } from '@ai-sdk/provider';
+
+const SCHEMA_ARRAY_KEYS = ['allOf', 'anyOf', 'oneOf', 'prefixItems'] as const;
+const SCHEMA_MAP_KEYS = [
+  'properties',
+  'patternProperties',
+  '$defs',
+  'dependentSchemas',
+] as const;
+const SCHEMA_SINGLE_KEYS = [
+  'additionalProperties',
+  'propertyNames',
+  'items',
+  'contains',
+  'not',
+  'if',
+  'then',
+  'else',
+] as const;
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value != null && typeof value === 'object' && !Array.isArray(value);
+}
+
+/**
+ * Normalizes a JSON Schema to the subset Moonshot's MFJS validator accepts:
+ * `object` root required, tuple `items` become `prefixItems`, and `type` next
+ * to `anyOf` moves into the branches. Everything else passes through. The
+ * full original schema is still used for AI SDK result validation.
+ */
+export function normalizeJsonSchemaForMFJS(schema: unknown): unknown {
+  return normalizeDefinition(schema, true);
+}
+
+function normalizeDefinition(definition: unknown, isRoot: boolean): unknown {
+  if (typeof definition === 'boolean' || !isRecord(definition)) {
+    if (isRoot) {
+      throw new UnsupportedFunctionalityError({
+        functionality:
+          'tool parameters must be a JSON Schema object with type "object" for moonshotai (MFJS)',
+      });
+    }
+    return definition;
+  }
+
+  if (isRoot && definition.type !== 'object') {
+    throw new UnsupportedFunctionalityError({
+      functionality:
+        'tool parameters must be a JSON Schema object with type "object" for moonshotai (MFJS)',
+    });
+  }
+
+  const result: Record<string, unknown> = { ...definition };
+
+  if (Array.isArray(result.items)) {
+    const tuple = result.items;
+    result.prefixItems = [
+      ...(Array.isArray(result.prefixItems) ? result.prefixItems : []),
+      ...tuple.map(item => normalizeDefinition(item, false)),
+    ];
+    delete result.items;
+  } else if (isRecord(result.items)) {
+    result.items = normalizeDefinition(result.items, false);
+  }
+
+  if (typeof result.type === 'string' && Array.isArray(result.anyOf)) {
+    const parentType = result.type;
+    delete result.type;
+    result.anyOf = result.anyOf.map(branch =>
+      isRecord(branch) && branch.type == null
+        ? { type: parentType, ...branch }
+        : branch,
+    );
+  }
+
+  for (const key of SCHEMA_ARRAY_KEYS) {
+    const value = result[key];
+    if (Array.isArray(value)) {
+      result[key] = value.map(item => normalizeDefinition(item, false));
+    }
+  }
+
+  for (const key of SCHEMA_MAP_KEYS) {
+    const value = result[key];
+    if (isRecord(value)) {
+      result[key] = Object.fromEntries(
+        Object.entries(value).map(([key, item]) => [
+          key,
+          normalizeDefinition(item, false),
+        ]),
+      );
+    }
+  }
+
+  for (const key of SCHEMA_SINGLE_KEYS) {
+    const value = result[key];
+    if (isRecord(value) || typeof value === 'boolean') {
+      result[key] = normalizeDefinition(value, false);
+    }
+  }
+
+  return result;
+}