kimi-vercel-ai-sdk-provider 0.2.0

package/src/code/kimi-code-messages.ts

@@ -0,0 +1,303 @@
+/**
+ * Message conversion for Kimi Code API.
+ * Converts AI SDK messages to Anthropic-compatible format used by Kimi Code.
+ * @module
+ */
+
+import type { LanguageModelV3FilePart, LanguageModelV3Prompt } from '@ai-sdk/provider';
+import { UnsupportedFunctionalityError } from '@ai-sdk/provider';
+import { convertToBase64 } from '@ai-sdk/provider-utils';
+
+// ============================================================================
+// Types
+// ============================================================================
+
+/**
+ * Kimi Code message content part types.
+ */
+export type KimiCodeContentPart =
+  | { type: 'text'; text: string }
+  | { type: 'image'; source: { type: 'base64'; media_type: string; data: string } }
+  | { type: 'image'; source: { type: 'url'; url: string } }
+  | { type: 'tool_use'; id: string; name: string; input: Record<string, unknown> }
+  | { type: 'tool_result'; tool_use_id: string; content: string | KimiCodeContentPart[]; is_error?: boolean };
+
+/**
+ * Kimi Code message format (Anthropic-compatible).
+ */
+export interface KimiCodeMessage {
+  role: 'user' | 'assistant';
+  content: string | KimiCodeContentPart[];
+}
+
+/**
+ * Kimi Code prompt structure.
+ */
+export interface KimiCodePrompt {
+  system?: string;
+  messages: KimiCodeMessage[];
+}
+
+// ============================================================================
+// Conversion Functions
+// ============================================================================
+
+/**
+ * Convert AI SDK prompt to Kimi Code message format.
+ *
+ * @param prompt - AI SDK prompt
+ * @returns Kimi Code formatted prompt with system and messages
+ */
+export async function convertToKimiCodePrompt(prompt: LanguageModelV3Prompt): Promise<KimiCodePrompt> {
+  let systemMessage: string | undefined;
+  const messages: KimiCodeMessage[] = [];
+
+  for (const message of prompt) {
+    switch (message.role) {
+      case 'system': {
+        // System messages have content as string in V3
+        const systemText = typeof message.content === 'string' ? message.content : '';
+        systemMessage = systemMessage ? `${systemMessage}\n\n${systemText}` : systemText;
+        break;
+      }
+
+      case 'user': {
+        const content: KimiCodeContentPart[] = [];
+
+        for (const part of message.content) {
+          switch (part.type) {
+            case 'text':
+              content.push({ type: 'text', text: part.text });
+              break;
+
+            case 'file':
+              // Check if it's an image file
+              if (part.mediaType?.startsWith('image/')) {
+                content.push(await convertFilePart(part));
+              } else {
+                throw new UnsupportedFunctionalityError({
+                  functionality: `file type: ${part.mediaType}`
+                });
+              }
+              break;
+
+            default:
+              throw new UnsupportedFunctionalityError({
+                functionality: `user content part type: ${(part as { type: string }).type}`
+              });
+          }
+        }
+
+        messages.push({
+          role: 'user',
+          content: content.length === 1 && content[0].type === 'text' ? content[0].text : content
+        });
+        break;
+      }
+
+      case 'assistant': {
+        const content: KimiCodeContentPart[] = [];
+
+        for (const part of message.content) {
+          switch (part.type) {
+            case 'text':
+              content.push({ type: 'text', text: part.text });
+              break;
+
+            case 'tool-call':
+              content.push({
+                type: 'tool_use',
+                id: part.toolCallId,
+                name: part.toolName,
+                input: typeof part.input === 'string' ? JSON.parse(part.input) : (part.input as Record<string, unknown>)
+              });
+              break;
+
+            case 'reasoning':
+              // Include reasoning as text (Kimi Code handles thinking blocks)
+              if (part.text) {
+                content.push({ type: 'text', text: `<thinking>${part.text}</thinking>` });
+              }
+              break;
+
+            default:
+              throw new UnsupportedFunctionalityError({
+                functionality: `assistant content part type: ${(part as { type: string }).type}`
+              });
+          }
+        }
+
+        if (content.length > 0) {
+          messages.push({
+            role: 'assistant',
+            content: content.length === 1 && content[0].type === 'text' ? content[0].text : content
+          });
+        }
+        break;
+      }
+
+      case 'tool': {
+        // Tool results need to be part of a user message in Anthropic format
+        const toolResults: KimiCodeContentPart[] = [];
+
+        for (const part of message.content) {
+          if (part.type === 'tool-result') {
+            toolResults.push(convertToolResultPart(part));
+          }
+        }
+
+        // If the last message is from the assistant, add tool results as user message
+        if (messages.length > 0 && messages[messages.length - 1].role === 'assistant') {
+          messages.push({
+            role: 'user',
+            content: toolResults
+          });
+        } else {
+          // Merge with existing user message or create new one
+          const lastMessage = messages[messages.length - 1];
+          if (lastMessage?.role === 'user' && Array.isArray(lastMessage.content)) {
+            lastMessage.content.push(...toolResults);
+          } else {
+            messages.push({
+              role: 'user',
+              content: toolResults
+            });
+          }
+        }
+        break;
+      }
+
+      default:
+        throw new UnsupportedFunctionalityError({
+          functionality: `message role: ${(message as { role: string }).role}`
+        });
+    }
+  }
+
+  return {
+    system: systemMessage,
+    messages
+  };
+}
+
+/**
+ * Convert a file part to Kimi Code format.
+ */
+async function convertFilePart(part: LanguageModelV3FilePart): Promise<KimiCodeContentPart> {
+  const mediaType = part.mediaType ?? 'image/png';
+
+  // Handle URL data
+  if (part.data instanceof URL) {
+    return {
+      type: 'image',
+      source: {
+        type: 'url',
+        url: part.data.toString()
+      }
+    };
+  }
+
+  // Handle string data
+  if (typeof part.data === 'string') {
+    // Check if it's a URL string
+    if (part.data.startsWith('http://') || part.data.startsWith('https://')) {
+      return {
+        type: 'image',
+        source: {
+          type: 'url',
+          url: part.data
+        }
+      };
+    }
+
+    // Check if it's a data URL
+    if (part.data.startsWith('data:')) {
+      const [header, data] = part.data.split(',');
+      const extractedMimeType = header.match(/data:([^;]+)/)?.[1] ?? mediaType;
+      return {
+        type: 'image',
+        source: {
+          type: 'base64',
+          media_type: extractedMimeType,
+          data
+        }
+      };
+    }
+
+    // Assume it's base64 encoded
+    return {
+      type: 'image',
+      source: {
+        type: 'base64',
+        media_type: mediaType,
+        data: part.data
+      }
+    };
+  }
+
+  // Handle Uint8Array - convert to base64
+  const base64 = convertToBase64(part.data);
+  return {
+    type: 'image',
+    source: {
+      type: 'base64',
+      media_type: mediaType,
+      data: base64
+    }
+  };
+}
+
+/**
+ * Tool result output type from LanguageModelV3.
+ */
+interface ToolResultOutput {
+  type: 'text' | 'error-text' | 'json' | 'error-json' | 'content' | 'execution-denied';
+  value?: unknown;
+  reason?: string;
+}
+
+/**
+ * Convert a tool result part to Kimi Code format.
+ */
+function convertToolResultPart(part: {
+  type: 'tool-result';
+  toolCallId: string;
+  toolName: string;
+  output: ToolResultOutput;
+}): KimiCodeContentPart {
+  // Handle different output types based on the discriminated union
+  const output = part.output;
+  let content: string;
+  let isError = false;
+
+  switch (output.type) {
+    case 'text':
+      content = String(output.value ?? '');
+      break;
+    case 'error-text':
+      content = String(output.value ?? '');
+      isError = true;
+      break;
+    case 'execution-denied':
+      content = output.reason ?? 'Tool execution denied.';
+      isError = true;
+      break;
+    case 'json':
+    case 'content':
+      content = JSON.stringify(output.value);
+      break;
+    case 'error-json':
+      content = JSON.stringify(output.value);
+      isError = true;
+      break;
+    default:
+      content = JSON.stringify(output);
+  }
+
+  return {
+    type: 'tool_result',
+    tool_use_id: part.toolCallId,
+    content,
+    is_error: isError || undefined
+  };
+}

package/src/code/kimi-code-provider.ts

@@ -0,0 +1,239 @@
+/**
+ * Kimi Code provider factory.
+ * @module
+ */
+
+import type { KimiCodeSettings } from './kimi-code-settings';
+import { type LanguageModelV3, NoSuchModelError, type ProviderV3 } from '@ai-sdk/provider';
+import {
+  type FetchFunction,
+  loadOptionalSetting,
+  withUserAgentSuffix,
+  withoutTrailingSlash
+} from '@ai-sdk/provider-utils';
+import { VERSION } from '../version';
+import { KimiCodeLanguageModel } from './kimi-code-language-model';
+import { KIMI_CODE_BASE_URL, KIMI_CODE_DEFAULT_MODEL, type KimiCodeModelId } from './kimi-code-types';
+
+// ============================================================================
+// Provider Settings
+// ============================================================================
+
+/**
+ * Settings for creating a Kimi Code provider instance.
+ */
+export interface KimiCodeProviderSettings {
+  /**
+   * Kimi Code API key. Defaults to the KIMI_CODE_API_KEY or KIMI_API_KEY environment variable.
+   */
+  apiKey?: string;
+
+  /**
+   * Base URL override. Defaults to https://api.kimi.com/coding/v1
+   */
+  baseURL?: string;
+
+  /**
+   * Default headers for all requests.
+   */
+  headers?: Record<string, string | undefined>;
+
+  /**
+   * Custom fetch implementation.
+   */
+  fetch?: FetchFunction;
+
+  /**
+   * ID generator for tool call fallback IDs.
+   */
+  generateId?: () => string;
+
+  /**
+   * Include usage details in streaming responses.
+   */
+  includeUsageInStream?: boolean;
+
+  /**
+   * Override supported URL patterns for file parts.
+   */
+  supportedUrls?: LanguageModelV3['supportedUrls'];
+}
+
+// ============================================================================
+// Provider Interface
+// ============================================================================
+
+/**
+ * The Kimi Code provider interface.
+ */
+export interface KimiCodeProvider extends Omit<ProviderV3, 'specificationVersion'> {
+  specificationVersion: 'v3';
+
+  /**
+   * Creates a Kimi Code language model.
+   * @param modelId - The model identifier (defaults to 'kimi-for-coding')
+   * @param settings - Optional model settings
+   */
+  (modelId?: KimiCodeModelId, settings?: KimiCodeSettings): LanguageModelV3;
+
+  /**
+   * Creates a Kimi Code language model.
+   * @param modelId - The model identifier
+   * @param settings - Optional model settings
+   */
+  languageModel(modelId: KimiCodeModelId, settings?: KimiCodeSettings): LanguageModelV3;
+
+  /**
+   * Creates a Kimi Code language model (alias for languageModel).
+   * @param modelId - The model identifier
+   * @param settings - Optional model settings
+   */
+  chat(modelId: KimiCodeModelId, settings?: KimiCodeSettings): LanguageModelV3;
+}
+
+// ============================================================================
+// Provider Factory
+// ============================================================================
+
+/**
+ * Create a Kimi Code provider instance.
+ *
+ * @param options - Provider settings
+ * @returns A configured Kimi Code provider
+ *
+ * @example
+ * ```ts
+ * import { createKimiCode } from 'kimi-vercel-ai-sdk-provider
+';
+ *
+ * const kimiCode = createKimiCode({
+ *   apiKey: process.env.KIMI_CODE_API_KEY,
+ * });
+ *
+ * const result = await generateText({
+ *   model: kimiCode(), // Uses default 'kimi-for-coding' model
+ *   prompt: 'Write a TypeScript function to merge two sorted arrays',
+ * });
+ * ```
+ *
+ * @example
+ * ```ts
+ * // With extended thinking enabled
+ * const result = await generateText({
+ *   model: kimiCode('kimi-for-coding', {
+ *     extendedThinking: {
+ *       enabled: true,
+ *       effort: 'high'
+ *     }
+ *   }),
+ *   prompt: 'Design a distributed cache system',
+ * });
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Using with Claude Code compatible settings
+ * const result = await generateText({
+ *   model: kimiCode('kimi-k2-thinking'),
+ *   prompt: 'Explain and fix this bug',
+ * });
+ * ```
+ */
+export function createKimiCode(options: KimiCodeProviderSettings = {}): KimiCodeProvider {
+  const resolvedBaseURL =
+    loadOptionalSetting({
+      settingValue: options.baseURL,
+      environmentVariableName: 'KIMI_CODE_BASE_URL'
+    }) ?? KIMI_CODE_BASE_URL;
+
+  const baseURL = withoutTrailingSlash(resolvedBaseURL) ?? KIMI_CODE_BASE_URL;
+
+  const getHeaders = () => {
+    // Try KIMI_CODE_API_KEY first, fall back to KIMI_API_KEY
+    let apiKey = options.apiKey;
+    if (!apiKey) {
+      apiKey = process.env.KIMI_CODE_API_KEY ?? process.env.KIMI_API_KEY;
+    }
+    if (!apiKey) {
+      throw new Error(
+        'Kimi Code API key is required. Set the KIMI_CODE_API_KEY or KIMI_API_KEY environment variable, or pass the apiKey option.'
+      );
+    }
+
+    return withUserAgentSuffix(
+      {
+        'x-api-key': apiKey,
+        'anthropic-version': '2023-06-01',
+        ...options.headers
+      },
+      `ai-sdk/kimi-code/${VERSION}`
+    );
+  };
+
+  const createCodeModel = (modelId: KimiCodeModelId = KIMI_CODE_DEFAULT_MODEL, settings: KimiCodeSettings = {}) =>
+    new KimiCodeLanguageModel(modelId, settings, {
+      provider: 'kimi.code',
+      baseURL,
+      headers: getHeaders,
+      fetch: options.fetch,
+      generateId: options.generateId,
+      includeUsageInStream: settings.includeUsageInStream ?? options.includeUsageInStream,
+      supportedUrls: settings.supportedUrls ?? options.supportedUrls
+    });
+
+  const provider: KimiCodeProvider = (
+    modelId: KimiCodeModelId = KIMI_CODE_DEFAULT_MODEL,
+    settings?: KimiCodeSettings
+  ): KimiCodeLanguageModel => {
+    if (new.target) {
+      throw new Error('The Kimi Code provider function cannot be called with new.');
+    }
+
+    return createCodeModel(modelId, settings);
+  };
+
+  provider.specificationVersion = 'v3';
+  provider.languageModel = createCodeModel;
+  provider.chat = createCodeModel;
+
+  provider.embeddingModel = (modelId: string) => {
+    throw new NoSuchModelError({ modelId, modelType: 'embeddingModel' });
+  };
+
+  provider.imageModel = (modelId: string) => {
+    throw new NoSuchModelError({ modelId, modelType: 'imageModel' });
+  };
+
+  provider.rerankingModel = (modelId: string) => {
+    throw new NoSuchModelError({ modelId, modelType: 'rerankingModel' });
+  };
+
+  return provider;
+}
+
+/**
+ * Default Kimi Code provider instance.
+ *
+ * Uses the KIMI_CODE_API_KEY or KIMI_API_KEY environment variable for authentication.
+ *
+ * @example
+ * ```ts
+ * import { kimiCode } from 'kimi-vercel-ai-sdk-provider
+';
+ *
+ * const result = await generateText({
+ *   model: kimiCode(), // Uses default model
+ *   prompt: 'Implement a binary search tree',
+ * });
+ * ```
+ *
+ * @example
+ * ```ts
+ * // With extended thinking
+ * const result = await generateText({
+ *   model: kimiCode('kimi-for-coding', { extendedThinking: true }),
+ *   prompt: 'Design a microservices architecture',
+ * });
+ * ```
+ */
+export const kimiCode = createKimiCode();