@ai-sdk/moonshotai 2.0.43 → 2.0.45

package/src/moonshotai-prepare-tools.ts

@@ -0,0 +1,98 @@
+import {
+  UnsupportedFunctionalityError,
+  type LanguageModelV3CallOptions,
+  type SharedV3Warning,
+} from '@ai-sdk/provider';
+
+export function prepareTools({
+  tools,
+  toolChoice,
+}: {
+  tools: LanguageModelV3CallOptions['tools'];
+  toolChoice?: LanguageModelV3CallOptions['toolChoice'];
+}): {
+  tools:
+    | undefined
+    | Array<{
+        type: 'function';
+        function: {
+          name: string;
+          description: string | undefined;
+          parameters: unknown;
+          strict?: boolean;
+        };
+      }>;
+  toolChoice:
+    | { type: 'function'; function: { name: string } }
+    | 'auto'
+    | 'none'
+    | 'required'
+    | undefined;
+  toolWarnings: SharedV3Warning[];
+} {
+  // when the tools array is empty, change it to undefined to prevent errors:
+  tools = tools?.length ? tools : undefined;
+
+  const toolWarnings: SharedV3Warning[] = [];
+
+  if (tools == null) {
+    return { tools: undefined, toolChoice: undefined, toolWarnings };
+  }
+
+  const moonshotTools: Array<{
+    type: 'function';
+    function: {
+      name: string;
+      description: string | undefined;
+      parameters: unknown;
+      strict?: boolean;
+    };
+  }> = [];
+
+  for (const tool of tools) {
+    if (tool.type === 'provider') {
+      toolWarnings.push({
+        type: 'unsupported',
+        feature: `provider-defined tool ${tool.id}`,
+      });
+    } else {
+      moonshotTools.push({
+        type: 'function',
+        function: {
+          name: tool.name,
+          description: tool.description,
+          parameters: tool.inputSchema,
+          ...(tool.strict != null ? { strict: tool.strict } : {}),
+        },
+      });
+    }
+  }
+
+  if (toolChoice == null) {
+    return { tools: moonshotTools, toolChoice: undefined, toolWarnings };
+  }
+
+  const type = toolChoice.type;
+
+  switch (type) {
+    case 'auto':
+    case 'none':
+    case 'required':
+      return { tools: moonshotTools, toolChoice: type, toolWarnings };
+    case 'tool':
+      return {
+        tools: moonshotTools,
+        toolChoice: {
+          type: 'function',
+          function: { name: toolChoice.toolName },
+        },
+        toolWarnings,
+      };
+    default: {
+      const _exhaustiveCheck: never = type;
+      throw new UnsupportedFunctionalityError({
+        functionality: `tool choice type: ${_exhaustiveCheck}`,
+      });
+    }
+  }
+}

package/src/moonshotai-provider.ts

@@ -1,4 +1,3 @@
-import type { ProviderErrorStructure } from '@ai-sdk/openai-compatible';
 import {
   NoSuchModelError,
   type LanguageModelV3,
@@ -10,24 +9,11 @@ import {
   withUserAgentSuffix,
   type FetchFunction,
 } from '@ai-sdk/provider-utils';
-import { z } from 'zod/v4';
 import { MoonshotAIChatLanguageModel } from './moonshotai-chat-language-model';
 import type { MoonshotAIChatModelId } from './moonshotai-chat-options';
 import { VERSION } from './version';
 
-export type MoonshotAIErrorData = z.infer<typeof moonshotaiErrorSchema>;
-
-const moonshotaiErrorSchema = z.object({
-  error: z.object({
-    message: z.string(),
-    type: z.string().nullish(),
-  }),
-});
-
-const moonshotaiErrorStructure: ProviderErrorStructure<MoonshotAIErrorData> = {
-  errorSchema: moonshotaiErrorSchema,
-  errorToMessage: data => data.error.message,
-};
+export type { MoonshotAIErrorData } from './moonshotai-chat-api-types';
 
 export interface MoonshotAIProviderSettings {
   /**
@@ -93,65 +79,14 @@ export function createMoonshotAI(
       `ai-sdk/moonshotai/${VERSION}`,
     );
 
-  interface CommonModelConfig {
-    provider: string;
-    url: ({ path }: { path: string }) => string;
-    headers: () => Record<string, string>;
-    fetch?: FetchFunction;
-  }
-
-  const getCommonModelConfig = (modelType: string): CommonModelConfig => ({
-    provider: `moonshotai.${modelType}`,
-    url: ({ path }) => `${baseURL}${path}`,
-    headers: getHeaders,
-    fetch: options.fetch,
-  });
-
   const createChatModel = (modelId: MoonshotAIChatModelId) => {
     return new MoonshotAIChatLanguageModel(modelId, {
-      ...getCommonModelConfig('chat'),
+      provider: 'moonshotai.chat',
+      url: ({ path }) => `${baseURL}${path}`,
+      headers: getHeaders,
+      fetch: options.fetch,
       includeUsage: true,
-      errorStructure: moonshotaiErrorStructure,
       supportsStructuredOutputs: getModelStructuredOutputSupport(modelId),
-      transformRequestBody: (args: Record<string, any>) => {
-        const thinking = args.thinking as
-          | { type?: string; budgetTokens?: number }
-          | undefined;
-        const reasoningHistory = args.reasoningHistory as string | undefined;
-
-        const { thinking: _, reasoningHistory: __, ...rest } = args;
-
-        const schema = rest.response_format?.json_schema?.schema;
-        if (schema != null) {
-          // kimi-k2.5 produces nonsensical output when the top-level `$schema`
-          // keyword injected by the AI SDK is present, even though it otherwise
-          // supports structured outputs. Strip it from the schema sent to
-          // Moonshot; the full original schema is still used for result validation.
-          const { $schema: _$schema, ...schemaWithoutDollarSchema } = schema;
-          rest.response_format = {
-            ...rest.response_format,
-            json_schema: {
-              ...rest.response_format.json_schema,
-              schema: schemaWithoutDollarSchema,
-            },
-          };
-        }
-
-        return {
-          ...rest,
-          ...(thinking && {
-            thinking: {
-              type: thinking.type,
-              ...(thinking.budgetTokens !== undefined && {
-                budget_tokens: thinking.budgetTokens,
-              }),
-            },
-          }),
-          ...(reasoningHistory && {
-            reasoning_history: reasoningHistory,
-          }),
-        };
-      },
     });
   };