kimi-vercel-ai-sdk-provider 0.2.0 → 0.4.0

package/dist/index.mjs

@@ -31,7 +31,7 @@ var kimiErrorSchema = z.union([
     error: z.object({
       message: z.string(),
       type: z.string().nullish(),
-      param: z.any().nullish(),
+      param: z.string().nullish(),
       code: z.union([z.string(), z.number()]).nullish(),
       request_id: z.string().nullish()
     })
@@ -98,6 +98,9 @@ var KimiContextLengthError = class extends KimiError {
 };
 
 // src/core/types.ts
+var THINKING_MODEL_TEMPERATURE = 1;
+var THINKING_MODEL_DEFAULT_MAX_TOKENS = 32768;
+var STANDARD_MODEL_DEFAULT_MAX_TOKENS = 4096;
 function inferModelCapabilities(modelId) {
   const isThinkingModel = modelId.includes("-thinking");
   const isK25Model = modelId.includes("k2.5") || modelId.includes("k2-5");
@@ -112,7 +115,12 @@ function inferModelCapabilities(modelId) {
     // 256k context window
     toolCalling: true,
     jsonMode: true,
-    structuredOutputs: true
+    structuredOutputs: true,
+    // Thinking models require temperature=1.0 for optimal reasoning
+    defaultTemperature: isThinkingModel ? THINKING_MODEL_TEMPERATURE : void 0,
+    temperatureLocked: isThinkingModel,
+    // Thinking models need higher token limits to avoid truncated reasoning
+    defaultMaxOutputTokens: isThinkingModel ? THINKING_MODEL_DEFAULT_MAX_TOKENS : STANDARD_MODEL_DEFAULT_MAX_TOKENS
   };
 }
 
@@ -260,24 +268,25 @@ function isBuiltinToolName(toolName) {
 }
 var kimiTools = {
   /**
-   * Create a web search tool for use with Kimi models.
-   *
-   * @param config - Optional configuration
-   * @returns A provider tool definition
-   *
-   * @example
-   * ```ts
-   * import { kimi, kimiTools } from 'ai-sdk-provider-kimi';
-   *
-   * const result = await generateText({
-   *   model: kimi('kimi-k2.5'),
-   *   tools: {
-   *     webSearch: kimiTools.webSearch(),
-   *   },
-   *   prompt: 'What are the latest AI news?',
-   * });
-   * ```
-   */
+     * Create a web search tool for use with Kimi models.
+     *
+     * @param config - Optional configuration
+     * @returns A provider tool definition
+     *
+     * @example
+     * ```ts
+     * import { kimi, kimiTools } from 'kimi-vercel-ai-sdk-provider
+  ';
+     *
+     * const result = await generateText({
+     *   model: kimi('kimi-k2.5'),
+     *   tools: {
+     *     webSearch: kimiTools.webSearch(),
+     *   },
+     *   prompt: 'What are the latest AI news?',
+     * });
+     * ```
+     */
   webSearch: (config) => {
     return {
       type: "provider",
@@ -286,24 +295,25 @@ var kimiTools = {
     };
   },
   /**
-   * Create a code interpreter tool for use with Kimi models.
-   *
-   * @param config - Optional configuration
-   * @returns A provider tool definition
-   *
-   * @example
-   * ```ts
-   * import { kimi, kimiTools } from 'ai-sdk-provider-kimi';
-   *
-   * const result = await generateText({
-   *   model: kimi('kimi-k2.5'),
-   *   tools: {
-   *     codeInterpreter: kimiTools.codeInterpreter(),
-   *   },
-   *   prompt: 'Calculate the factorial of 10',
-   * });
-   * ```
-   */
+     * Create a code interpreter tool for use with Kimi models.
+     *
+     * @param config - Optional configuration
+     * @returns A provider tool definition
+     *
+     * @example
+     * ```ts
+     * import { kimi, kimiTools } from 'kimi-vercel-ai-sdk-provider
+  ';
+     *
+     * const result = await generateText({
+     *   model: kimi('kimi-k2.5'),
+     *   tools: {
+     *     codeInterpreter: kimiTools.codeInterpreter(),
+     *   },
+     *   prompt: 'Calculate the factorial of 10',
+     * });
+     * ```
+     */
   codeInterpreter: (config) => {
     return {
       type: "provider",
@@ -349,13 +359,15 @@ function prepareKimiTools({
         });
         continue;
       }
+      const sanitizedSchema = sanitizeToolSchema(tool.inputSchema);
       kimiTools2.push({
         type: "function",
         function: {
           name: tool.name,
           description: tool.description,
-          parameters: tool.inputSchema,
-          ...tool.strict != null ? { strict: tool.strict } : {}
+          parameters: sanitizedSchema
+          // Don't pass strict mode to Kimi - it may cause issues
+          // ...(tool.strict != null ? { strict: tool.strict } : {})
         }
       });
     }
@@ -429,6 +441,61 @@ function generateRequiredToolMessage(toolNames) {
 function generateSpecificToolMessage(toolName) {
   return `IMPORTANT INSTRUCTION: You MUST use the "${toolName}" tool to respond to this request. Do NOT use any other tool or provide a direct text response. Call the "${toolName}" tool with appropriate parameters.`;
 }
+var UNSUPPORTED_SCHEMA_KEYWORDS = [
+  "$schema",
+  "$id",
+  "$ref",
+  "$defs",
+  "definitions",
+  "if",
+  "then",
+  "else",
+  "allOf",
+  "anyOf",
+  "oneOf",
+  "not",
+  "patternProperties",
+  "additionalItems",
+  "contains",
+  "propertyNames",
+  "const",
+  "contentMediaType",
+  "contentEncoding",
+  "examples",
+  "$comment"
+];
+function sanitizeToolSchema(schema) {
+  if (schema === null || schema === void 0) {
+    return schema;
+  }
+  if (Array.isArray(schema)) {
+    return schema.map(sanitizeToolSchema);
+  }
+  if (typeof schema !== "object") {
+    return schema;
+  }
+  const sanitized = {};
+  const schemaObj = schema;
+  for (const [key, value] of Object.entries(schemaObj)) {
+    if (UNSUPPORTED_SCHEMA_KEYWORDS.includes(key)) {
+      continue;
+    }
+    if (key === "properties" && typeof value === "object" && value !== null) {
+      const props = {};
+      for (const [propKey, propValue] of Object.entries(value)) {
+        props[propKey] = sanitizeToolSchema(propValue);
+      }
+      sanitized[key] = props;
+    } else if (key === "items" && typeof value === "object") {
+      sanitized[key] = sanitizeToolSchema(value);
+    } else if (key === "additionalProperties" && typeof value === "object") {
+      sanitized[key] = sanitizeToolSchema(value);
+    } else {
+      sanitized[key] = value;
+    }
+  }
+  return sanitized;
+}
 function tryConvertToKimiBuiltinTool(tool) {
   if (!tool.id.startsWith("kimi.")) {
     return void 0;
@@ -832,11 +899,24 @@ var KimiChatLanguageModel = class {
     if (toolChoiceSystemMessage) {
       messages.unshift({ role: "system", content: toolChoiceSystemMessage });
     }
+    const caps = this.capabilities;
+    let resolvedTemperature = temperature;
+    if (caps.temperatureLocked && caps.defaultTemperature !== void 0) {
+      if (temperature !== void 0 && temperature !== caps.defaultTemperature) {
+        warnings.push({
+          type: "compatibility",
+          feature: "temperature",
+          details: `Thinking models require temperature=${caps.defaultTemperature}. Your value (${temperature}) will be overridden.`
+        });
+      }
+      resolvedTemperature = caps.defaultTemperature;
+    }
+    const resolvedMaxTokens = maxOutputTokens ?? caps.defaultMaxOutputTokens;
     const body = removeUndefinedEntries({
       model: this.modelId,
       messages,
-      max_tokens: maxOutputTokens,
-      temperature,
+      max_tokens: resolvedMaxTokens,
+      temperature: resolvedTemperature,
       top_p: topP,
       frequency_penalty: frequencyPenalty,
       presence_penalty: presencePenalty,
@@ -1251,6 +1331,21 @@ var kimiTokenUsageSchema = z3.object({
     reasoning_tokens: z3.number().nullish()
   }).nullish()
 }).nullish();
+var kimiContentPartSchema = z3.union([
+  z3.object({
+    type: z3.literal("text"),
+    text: z3.string()
+  }),
+  z3.object({
+    type: z3.literal("image_url"),
+    image_url: z3.object({
+      url: z3.string()
+    })
+  }),
+  z3.looseObject({
+    type: z3.string()
+  })
+]);
 var kimiChatResponseSchema = z3.looseObject({
   id: z3.string().nullish(),
   created: z3.number().nullish(),
@@ -1259,7 +1354,7 @@ var kimiChatResponseSchema = z3.looseObject({
     z3.object({
       message: z3.object({
         role: z3.string().nullish(),
-        content: z3.union([z3.string(), z3.array(z3.any())]).nullish(),
+        content: z3.union([z3.string(), z3.array(kimiContentPartSchema)]).nullish(),
         reasoning_content: z3.string().nullish(),
         reasoning: z3.string().nullish(),
         tool_calls: z3.array(
@@ -1306,6 +1401,115 @@ var kimiChatChunkBaseSchema = z3.looseObject({
 });
 var kimiChatChunkSchema = z3.union([kimiChatChunkBaseSchema, kimiErrorSchema]);
 
+// src/files/file-cache.ts
+var FileCache = class {
+  constructor(options = {}) {
+    this.maxSize = options.maxSize ?? 100;
+    this.ttlMs = options.ttlMs ?? 36e5;
+    this.cache = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Get a cached entry by content hash.
+   * Returns undefined if not found or expired.
+   * Moves the entry to the end (most recently used).
+   */
+  get(contentHash) {
+    const entry = this.cache.get(contentHash);
+    if (!entry) {
+      return void 0;
+    }
+    if (this.isExpired(entry)) {
+      this.cache.delete(contentHash);
+      return void 0;
+    }
+    this.cache.delete(contentHash);
+    this.cache.set(contentHash, entry);
+    return entry;
+  }
+  /**
+   * Set a cache entry.
+   * Evicts the least recently used entry if cache is full.
+   */
+  set(contentHash, entry) {
+    this.cache.delete(contentHash);
+    while (this.cache.size >= this.maxSize) {
+      const oldestKey = this.cache.keys().next().value;
+      if (oldestKey !== void 0) {
+        this.cache.delete(oldestKey);
+      } else {
+        break;
+      }
+    }
+    this.cache.set(contentHash, entry);
+  }
+  /**
+   * Check if an entry exists and is not expired.
+   */
+  has(contentHash) {
+    return this.get(contentHash) !== void 0;
+  }
+  /**
+   * Delete a specific entry.
+   */
+  delete(contentHash) {
+    return this.cache.delete(contentHash);
+  }
+  /**
+   * Clear all entries.
+   */
+  clear() {
+    this.cache.clear();
+  }
+  /**
+   * Get the current cache size.
+   */
+  get size() {
+    return this.cache.size;
+  }
+  /**
+   * Remove all expired entries.
+   */
+  prune() {
+    let pruned = 0;
+    for (const [key, entry] of this.cache) {
+      if (this.isExpired(entry)) {
+        this.cache.delete(key);
+        pruned++;
+      }
+    }
+    return pruned;
+  }
+  /**
+   * Check if an entry is expired.
+   */
+  isExpired(entry) {
+    return Date.now() - entry.createdAt > this.ttlMs;
+  }
+};
+function generateContentHash(data) {
+  const bytes = typeof data === "string" ? new TextEncoder().encode(data) : data;
+  let hash = 2166136261;
+  for (let i = 0; i < bytes.length; i++) {
+    hash ^= bytes[i];
+    hash = Math.imul(hash, 16777619);
+  }
+  hash ^= bytes.length;
+  return (hash >>> 0).toString(16).padStart(8, "0");
+}
+function generateCacheKey(data, filename) {
+  const bytes = typeof data === "string" ? new TextEncoder().encode(data) : data;
+  const contentHash = generateContentHash(data);
+  const normalizedFilename = filename.toLowerCase().replace(/[^a-z0-9.]/g, "_");
+  return `${contentHash}_${bytes.length}_${normalizedFilename}`;
+}
+var defaultCache = null;
+function getDefaultFileCache() {
+  if (!defaultCache) {
+    defaultCache = new FileCache();
+  }
+  return defaultCache;
+}
+
 // src/files/file-utils.ts
 var SUPPORTED_FILE_EXTENSIONS = [
   // Documents
@@ -1661,8 +1865,10 @@ async function processAttachments(options) {
     clientConfig,
     autoUploadDocuments = true,
     uploadImages = false,
-    cleanupAfterExtract = false
+    cleanupAfterExtract = false,
+    cache = false
   } = options;
+  const cacheInstance = cache === true ? getDefaultFileCache() : cache === false ? null : cache;
   const results = [];
   const client = new KimiFileClient(clientConfig);
   for (const attachment of attachments) {
@@ -1670,7 +1876,8 @@ async function processAttachments(options) {
       const processed = await processAttachment(attachment, client, {
         autoUploadDocuments,
         uploadImages,
-        cleanupAfterExtract
+        cleanupAfterExtract,
+        cache: cacheInstance
       });
       results.push(processed);
     } catch (error) {
@@ -1730,12 +1937,35 @@ async function processAttachment(attachment, client, options) {
         error: "No content or URL provided for document attachment"
       };
     }
+    const filename = attachment.name ?? guessFilename(attachment, contentType);
+    if (options.cache) {
+      const cacheKey = generateCacheKey(data, filename);
+      const cached = options.cache.get(cacheKey);
+      if (cached) {
+        return {
+          original: attachment,
+          type: "text-inject",
+          textContent: cached.content,
+          fileId: cached.fileId
+        };
+      }
+    }
     const result = await client.uploadAndExtract({
       data,
-      filename: attachment.name ?? guessFilename(attachment, contentType),
+      filename,
       mediaType: contentType,
       purpose: "file-extract"
     });
+    if (options.cache && result.content) {
+      const cacheKey = generateCacheKey(data, filename);
+      const cacheEntry = {
+        fileId: result.file.id,
+        content: result.content,
+        createdAt: Date.now(),
+        purpose: "file-extract"
+      };
+      options.cache.set(cacheKey, cacheEntry);
+    }
     if (options.cleanupAfterExtract && result.file.id) {
       try {
         await client.deleteFile(result.file.id);
@@ -1776,7 +2006,7 @@ function guessFilename(attachment, contentType) {
     const urlPath = attachment.url.split("?")[0];
     const segments = urlPath.split("/");
     const lastSegment = segments[segments.length - 1];
-    if (lastSegment && lastSegment.includes(".")) {
+    if (lastSegment.includes(".")) {
       return lastSegment;
     }
   }
@@ -1792,7 +2022,7 @@ function guessFilename(attachment, contentType) {
 }
 
 // src/version.ts
-var VERSION = "0.2.0".length > 0 ? "0.2.0" : "0.0.0";
+var VERSION = "0.4.0".length > 0 ? "0.4.0" : "0.0.0";
 
 // src/kimi-provider.ts
 var GLOBAL_BASE_URL = "https://api.moonshot.ai/v1";