@ai-sdk/moonshotai 3.0.31 → 3.0.33

package/src/moonshotai-provider.ts

@@ -1,4 +1,3 @@
-import type { ProviderErrorStructure } from '@ai-sdk/openai-compatible';
 import {
   NoSuchModelError,
   type LanguageModelV4,
@@ -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,
-          }),
-        };
-      },
     });
   };