@providerprotocol/ai 0.0.37 → 0.0.39

package/dist/moonshot/index.js

@@ -0,0 +1,1090 @@
+import {
+  parseSSEStream
+} from "../chunk-PMK5LZ5Z.js";
+import {
+  parseJsonResponse
+} from "../chunk-TUTYMOBL.js";
+import {
+  resolveApiKey
+} from "../chunk-ARVM24K2.js";
+import {
+  createProvider
+} from "../chunk-JA3UZALR.js";
+import {
+  doFetch,
+  doStreamFetch,
+  normalizeHttpError
+} from "../chunk-SBGZJVTJ.js";
+import {
+  StreamEventType,
+  objectDelta
+} from "../chunk-MJI74VEJ.js";
+import {
+  AssistantMessage,
+  generateId,
+  isAssistantMessage,
+  isToolResultMessage,
+  isUserMessage
+} from "../chunk-WU4U6IHF.js";
+import {
+  toError
+} from "../chunk-GIDT7C6I.js";
+import {
+  ErrorCode,
+  ModalityType,
+  UPPError
+} from "../chunk-COS4ON4G.js";
+
+// src/providers/moonshot/transform.ts
+function normalizeSystem(system) {
+  if (system === void 0 || system === null) return void 0;
+  if (typeof system === "string") return system;
+  if (!Array.isArray(system)) {
+    throw new UPPError(
+      "System prompt must be a string or an array of text blocks",
+      ErrorCode.InvalidRequest,
+      "moonshot",
+      ModalityType.LLM
+    );
+  }
+  const texts = [];
+  for (const block of system) {
+    if (!block || typeof block !== "object" || !("text" in block)) {
+      throw new UPPError(
+        "System prompt array must contain objects with a text field",
+        ErrorCode.InvalidRequest,
+        "moonshot",
+        ModalityType.LLM
+      );
+    }
+    const textValue = block.text;
+    if (typeof textValue !== "string") {
+      throw new UPPError(
+        "System prompt text must be a string",
+        ErrorCode.InvalidRequest,
+        "moonshot",
+        ModalityType.LLM
+      );
+    }
+    if (textValue.length > 0) {
+      texts.push(textValue);
+    }
+  }
+  return texts.length > 0 ? texts.join("\n\n") : void 0;
+}
+function filterValidContent(content) {
+  return content.filter((c) => c && typeof c.type === "string");
+}
+function transformContentBlock(block) {
+  switch (block.type) {
+    case "text":
+      return { type: "text", text: block.text };
+    case "image": {
+      const imageBlock = block;
+      let url;
+      if (imageBlock.source.type === "base64") {
+        url = `data:${imageBlock.mimeType};base64,${imageBlock.source.data}`;
+      } else if (imageBlock.source.type === "url") {
+        url = imageBlock.source.url;
+      } else if (imageBlock.source.type === "bytes") {
+        const base64 = Buffer.from(imageBlock.source.data).toString("base64");
+        url = `data:${imageBlock.mimeType};base64,${base64}`;
+      } else {
+        throw new UPPError(
+          "Unknown image source type",
+          ErrorCode.InvalidRequest,
+          "moonshot",
+          ModalityType.LLM
+        );
+      }
+      return {
+        type: "image_url",
+        image_url: { url }
+      };
+    }
+    case "video": {
+      const videoBlock = block;
+      const base64 = Buffer.from(videoBlock.data).toString("base64");
+      const url = `data:${videoBlock.mimeType};base64,${base64}`;
+      return {
+        type: "video_url",
+        video_url: { url }
+      };
+    }
+    case "document":
+      throw new UPPError(
+        "Moonshot does not support inline document blocks. Use the /v1/files API to upload documents first.",
+        ErrorCode.InvalidRequest,
+        "moonshot",
+        ModalityType.LLM
+      );
+    case "audio":
+      throw new UPPError(
+        "Moonshot does not support audio input",
+        ErrorCode.InvalidRequest,
+        "moonshot",
+        ModalityType.LLM
+      );
+    default:
+      throw new UPPError(
+        `Unsupported content type: ${block.type}`,
+        ErrorCode.InvalidRequest,
+        "moonshot",
+        ModalityType.LLM
+      );
+  }
+}
+function transformMessage(message) {
+  if (isUserMessage(message)) {
+    const validContent = filterValidContent(message.content);
+    if (validContent.length === 1 && validContent[0]?.type === "text") {
+      return {
+        role: "user",
+        content: validContent[0].text
+      };
+    }
+    return {
+      role: "user",
+      content: validContent.map(transformContentBlock)
+    };
+  }
+  if (isAssistantMessage(message)) {
+    const validContent = filterValidContent(message.content);
+    const textContent = validContent.filter((c) => c.type === "text").map((c) => c.text).join("");
+    const moonshotMeta = message.metadata?.moonshot;
+    let reasoningContent = moonshotMeta?.reasoning_content;
+    if (!reasoningContent) {
+      const reasoningBlocks = validContent.filter(
+        (c) => c.type === "reasoning"
+      );
+      if (reasoningBlocks.length > 0) {
+        reasoningContent = reasoningBlocks.map((b) => b.text).join("\n");
+      }
+    }
+    const assistantMessage = {
+      role: "assistant",
+      content: textContent || null
+    };
+    if (reasoningContent) {
+      assistantMessage.reasoning_content = reasoningContent;
+    }
+    if (message.toolCalls && message.toolCalls.length > 0) {
+      assistantMessage.tool_calls = message.toolCalls.map((call) => ({
+        id: call.toolCallId,
+        type: "function",
+        function: {
+          name: call.toolName,
+          arguments: JSON.stringify(call.arguments)
+        }
+      }));
+    }
+    return assistantMessage;
+  }
+  if (isToolResultMessage(message)) {
+    const results = message.results.map((result) => ({
+      role: "tool",
+      tool_call_id: result.toolCallId,
+      content: typeof result.result === "string" ? result.result : JSON.stringify(result.result)
+    }));
+    return results[0] ?? null;
+  }
+  return null;
+}
+function transformToolResults(message) {
+  if (!isToolResultMessage(message)) {
+    const single = transformMessage(message);
+    return single ? [single] : [];
+  }
+  return message.results.map((result) => ({
+    role: "tool",
+    tool_call_id: result.toolCallId,
+    content: typeof result.result === "string" ? result.result : JSON.stringify(result.result)
+  }));
+}
+function transformMessages(messages, system) {
+  const result = [];
+  const normalizedSystem = normalizeSystem(system);
+  if (normalizedSystem) {
+    result.push({
+      role: "system",
+      content: normalizedSystem
+    });
+  }
+  for (const message of messages) {
+    if (isToolResultMessage(message)) {
+      const toolMessages = transformToolResults(message);
+      result.push(...toolMessages);
+    } else {
+      const transformed = transformMessage(message);
+      if (transformed) {
+        result.push(transformed);
+      }
+    }
+  }
+  return result;
+}
+function extractToolOptions(tool) {
+  const moonshotMeta = tool.metadata?.moonshot;
+  return { strict: moonshotMeta?.strict };
+}
+function transformTool(tool) {
+  const { strict } = extractToolOptions(tool);
+  return {
+    type: "function",
+    function: {
+      name: tool.name,
+      description: tool.description,
+      parameters: {
+        type: "object",
+        properties: tool.parameters.properties,
+        required: tool.parameters.required,
+        ...tool.parameters.additionalProperties !== void 0 ? { additionalProperties: tool.parameters.additionalProperties } : {}
+      },
+      ...strict !== void 0 ? { strict } : {}
+    }
+  };
+}
+function transformRequest(request, modelId) {
+  const params = request.params ?? {};
+  const { tools: paramsTools, ...restParams } = params;
+  const moonshotRequest = {
+    ...restParams,
+    model: modelId,
+    messages: transformMessages(request.messages, request.system)
+  };
+  const allTools = [];
+  if (paramsTools && paramsTools.length > 0) {
+    allTools.push(...paramsTools);
+  }
+  if (request.tools && request.tools.length > 0) {
+    allTools.push(...request.tools.map(transformTool));
+  }
+  if (allTools.length > 0) {
+    moonshotRequest.tools = allTools;
+  }
+  if (request.structure) {
+    const schema = {
+      type: "object",
+      properties: request.structure.properties,
+      required: request.structure.required,
+      ...request.structure.additionalProperties !== void 0 ? { additionalProperties: request.structure.additionalProperties } : { additionalProperties: false }
+    };
+    if (request.structure.description) {
+      schema.description = request.structure.description;
+    }
+    moonshotRequest.response_format = {
+      type: "json_schema",
+      json_schema: {
+        name: "json_response",
+        description: request.structure.description,
+        schema,
+        strict: true
+      }
+    };
+  }
+  return moonshotRequest;
+}
+function transformResponse(data) {
+  const choice = data.choices[0];
+  if (!choice) {
+    throw new UPPError(
+      "No choices in Moonshot response",
+      ErrorCode.InvalidResponse,
+      "moonshot",
+      ModalityType.LLM
+    );
+  }
+  const contentBlocks = [];
+  let structuredData;
+  if (choice.message.reasoning_content) {
+    contentBlocks.push({ type: "reasoning", text: choice.message.reasoning_content });
+  }
+  if (choice.message.content) {
+    contentBlocks.push({ type: "text", text: choice.message.content });
+    try {
+      structuredData = JSON.parse(choice.message.content);
+    } catch {
+    }
+  }
+  const toolCalls = [];
+  if (choice.message.tool_calls) {
+    for (const call of choice.message.tool_calls) {
+      let args = {};
+      try {
+        args = JSON.parse(call.function.arguments);
+      } catch {
+      }
+      toolCalls.push({
+        toolCallId: call.id,
+        toolName: call.function.name,
+        arguments: args
+      });
+    }
+  }
+  const message = new AssistantMessage(
+    contentBlocks,
+    toolCalls.length > 0 ? toolCalls : void 0,
+    {
+      id: data.id || generateId(),
+      metadata: {
+        moonshot: {
+          model: data.model,
+          finish_reason: choice.finish_reason,
+          system_fingerprint: data.system_fingerprint,
+          reasoning_content: choice.message.reasoning_content ?? void 0
+        }
+      }
+    }
+  );
+  const usage = {
+    inputTokens: data.usage.prompt_tokens,
+    outputTokens: data.usage.completion_tokens,
+    totalTokens: data.usage.total_tokens,
+    cacheReadTokens: data.usage.prompt_tokens_details?.cached_tokens ?? 0,
+    cacheWriteTokens: 0
+  };
+  let stopReason = "end_turn";
+  switch (choice.finish_reason) {
+    case "stop":
+      stopReason = "end_turn";
+      break;
+    case "length":
+      stopReason = "max_tokens";
+      break;
+    case "tool_calls":
+      stopReason = "tool_use";
+      break;
+    case "content_filter":
+      stopReason = "content_filter";
+      break;
+  }
+  return {
+    message,
+    usage,
+    stopReason,
+    data: structuredData
+  };
+}
+function createStreamState() {
+  return {
+    id: "",
+    model: "",
+    text: "",
+    reasoningText: "",
+    toolCalls: /* @__PURE__ */ new Map(),
+    finishReason: null,
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheReadTokens: 0
+  };
+}
+function transformStreamEvent(chunk, state) {
+  const events = [];
+  if (chunk.id && !state.id) {
+    state.id = chunk.id;
+    events.push({ type: StreamEventType.MessageStart, index: 0, delta: {} });
+  }
+  if (chunk.model) {
+    state.model = chunk.model;
+  }
+  const choice = chunk.choices[0];
+  if (choice) {
+    if (choice.delta.reasoning_content) {
+      state.reasoningText += choice.delta.reasoning_content;
+      events.push({
+        type: StreamEventType.ReasoningDelta,
+        index: 0,
+        delta: { text: choice.delta.reasoning_content }
+      });
+    }
+    if (choice.delta.content) {
+      state.text += choice.delta.content;
+      events.push({
+        type: StreamEventType.TextDelta,
+        index: 0,
+        delta: { text: choice.delta.content }
+      });
+    }
+    if (choice.delta.tool_calls) {
+      for (const toolCallDelta of choice.delta.tool_calls) {
+        const index = toolCallDelta.index;
+        let toolCall = state.toolCalls.get(index);
+        if (!toolCall) {
+          toolCall = { id: "", name: "", arguments: "" };
+          state.toolCalls.set(index, toolCall);
+        }
+        if (toolCallDelta.id) {
+          toolCall.id = toolCallDelta.id;
+        }
+        if (toolCallDelta.function?.name) {
+          toolCall.name = toolCallDelta.function.name;
+        }
+        if (toolCallDelta.function?.arguments) {
+          toolCall.arguments += toolCallDelta.function.arguments;
+          events.push({
+            type: StreamEventType.ToolCallDelta,
+            index,
+            delta: {
+              toolCallId: toolCall.id,
+              toolName: toolCall.name,
+              argumentsJson: toolCallDelta.function.arguments
+            }
+          });
+        }
+      }
+    }
+    if (choice.finish_reason) {
+      state.finishReason = choice.finish_reason;
+      events.push({ type: StreamEventType.MessageStop, index: 0, delta: {} });
+    }
+  }
+  if (chunk.usage) {
+    state.inputTokens = chunk.usage.prompt_tokens;
+    state.outputTokens = chunk.usage.completion_tokens;
+    state.cacheReadTokens = chunk.usage.prompt_tokens_details?.cached_tokens ?? 0;
+  }
+  return events;
+}
+function buildResponseFromState(state) {
+  const contentBlocks = [];
+  let structuredData;
+  if (state.reasoningText) {
+    contentBlocks.push({ type: "reasoning", text: state.reasoningText });
+  }
+  if (state.text) {
+    contentBlocks.push({ type: "text", text: state.text });
+    try {
+      structuredData = JSON.parse(state.text);
+    } catch {
+    }
+  }
+  const toolCalls = [];
+  for (const [, toolCall] of state.toolCalls) {
+    let args = {};
+    if (toolCall.arguments) {
+      try {
+        args = JSON.parse(toolCall.arguments);
+      } catch {
+      }
+    }
+    toolCalls.push({
+      toolCallId: toolCall.id,
+      toolName: toolCall.name,
+      arguments: args
+    });
+  }
+  const messageId = state.id || generateId();
+  const message = new AssistantMessage(
+    contentBlocks,
+    toolCalls.length > 0 ? toolCalls : void 0,
+    {
+      id: messageId,
+      metadata: {
+        moonshot: {
+          model: state.model,
+          finish_reason: state.finishReason,
+          reasoning_content: state.reasoningText || void 0
+        }
+      }
+    }
+  );
+  const usage = {
+    inputTokens: state.inputTokens,
+    outputTokens: state.outputTokens,
+    totalTokens: state.inputTokens + state.outputTokens,
+    cacheReadTokens: state.cacheReadTokens,
+    cacheWriteTokens: 0
+  };
+  let stopReason = "end_turn";
+  switch (state.finishReason) {
+    case "stop":
+      stopReason = "end_turn";
+      break;
+    case "length":
+      stopReason = "max_tokens";
+      break;
+    case "tool_calls":
+      stopReason = "tool_use";
+      break;
+    case "content_filter":
+      stopReason = "content_filter";
+      break;
+  }
+  return {
+    message,
+    usage,
+    stopReason,
+    data: structuredData
+  };
+}
+
+// src/providers/moonshot/llm.ts
+var MOONSHOT_API_URL = "https://api.moonshot.ai/v1/chat/completions";
+var MOONSHOT_CAPABILITIES = {
+  streaming: true,
+  tools: true,
+  structuredOutput: true,
+  imageInput: true,
+  documentInput: false,
+  videoInput: true,
+  audioInput: false
+};
+async function resolveMoonshotApiKey(config) {
+  try {
+    return await resolveApiKey(config, "MOONSHOT_API_KEY", "moonshot", "llm");
+  } catch {
+    const kimiKey = process.env.KIMI_API_KEY;
+    if (kimiKey) {
+      return kimiKey;
+    }
+    throw new UPPError(
+      "API key not found. Set MOONSHOT_API_KEY or KIMI_API_KEY environment variable, or pass apiKey in config.",
+      ErrorCode.AuthenticationFailed,
+      "moonshot",
+      ModalityType.LLM
+    );
+  }
+}
+function createLLMHandler() {
+  let providerRef = null;
+  return {
+    _setProvider(provider) {
+      providerRef = provider;
+    },
+    bind(modelId) {
+      if (!providerRef) {
+        throw new UPPError(
+          "Provider reference not set. Handler must be used with createProvider() or have _setProvider called.",
+          ErrorCode.InvalidRequest,
+          "moonshot",
+          ModalityType.LLM
+        );
+      }
+      const model = {
+        modelId,
+        capabilities: MOONSHOT_CAPABILITIES,
+        get provider() {
+          return providerRef;
+        },
+        async complete(request) {
+          const apiKey = await resolveMoonshotApiKey(request.config);
+          const baseUrl = request.config.baseUrl ?? MOONSHOT_API_URL;
+          const body = transformRequest(request, modelId);
+          const headers = {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${apiKey}`
+          };
+          if (request.config.headers) {
+            for (const [key, value] of Object.entries(request.config.headers)) {
+              if (value !== void 0) {
+                headers[key] = value;
+              }
+            }
+          }
+          const response = await doFetch(
+            baseUrl,
+            {
+              method: "POST",
+              headers,
+              body: JSON.stringify(body),
+              signal: request.signal
+            },
+            request.config,
+            "moonshot",
+            "llm"
+          );
+          const data = await parseJsonResponse(response, "moonshot", "llm");
+          return transformResponse(data);
+        },
+        stream(request) {
+          const state = createStreamState();
+          let responseResolve;
+          let responseReject;
+          const responsePromise = new Promise((resolve, reject) => {
+            responseResolve = resolve;
+            responseReject = reject;
+          });
+          async function* generateEvents() {
+            try {
+              const apiKey = await resolveMoonshotApiKey(request.config);
+              const baseUrl = request.config.baseUrl ?? MOONSHOT_API_URL;
+              const body = transformRequest(request, modelId);
+              body.stream = true;
+              body.stream_options = { include_usage: true };
+              const headers = {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${apiKey}`,
+                Accept: "text/event-stream"
+              };
+              if (request.config.headers) {
+                for (const [key, value] of Object.entries(request.config.headers)) {
+                  if (value !== void 0) {
+                    headers[key] = value;
+                  }
+                }
+              }
+              const response = await doStreamFetch(
+                baseUrl,
+                {
+                  method: "POST",
+                  headers,
+                  body: JSON.stringify(body),
+                  signal: request.signal
+                },
+                request.config,
+                "moonshot",
+                "llm"
+              );
+              if (!response.ok) {
+                const error = await normalizeHttpError(response, "moonshot", "llm");
+                responseReject(error);
+                throw error;
+              }
+              if (!response.body) {
+                const error = new UPPError(
+                  "No response body for streaming request",
+                  ErrorCode.ProviderError,
+                  "moonshot",
+                  ModalityType.LLM
+                );
+                responseReject(error);
+                throw error;
+              }
+              for await (const data of parseSSEStream(response.body)) {
+                if (data === "[DONE]") {
+                  continue;
+                }
+                if (typeof data === "object" && data !== null) {
+                  const chunk = data;
+                  if ("error" in chunk && chunk.error) {
+                    const errorData = chunk.error;
+                    const error = new UPPError(
+                      errorData.message ?? "Unknown error",
+                      ErrorCode.ProviderError,
+                      "moonshot",
+                      ModalityType.LLM
+                    );
+                    responseReject(error);
+                    throw error;
+                  }
+                  const uppEvents = transformStreamEvent(chunk, state);
+                  for (const event of uppEvents) {
+                    yield event;
+                    if (request.structure && event.type === StreamEventType.TextDelta) {
+                      yield objectDelta(event.delta.text ?? "", event.index);
+                    }
+                  }
+                }
+              }
+              responseResolve(buildResponseFromState(state));
+            } catch (error) {
+              const err = toError(error);
+              responseReject(err);
+              throw err;
+            }
+          }
+          return {
+            [Symbol.asyncIterator]() {
+              return generateEvents();
+            },
+            response: responsePromise
+          };
+        }
+      };
+      return model;
+    }
+  };
+}
+
+// src/providers/moonshot/types.ts
+function webSearch() {
+  return {
+    type: "function",
+    function: {
+      name: "web_search",
+      description: "Search the web for information",
+      parameters: {
+        type: "object",
+        properties: {
+          query: {
+            description: "What to search for",
+            type: "string"
+          },
+          classes: {
+            description: 'Search domains to focus on. Defaults to "all" if not specified.',
+            type: "array",
+            items: {
+              type: "string",
+              enum: ["all", "academic", "social", "library", "finance", "code", "ecommerce", "medical"]
+            }
+          }
+        },
+        required: ["query"]
+      }
+    }
+  };
+}
+function codeRunner() {
+  return {
+    type: "function",
+    function: {
+      name: "code_runner",
+      description: "Safely executes Python code and returns the result, with print output, last-line evaluation, error handling, and timeout protection.",
+      parameters: {
+        type: "object",
+        properties: {
+          code: {
+            description: "The Python code to execute. Supports print(), matplotlib, pandas, and ctx.read_object() for file reading.",
+            type: "string"
+          }
+        },
+        required: ["code"]
+      }
+    }
+  };
+}
+function quickjs() {
+  return {
+    type: "function",
+    function: {
+      name: "quickjs",
+      description: "Safely executes JavaScript code using QuickJS engine",
+      parameters: {
+        type: "object",
+        properties: {
+          code: {
+            description: "The JavaScript code to execute. Supports console.log(), ES6+ features, and ctx.log() for logging.",
+            type: "string"
+          }
+        },
+        required: ["code"]
+      }
+    }
+  };
+}
+function fetch() {
+  return {
+    type: "function",
+    function: {
+      name: "fetch",
+      description: "Fetches a URL from the internet and optionally extracts its contents as markdown.",
+      parameters: {
+        type: "object",
+        properties: {
+          url: {
+            description: "URL to fetch",
+            type: "string",
+            format: "uri"
+          },
+          max_length: {
+            description: "Maximum number of characters to return (default: 5000)",
+            type: "integer",
+            default: 5e3
+          },
+          start_index: {
+            description: "Start at this character index, useful for pagination",
+            type: "integer",
+            default: 0
+          },
+          raw: {
+            description: "Get raw HTML without simplification",
+            type: "boolean",
+            default: false
+          }
+        },
+        required: ["url"]
+      }
+    }
+  };
+}
+function convert() {
+  return {
+    type: "function",
+    function: {
+      name: "convert",
+      description: "Convert between supported units of length, mass, volume, temperature, area, time, energy, pressure, speed, and currency.",
+      parameters: {
+        type: "object",
+        properties: {
+          value: {
+            description: "Value to convert",
+            type: "number"
+          },
+          from_unit: {
+            description: "Source unit (e.g., m, km, ft, kg, lb, \xB0C, \xB0F, USD, EUR)",
+            type: "string"
+          },
+          to_unit: {
+            description: "Target unit",
+            type: "string"
+          }
+        },
+        required: ["value", "from_unit", "to_unit"]
+      }
+    }
+  };
+}
+function date() {
+  return {
+    type: "function",
+    function: {
+      name: "date",
+      description: "Date and time processing tool, supports displaying current time, timezone conversion, date calculation, and more.",
+      parameters: {
+        type: "object",
+        properties: {
+          operation: {
+            description: "Operation type",
+            type: "string",
+            enum: ["time", "convert", "between", "add", "subtract"]
+          },
+          date: {
+            description: "Date string (YYYY-MM-DD or YYYY-MM-DD HH:MM:SS)",
+            type: "string"
+          },
+          date1: {
+            description: "First date (for difference calculation)",
+            type: "string"
+          },
+          date2: {
+            description: "Second date (for difference calculation)",
+            type: "string"
+          },
+          days: {
+            description: "Number of days (for add/subtract)",
+            type: "integer"
+          },
+          zone: {
+            description: "Timezone name (e.g., Asia/Shanghai, America/New_York, UTC)",
+            type: "string"
+          },
+          from_zone: {
+            description: "Source timezone (for conversion)",
+            type: "string"
+          },
+          to_zone: {
+            description: "Target timezone (for conversion)",
+            type: "string"
+          },
+          format: {
+            description: "Output format (Python strftime)",
+            type: "string",
+            default: "%Y-%m-%d %H:%M:%S"
+          }
+        },
+        required: ["operation"]
+      }
+    }
+  };
+}
+function base64Encode() {
+  return {
+    type: "function",
+    function: {
+      name: "base64_encode",
+      description: "Encode text to base64 format",
+      parameters: {
+        type: "object",
+        properties: {
+          data: {
+            description: "Text data to encode to base64",
+            type: "string"
+          },
+          encoding: {
+            description: "Character encoding to use (default: utf-8)",
+            type: "string",
+            default: "utf-8"
+          }
+        },
+        required: ["data"]
+      }
+    }
+  };
+}
+function base64Decode() {
+  return {
+    type: "function",
+    function: {
+      name: "base64_decode",
+      description: "Decode base64 text to original format",
+      parameters: {
+        type: "object",
+        properties: {
+          data: {
+            description: "Base64 encoded data to decode",
+            type: "string"
+          },
+          encoding: {
+            description: "Character encoding to use (default: utf-8)",
+            type: "string",
+            default: "utf-8"
+          }
+        },
+        required: ["data"]
+      }
+    }
+  };
+}
+function memory() {
+  return {
+    type: "function",
+    function: {
+      name: "memory",
+      description: "Memory storage and retrieval system, supporting persistence of conversation history, user preferences, and other data.",
+      parameters: {
+        type: "object",
+        properties: {
+          action: {
+            description: "Operation type",
+            type: "string",
+            enum: ["store", "retrieve", "delete", "list"]
+          },
+          key: {
+            description: "Storage key name",
+            type: "string"
+          },
+          data: {
+            description: "Data content to store",
+            type: "object"
+          },
+          prefix: {
+            description: "Key prefix for list operation",
+            type: "string"
+          },
+          ttl: {
+            description: "Data expiration time in seconds (default: 86400 = 24 hours)",
+            type: "integer",
+            default: 86400
+          }
+        },
+        required: ["action"]
+      }
+    }
+  };
+}
+function rethink() {
+  return {
+    type: "function",
+    function: {
+      name: "rethink",
+      description: "Tool for organizing thoughts, making plans, and thinking step by step. Does not return information, just for reflection.",
+      parameters: {
+        type: "object",
+        properties: {
+          thought: {
+            description: "The thought to consider for better solving the current task",
+            type: "string"
+          }
+        },
+        required: ["thought"]
+      }
+    }
+  };
+}
+function randomChoice() {
+  return {
+    type: "function",
+    function: {
+      name: "random_choice",
+      description: "Random selection tool that supports choosing items from candidates with optional weights.",
+      parameters: {
+        type: "object",
+        properties: {
+          candidates: {
+            description: "List of candidates to choose from",
+            type: "array",
+            items: { type: "string" }
+          },
+          count: {
+            description: "Number of items to select (default: 1)",
+            type: "integer",
+            default: 1
+          },
+          replace: {
+            description: "Allow duplicates (default: false)",
+            type: "boolean",
+            default: false
+          },
+          weights: {
+            description: "Optional weights for weighted selection",
+            type: "array",
+            items: { type: "number" }
+          },
+          seed: {
+            description: "Random seed for reproducibility",
+            type: "integer"
+          },
+          format: {
+            description: "Output format",
+            type: "string",
+            enum: ["simple", "detailed", "json"],
+            default: "simple"
+          }
+        },
+        required: ["candidates"]
+      }
+    }
+  };
+}
+function mew() {
+  return {
+    type: "function",
+    function: {
+      name: "mew_generator",
+      description: "Randomly generates a cat's meow, accompanied by a blessing.",
+      parameters: {
+        type: "object",
+        properties: {
+          mood: {
+            description: "The cat's mood",
+            type: "string",
+            enum: ["happy", "sleepy", "hungry", "playful", "grumpy"]
+          }
+        },
+        required: []
+      }
+    }
+  };
+}
+var tools = {
+  /** Web search for real-time internet information */
+  webSearch,
+  /** Python code execution with matplotlib, pandas support */
+  codeRunner,
+  /** JavaScript execution via QuickJS engine */
+  quickjs,
+  /** URL content fetching with markdown extraction */
+  fetch,
+  /** Unit conversion (length, mass, temperature, currency, etc.) */
+  convert,
+  /** Date/time processing and timezone conversion */
+  date,
+  /** Base64 encoding */
+  base64Encode,
+  /** Base64 decoding */
+  base64Decode,
+  /** Alias for base64Encode */
+  base64: base64Encode,
+  /** Memory storage and retrieval system */
+  memory,
+  /** Intelligent reasoning/reflection tool */
+  rethink,
+  /** Random selection with optional weights */
+  randomChoice,
+  /** Cat meowing and blessings generator */
+  mew
+};
+
+// src/providers/moonshot/index.ts
+var moonshot = createProvider({
+  name: "moonshot",
+  version: "1.0.0",
+  handlers: {
+    llm: createLLMHandler()
+  }
+});
+export {
+  moonshot,
+  tools
+};
+//# sourceMappingURL=index.js.map