@providerprotocol/ai 0.0.37 → 0.0.38

package/dist/{chunk-IK6NRCW5.js → chunk-BDXH6NQS.js}

@@ -1,3 +1,6 @@
+import {
+  express
+} from "./chunk-FYSZFIZS.js";
 import {
   h3
 } from "./chunk-ZRVNAET3.js";
@@ -7,9 +10,6 @@ import {
 import {
   webapi
 } from "./chunk-LTEMH3CI.js";
-import {
-  express
-} from "./chunk-FYSZFIZS.js";
 
 // src/providers/proxy/server/index.ts
 var server = {
@@ -26,4 +26,4 @@ var server = {
 export {
   server
 };
-//# sourceMappingURL=chunk-IK6NRCW5.js.map
+//# sourceMappingURL=chunk-BDXH6NQS.js.map

package/dist/moonshot/index.d.ts

@@ -0,0 +1,510 @@
+import { e as Provider } from '../llm-DS_-l71X.js';
+import '../stream-sXhBtWjl.js';
+
+/**
+ * @fileoverview Moonshot AI Provider Type Definitions
+ *
+ * This module contains all TypeScript type definitions for the Moonshot provider,
+ * including types for the Chat Completions API (OpenAI-compatible).
+ *
+ * @module providers/moonshot/types
+ */
+/**
+ * Thinking mode configuration for Moonshot models.
+ *
+ * By default, kimi-k2.5 has thinking mode enabled and returns reasoning traces.
+ * Use `{ type: 'disabled' }` to switch to instant mode for faster responses.
+ */
+interface MoonshotThinkingConfig {
+    /** Thinking mode type: 'enabled' (default) or 'disabled' for instant mode */
+    type: 'enabled' | 'disabled';
+}
+/**
+ * Parameters for the Moonshot Chat Completions API.
+ *
+ * These parameters are passed directly to the `/v1/chat/completions` endpoint.
+ * Moonshot's API is OpenAI-compatible with additional thinking mode support.
+ *
+ * @example
+ * ```typescript
+ * const params: MoonshotLLMParams = {
+ *   temperature: 1.0,
+ *   max_tokens: 1000,
+ *   thinking: { type: 'enabled' }  // Default for kimi-k2.5
+ * };
+ * ```
+ */
+interface MoonshotLLMParams {
+    /** Maximum number of tokens to generate */
+    max_tokens?: number;
+    /** Maximum completion tokens (alias for max_tokens) */
+    max_completion_tokens?: number;
+    /** Temperature for randomness (0.0 to 2.0). Default: 1.0 (thinking) or 0.6 (instant) */
+    temperature?: number;
+    /** Top-p (nucleus) sampling (0.0 - 1.0), default 0.95 */
+    top_p?: number;
+    /** Custom stop sequences */
+    stop?: string | string[];
+    /** Frequency penalty (-2.0 - 2.0) */
+    frequency_penalty?: number;
+    /** Presence penalty (-2.0 - 2.0) */
+    presence_penalty?: number;
+    /** Seed for deterministic sampling */
+    seed?: number;
+    /** User identifier for rate limit tracking */
+    user?: string;
+    /** Response format for structured output */
+    response_format?: MoonshotResponseFormat;
+    /** Thinking mode configuration (kimi-k2.5 specific) */
+    thinking?: MoonshotThinkingConfig;
+    /**
+     * Builtin tools to enable for this request.
+     * Use the `tools` helper object to create these.
+     *
+     * @example
+     * ```typescript
+     * import { moonshot, tools } from '@providerprotocol/ai/moonshot';
+     *
+     * const model = llm({
+     *   model: moonshot('kimi-k2.5'),
+     *   params: {
+     *     tools: [tools.webSearch(), tools.codeRunner()],
+     *   },
+     * });
+     * ```
+     */
+    tools?: MoonshotTool[];
+}
+/**
+ * Response format options for structured output.
+ */
+type MoonshotResponseFormat = {
+    type: 'text';
+} | {
+    type: 'json_object';
+} | {
+    type: 'json_schema';
+    json_schema: {
+        name: string;
+        description?: string;
+        schema: Record<string, unknown>;
+        strict?: boolean;
+    };
+};
+/**
+ * Request body for the Moonshot Chat Completions API.
+ */
+interface MoonshotRequest {
+    model: string;
+    messages: MoonshotMessage[];
+    temperature?: number;
+    top_p?: number;
+    stream?: boolean;
+    stream_options?: {
+        include_usage?: boolean;
+    };
+    stop?: string | string[];
+    max_tokens?: number;
+    max_completion_tokens?: number;
+    presence_penalty?: number;
+    frequency_penalty?: number;
+    user?: string;
+    seed?: number;
+    tools?: MoonshotTool[];
+    tool_choice?: MoonshotToolChoice;
+    response_format?: MoonshotResponseFormat;
+    thinking?: MoonshotThinkingConfig;
+}
+/**
+ * Union type for all message types in the Moonshot API.
+ */
+type MoonshotMessage = MoonshotSystemMessage | MoonshotUserMessage | MoonshotAssistantMessage | MoonshotToolMessage;
+/** System message for setting context and instructions */
+interface MoonshotSystemMessage {
+    role: 'system';
+    content: string;
+}
+/** User message with text or multimodal content */
+interface MoonshotUserMessage {
+    role: 'user';
+    content: string | MoonshotUserContent[];
+}
+/** Assistant message containing the model's response */
+interface MoonshotAssistantMessage {
+    role: 'assistant';
+    content?: string | null;
+    /** Reasoning traces from thinking mode */
+    reasoning_content?: string | null;
+    tool_calls?: MoonshotToolCall[];
+}
+/** Tool result message providing output from a function call */
+interface MoonshotToolMessage {
+    role: 'tool';
+    content: string;
+    tool_call_id: string;
+}
+/**
+ * Union type for user content parts (text, image, or video).
+ */
+type MoonshotUserContent = MoonshotTextContent | MoonshotImageContent | MoonshotVideoContent;
+/** Text content part */
+interface MoonshotTextContent {
+    type: 'text';
+    text: string;
+}
+/** Image content part with URL reference (for vision models) */
+interface MoonshotImageContent {
+    type: 'image_url';
+    image_url: {
+        url: string;
+    };
+}
+/** Video content part with URL reference (experimental) */
+interface MoonshotVideoContent {
+    type: 'video_url';
+    video_url: {
+        url: string;
+    };
+}
+/**
+ * Tool call structure in assistant messages.
+ */
+interface MoonshotToolCall {
+    id: string;
+    type: 'function';
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+/**
+ * Tool definition for the Moonshot API.
+ * Used for both custom function tools and server-side builtin tools.
+ */
+interface MoonshotTool {
+    type: 'function';
+    function: {
+        name: string;
+        description: string;
+        parameters: {
+            type?: 'object';
+            description?: string;
+            properties: Record<string, unknown>;
+            required?: string[];
+            additionalProperties?: boolean;
+        };
+        strict?: boolean;
+    };
+}
+/**
+ * Tool choice options for controlling function calling behavior.
+ * Moonshot models support full tool_choice including 'required'.
+ */
+type MoonshotToolChoice = 'none' | 'auto' | 'required' | {
+    type: 'function';
+    function: {
+        name: string;
+    };
+};
+/**
+ * Creates a web search tool (server-side execution).
+ * Enables real-time internet search capabilities.
+ *
+ * Note: Web search is charged separately from regular API usage.
+ *
+ * @example
+ * ```typescript
+ * import { moonshot, tools } from '@providerprotocol/ai/moonshot';
+ *
+ * const model = llm({
+ *   model: moonshot('kimi-k2.5'),
+ *   params: {
+ *     tools: [tools.webSearch()],
+ *   },
+ * });
+ * ```
+ */
+declare function webSearch(): MoonshotTool;
+/**
+ * Creates a Python code runner tool (server-side execution).
+ * Allows execution of Python code for calculations and data processing.
+ * Supports print output, matplotlib plots, pandas, and file reading via ctx.read_object().
+ */
+declare function codeRunner(): MoonshotTool;
+/**
+ * Creates a QuickJS JavaScript execution tool (server-side execution).
+ * Enables secure JavaScript code execution via the QuickJS engine.
+ */
+declare function quickjs(): MoonshotTool;
+/**
+ * Creates a URL fetch tool (server-side execution).
+ * Extracts content from URLs and formats it as Markdown.
+ */
+declare function fetch(): MoonshotTool;
+/**
+ * Creates a unit conversion tool (server-side execution).
+ * Supports length, mass, volume, temperature, area, time, energy,
+ * pressure, speed, and currency conversions.
+ */
+declare function convert(): MoonshotTool;
+/**
+ * Creates a date/time processing tool (server-side execution).
+ * Handles date and time calculations, timezone conversion, and formatting.
+ */
+declare function date(): MoonshotTool;
+/**
+ * Creates a Base64 encoding tool (server-side execution).
+ */
+declare function base64Encode(): MoonshotTool;
+/**
+ * Creates a Base64 decoding tool (server-side execution).
+ */
+declare function base64Decode(): MoonshotTool;
+/**
+ * Creates a memory storage tool (server-side execution).
+ * Supports persistent storage of conversation history and user preferences.
+ */
+declare function memory(): MoonshotTool;
+/**
+ * Creates an intelligent reasoning tool (server-side execution).
+ * Allows the model to organize thoughts and plan before responding.
+ */
+declare function rethink(): MoonshotTool;
+/**
+ * Creates a random choice tool (server-side execution).
+ * Enables random selection from options with optional weights.
+ */
+declare function randomChoice(): MoonshotTool;
+/**
+ * Creates a cat meowing/blessing tool (server-side execution).
+ * Returns random cat meowing sounds and blessings based on mood.
+ */
+declare function mew(): MoonshotTool;
+/**
+ * Moonshot builtin tools factory object.
+ * Provides convenient access to all builtin tool creators.
+ *
+ * Note: The `excel` plugin tool uses a different format and is not included here.
+ * It requires file IDs from the Moonshot file upload API.
+ *
+ * @example
+ * ```typescript
+ * import { moonshot, tools } from '@providerprotocol/ai/moonshot';
+ *
+ * const model = llm({
+ *   model: moonshot('kimi-k2.5'),
+ *   params: {
+ *     tools: [
+ *       tools.webSearch(),
+ *       tools.codeRunner(),
+ *       tools.fetch(),
+ *     ],
+ *   },
+ * });
+ * ```
+ */
+declare const tools: {
+    /** Web search for real-time internet information */
+    webSearch: typeof webSearch;
+    /** Python code execution with matplotlib, pandas support */
+    codeRunner: typeof codeRunner;
+    /** JavaScript execution via QuickJS engine */
+    quickjs: typeof quickjs;
+    /** URL content fetching with markdown extraction */
+    fetch: typeof fetch;
+    /** Unit conversion (length, mass, temperature, currency, etc.) */
+    convert: typeof convert;
+    /** Date/time processing and timezone conversion */
+    date: typeof date;
+    /** Base64 encoding */
+    base64Encode: typeof base64Encode;
+    /** Base64 decoding */
+    base64Decode: typeof base64Decode;
+    /** Alias for base64Encode */
+    base64: typeof base64Encode;
+    /** Memory storage and retrieval system */
+    memory: typeof memory;
+    /** Intelligent reasoning/reflection tool */
+    rethink: typeof rethink;
+    /** Random selection with optional weights */
+    randomChoice: typeof randomChoice;
+    /** Cat meowing and blessings generator */
+    mew: typeof mew;
+};
+/**
+ * Response structure from the Moonshot Chat Completions API.
+ */
+interface MoonshotResponse {
+    id: string;
+    object: 'chat.completion';
+    created: number;
+    model: string;
+    choices: MoonshotChoice[];
+    usage: MoonshotUsage;
+    system_fingerprint?: string;
+}
+/** A single choice from a completion response */
+interface MoonshotChoice {
+    index: number;
+    message: MoonshotAssistantMessage;
+    finish_reason: 'stop' | 'length' | 'tool_calls' | 'content_filter' | null;
+}
+/** Token usage statistics from the API response */
+interface MoonshotUsage {
+    prompt_tokens: number;
+    completion_tokens: number;
+    total_tokens: number;
+    prompt_tokens_details?: {
+        cached_tokens?: number;
+    };
+}
+/**
+ * Streaming chunk structure from the Moonshot API.
+ */
+interface MoonshotStreamChunk {
+    id: string;
+    object: 'chat.completion.chunk';
+    created: number;
+    model: string;
+    choices: MoonshotStreamChoice[];
+    usage?: MoonshotUsage | null;
+    system_fingerprint?: string;
+}
+/** A streaming choice containing incremental content */
+interface MoonshotStreamChoice {
+    index: number;
+    delta: MoonshotStreamDelta;
+    finish_reason: 'stop' | 'length' | 'tool_calls' | 'content_filter' | null;
+}
+/** Incremental content delta in a streaming chunk */
+interface MoonshotStreamDelta {
+    role?: 'assistant';
+    content?: string | null;
+    reasoning_content?: string | null;
+    tool_calls?: MoonshotStreamToolCall[];
+}
+/** Incremental tool call data in a streaming chunk */
+interface MoonshotStreamToolCall {
+    index: number;
+    id?: string;
+    type?: 'function';
+    function?: {
+        name?: string;
+        arguments?: string;
+    };
+}
+/**
+ * Moonshot-specific HTTP headers for API requests.
+ *
+ * @example
+ * ```typescript
+ * const headers: MoonshotHeaders = {
+ *   'X-Request-Id': 'my-request-id',
+ * };
+ * ```
+ */
+interface MoonshotHeaders {
+    /** Client-generated request ID for tracing */
+    'X-Request-Id'?: string;
+    [key: string]: string | undefined;
+}
+
+/**
+ * @fileoverview Moonshot Provider Factory
+ *
+ * This module provides the main Moonshot provider implementation for the
+ * OpenAI-compatible Chat Completions API.
+ *
+ * @module providers/moonshot
+ */
+/**
+ * Configuration options for the Moonshot provider.
+ *
+ * Currently Moonshot only supports one API endpoint (Chat Completions),
+ * so no additional options are needed.
+ */
+interface MoonshotProviderOptions {
+}
+/**
+ * The Moonshot provider instance.
+ *
+ * Use this provider to create model references for Moonshot models like
+ * Kimi K2.5 and other models available on the Moonshot AI platform.
+ *
+ * @example Basic usage
+ * ```typescript
+ * import { moonshot } from './providers/moonshot';
+ * import { llm } from './core/llm';
+ *
+ * const model = llm({
+ *   model: moonshot('kimi-k2.5'),
+ *   params: { max_tokens: 1000 }
+ * });
+ *
+ * const turn = await model.generate('Hello!');
+ * console.log(turn.response.text);
+ * ```
+ *
+ * @example With streaming
+ * ```typescript
+ * const stream = model.stream('Tell me a story');
+ *
+ * for await (const event of stream) {
+ *   if (event.type === StreamEventType.TextDelta) {
+ *     process.stdout.write(event.delta.text ?? '');
+ *   }
+ * }
+ *
+ * const turn = await stream.turn;
+ * console.log('Tokens used:', turn.usage.totalTokens);
+ * ```
+ *
+ * @example With thinking mode (default for K2.5)
+ * ```typescript
+ * const model = llm({
+ *   model: moonshot('kimi-k2.5'),
+ *   params: {
+ *     max_tokens: 2000,
+ *     temperature: 1.0,  // Recommended for thinking mode
+ *     thinking: { type: 'enabled' }  // Default
+ *   }
+ * });
+ *
+ * // Response includes reasoning_content in metadata
+ * const turn = await model.generate('Solve this step by step: 2x + 5 = 13');
+ * ```
+ *
+ * @example With instant mode (disabled thinking)
+ * ```typescript
+ * const model = llm({
+ *   model: moonshot('kimi-k2.5'),
+ *   params: {
+ *     max_tokens: 1000,
+ *     temperature: 0.6,  // Recommended for instant mode
+ *     thinking: { type: 'disabled' }
+ *   }
+ * });
+ * ```
+ *
+ * @example With vision (image input)
+ * ```typescript
+ * import { Image } from './core/media/Image';
+ *
+ * const image = await Image.fromPath('./photo.png');
+ * const turn = await model.generate([
+ *   image.toBlock(),
+ *   { type: 'text', text: 'Describe this image' }
+ * ]);
+ * ```
+ *
+ * @example Available models
+ * Production models:
+ * - `kimi-k2.5` - Latest K2.5 with 256K context, vision, thinking mode
+ *
+ * Environment variables:
+ * - `MOONSHOT_API_KEY` - Primary API key
+ * - `KIMI_API_KEY` - Fallback API key
+ */
+declare const moonshot: Provider<MoonshotProviderOptions>;
+
+export { type MoonshotHeaders, type MoonshotLLMParams, type MoonshotMessage, type MoonshotProviderOptions, type MoonshotRequest, type MoonshotResponse, type MoonshotResponseFormat, type MoonshotStreamChunk, type MoonshotThinkingConfig, type MoonshotTool, type MoonshotToolCall, type MoonshotToolChoice, type MoonshotUsage, moonshot, tools };