@moraya/core 0.2.0 → 0.4.0

package/dist/ai/drivers/index.js

@@ -0,0 +1,617 @@
+// src/ai/drivers/tool-bridge.ts
+var GEMINI_UNSUPPORTED_KEYS = /* @__PURE__ */ new Set([
+  "additionalProperties",
+  "$schema",
+  "$id",
+  "$ref",
+  "$defs",
+  "definitions",
+  "patternProperties",
+  "unevaluatedProperties",
+  "dependentRequired",
+  "dependentSchemas",
+  "const"
+]);
+function sanitizeGeminiSchema(schema) {
+  if (Array.isArray(schema)) return schema.map(sanitizeGeminiSchema);
+  if (schema && typeof schema === "object") {
+    const out = {};
+    for (const [key, value] of Object.entries(schema)) {
+      if (GEMINI_UNSUPPORTED_KEYS.has(key)) continue;
+      out[key] = sanitizeGeminiSchema(value);
+    }
+    return out;
+  }
+  return schema;
+}
+function formatToolsForProvider(provider, tools) {
+  if (tools.length === 0) return {};
+  switch (provider) {
+    case "claude":
+      return {
+        tools: tools.map((t) => ({ name: t.name, description: t.description, input_schema: t.input_schema }))
+      };
+    case "gemini":
+      return {
+        tools: [{
+          functionDeclarations: tools.map((t) => ({
+            name: t.name,
+            description: t.description,
+            parameters: sanitizeGeminiSchema(t.input_schema)
+          }))
+        }]
+      };
+    default:
+      return {
+        tools: tools.map((t) => ({
+          type: "function",
+          function: { name: t.name, description: t.description, parameters: t.input_schema }
+        }))
+      };
+  }
+}
+function parseClaudeToolCalls(data) {
+  const content = data.content;
+  const stopReason = data.stop_reason || "end_turn";
+  const toolCalls = [];
+  let textContent = "";
+  if (content) {
+    for (const block of content) {
+      if (block.type === "tool_use") {
+        toolCalls.push({ id: block.id, name: block.name, arguments: block.input || {} });
+      } else if (block.type === "text") {
+        textContent += block.text;
+      }
+    }
+  }
+  return { toolCalls, textContent, stopReason };
+}
+function parseOpenAIToolCalls(data) {
+  const choices = data.choices;
+  if (!choices || choices.length === 0) return { toolCalls: [], textContent: "", stopReason: "stop" };
+  const choice = choices[0];
+  const message = choice.message;
+  const finishReason = choice.finish_reason || "stop";
+  const textContent = message?.content || "";
+  const toolCalls = [];
+  const rawToolCalls = message?.tool_calls;
+  if (rawToolCalls) {
+    for (const tc of rawToolCalls) {
+      const fn = tc.function;
+      let args = {};
+      try {
+        args = JSON.parse(fn.arguments);
+      } catch {
+      }
+      toolCalls.push({ id: tc.id, name: fn.name, arguments: args });
+    }
+  }
+  return { toolCalls, textContent, stopReason: finishReason === "tool_calls" ? "tool_use" : finishReason };
+}
+function parseGeminiToolCalls(data) {
+  const candidates = data.candidates;
+  if (!candidates || candidates.length === 0) return { toolCalls: [], textContent: "", stopReason: "stop" };
+  const content = candidates[0].content;
+  const parts = content?.parts;
+  const toolCalls = [];
+  let textContent = "";
+  if (parts) {
+    for (const part of parts) {
+      if (part.functionCall) {
+        const fc = part.functionCall;
+        const thoughtSignature = part.thoughtSignature ?? fc.thoughtSignature;
+        toolCalls.push({
+          id: `gemini-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+          name: fc.name,
+          arguments: fc.args || {},
+          ...thoughtSignature ? { providerMeta: { thoughtSignature } } : {}
+        });
+      } else if (part.text) {
+        textContent += part.text;
+      }
+    }
+  }
+  return { toolCalls, textContent, stopReason: toolCalls.length > 0 ? "tool_use" : "stop" };
+}
+
+// src/ai/catalog.ts
+var PROVIDER_BASE_URLS = {
+  claude: "https://api.anthropic.com",
+  openai: "https://api.openai.com",
+  gemini: "https://generativelanguage.googleapis.com",
+  deepseek: "https://api.deepseek.com",
+  ollama: "http://localhost:11434",
+  grok: "https://api.x.ai",
+  mistral: "https://api.mistral.ai",
+  glm: "https://open.bigmodel.cn/api/paas/v4",
+  minimax: "https://api.minimax.io/v1",
+  doubao: "https://ark.cn-beijing.volces.com/api/v3",
+  custom: "",
+  "local-mlx": "",
+  "local-llama": ""
+};
+
+// src/ai/drivers/util.ts
+function resolveBaseUrl(config, fallback) {
+  return config.baseUrl || PROVIDER_BASE_URLS[config.provider] || fallback;
+}
+function openaiEndpoint(baseUrl, path) {
+  const clean = baseUrl.replace(/\/+$/, "");
+  if (/\/v\d+$/.test(clean)) return `${clean}${path}`;
+  return `${clean}/v1${path}`;
+}
+var NOOP_FOLD = {
+  pushEnvelope() {
+    return void 0;
+  },
+  finish() {
+    return { stopReason: "end_turn" };
+  }
+};
+
+// src/ai/drivers/claude.ts
+function buildClaudeMessages(messages) {
+  const result = [];
+  for (const msg of messages) {
+    if (msg.role === "assistant" && msg.toolCalls && msg.toolCalls.length > 0) {
+      const content = [];
+      if (msg.content) content.push({ type: "text", text: msg.content });
+      for (const tc of msg.toolCalls) content.push({ type: "tool_use", id: tc.id, name: tc.name, input: tc.arguments });
+      result.push({ role: "assistant", content });
+    } else if (msg.role === "tool") {
+      const lastMsg = result[result.length - 1];
+      const toolResultBlock = { type: "tool_result", tool_use_id: msg.toolCallId, content: msg.content, is_error: msg.isError || false };
+      if (lastMsg && lastMsg.role === "user" && Array.isArray(lastMsg.content) && lastMsg.content.every((b) => b.type === "tool_result")) {
+        lastMsg.content.push(toolResultBlock);
+      } else {
+        result.push({ role: "user", content: [toolResultBlock] });
+      }
+    } else if (msg.role === "user" && msg.images && msg.images.length > 0) {
+      const content = [];
+      for (const img of msg.images) content.push({ type: "image", source: { type: "base64", media_type: img.mimeType, data: img.base64 } });
+      if (msg.content) content.push({ type: "text", text: msg.content });
+      result.push({ role: "user", content });
+    } else {
+      result.push({ role: msg.role, content: msg.content });
+    }
+  }
+  return result;
+}
+var claudeDriver = {
+  supportsStreaming: true,
+  buildChatRequest(config, request, stream) {
+    const baseUrl = resolveBaseUrl(config, "https://api.anthropic.com");
+    const systemMessages = request.messages.filter((m) => m.role === "system");
+    const chatMessages = request.messages.filter((m) => m.role !== "system");
+    const body = {
+      model: request.model || config.model,
+      max_tokens: request.maxTokens ?? config.maxTokens ?? 41920,
+      messages: buildClaudeMessages(chatMessages)
+    };
+    if (stream) body.stream = true;
+    if (systemMessages.length > 0) body.system = systemMessages.map((m) => m.content).join("\n");
+    const temperature = request.temperature ?? config.temperature;
+    if (temperature !== void 0) body.temperature = temperature;
+    const topP = request.topP ?? config.topP;
+    if (topP !== void 0) body.top_p = topP;
+    if (request.stop && request.stop.length > 0) body.stop_sequences = request.stop.slice(0, 5);
+    if (request.tools && request.tools.length > 0) Object.assign(body, formatToolsForProvider("claude", request.tools));
+    return {
+      provider: "claude",
+      configId: config.id,
+      method: "POST",
+      url: `${baseUrl}/v1/messages`,
+      headers: {
+        "anthropic-version": "2023-06-01",
+        // Required for direct browser fetch; harmless when proxied via Rust.
+        "anthropic-dangerous-direct-browser-access": "true"
+      },
+      body: JSON.stringify(body),
+      auth: { scheme: "header", headerName: "x-api-key" }
+    };
+  },
+  parseResponse(json, _config) {
+    const parsed = parseClaudeToolCalls(json);
+    const usage = json.usage;
+    return {
+      content: parsed.textContent,
+      model: json.model || _config.model,
+      usage: { inputTokens: usage?.input_tokens || 0, outputTokens: usage?.output_tokens || 0 },
+      ...parsed.toolCalls.length > 0 ? { toolCalls: parsed.toolCalls } : {},
+      stopReason: parsed.stopReason
+    };
+  },
+  createStreamFold() {
+    const partials = /* @__PURE__ */ new Map();
+    const toolCalls = [];
+    let stopReason = "end_turn";
+    let inputTokens = 0;
+    let outputTokens = 0;
+    return {
+      pushEnvelope(raw) {
+        let v;
+        try {
+          v = JSON.parse(raw);
+        } catch {
+          return void 0;
+        }
+        switch (v.type) {
+          case "message_start": {
+            const u = v.message?.usage;
+            if (u?.input_tokens) inputTokens = u.input_tokens;
+            break;
+          }
+          case "content_block_delta": {
+            const delta = v.delta;
+            if (delta?.type === "text_delta") return delta.text || void 0;
+            if (delta?.type === "input_json_delta") {
+              const p = partials.get(v.index);
+              if (p) p.json += delta.partial_json || "";
+            }
+            break;
+          }
+          case "content_block_start": {
+            const block = v.content_block;
+            if (block?.type === "tool_use") partials.set(v.index, { id: block.id, name: block.name, json: "" });
+            break;
+          }
+          case "content_block_stop": {
+            const p = partials.get(v.index);
+            if (p) {
+              try {
+                toolCalls.push({ id: p.id, name: p.name, arguments: JSON.parse(p.json || "{}") });
+              } catch {
+              }
+              partials.delete(v.index);
+            }
+            break;
+          }
+          case "message_delta": {
+            const d = v.delta;
+            if (d?.stop_reason) stopReason = d.stop_reason === "tool_use" ? "tool_use" : d.stop_reason;
+            const u = v.usage;
+            if (u?.output_tokens) outputTokens = u.output_tokens;
+            break;
+          }
+        }
+        return void 0;
+      },
+      finish() {
+        const usage = inputTokens || outputTokens ? { inputTokens, outputTokens } : void 0;
+        return { ...toolCalls.length > 0 ? { toolCalls } : {}, stopReason, ...usage ? { usage } : {} };
+      }
+    };
+  }
+};
+
+// src/ai/drivers/openai.ts
+function buildOpenAIMessages(messages) {
+  return messages.map((msg) => {
+    if (msg.role === "assistant" && msg.toolCalls && msg.toolCalls.length > 0) {
+      return {
+        role: "assistant",
+        content: msg.content || null,
+        tool_calls: msg.toolCalls.map((tc) => ({
+          id: tc.id,
+          type: "function",
+          function: { name: tc.name, arguments: JSON.stringify(tc.arguments) }
+        }))
+      };
+    } else if (msg.role === "tool") {
+      return { role: "tool", tool_call_id: msg.toolCallId, content: msg.content };
+    } else if (msg.role === "user" && msg.images && msg.images.length > 0) {
+      const content = [];
+      for (const img of msg.images) content.push({ type: "image_url", image_url: { url: `data:${img.mimeType};base64,${img.base64}` } });
+      if (msg.content) content.push({ type: "text", text: msg.content });
+      return { role: "user", content };
+    }
+    return { role: msg.role, content: msg.content };
+  });
+}
+var openaiDriver = {
+  supportsStreaming: true,
+  buildChatRequest(config, request, stream) {
+    const baseUrl = resolveBaseUrl(config, "https://api.openai.com");
+    const body = {
+      model: request.model || config.model,
+      max_tokens: request.maxTokens ?? config.maxTokens ?? 41920,
+      temperature: request.temperature ?? config.temperature ?? 0.7,
+      messages: buildOpenAIMessages(request.messages)
+    };
+    if (stream) {
+      body.stream = true;
+      if (config.provider === "openai" || config.provider === "deepseek") {
+        body.stream_options = { include_usage: true };
+      }
+    }
+    const topP = request.topP ?? config.topP;
+    if (topP !== void 0) body.top_p = topP;
+    if (request.stop && request.stop.length > 0) body.stop = request.stop.slice(0, 4);
+    if (request.tools && request.tools.length > 0) Object.assign(body, formatToolsForProvider(config.provider, request.tools));
+    const proxyProvider = config.provider === "deepseek" ? "deepseek" : "openai";
+    return {
+      provider: proxyProvider,
+      configId: config.id,
+      method: "POST",
+      url: openaiEndpoint(baseUrl, "/chat/completions"),
+      headers: {},
+      body: JSON.stringify(body),
+      auth: { scheme: "bearer" }
+    };
+  },
+  parseResponse(json, _config) {
+    const parsed = parseOpenAIToolCalls(json);
+    const usage = json.usage;
+    return {
+      content: parsed.textContent,
+      model: json.model || _config.model,
+      usage: { inputTokens: usage?.prompt_tokens || 0, outputTokens: usage?.completion_tokens || 0 },
+      ...parsed.toolCalls.length > 0 ? { toolCalls: parsed.toolCalls } : {},
+      stopReason: parsed.stopReason
+    };
+  },
+  createStreamFold() {
+    const toolMap = /* @__PURE__ */ new Map();
+    let stopReason = "end_turn";
+    let usage;
+    return {
+      pushEnvelope(raw) {
+        let v;
+        try {
+          v = JSON.parse(raw);
+        } catch {
+          return void 0;
+        }
+        const u = v.usage;
+        if (u) usage = { inputTokens: u.prompt_tokens || 0, outputTokens: u.completion_tokens || 0 };
+        const choices = v.choices;
+        if (!choices || choices.length === 0) return void 0;
+        const choice = choices[0];
+        const fr = choice.finish_reason;
+        if (fr) stopReason = fr === "tool_calls" ? "tool_use" : fr === "length" ? "max_tokens" : fr;
+        const delta = choice.delta;
+        const rawTC = delta?.tool_calls;
+        if (rawTC) {
+          for (const tc of rawTC) {
+            const idx = tc.index ?? 0;
+            const fn = tc.function;
+            let entry = toolMap.get(idx);
+            if (!entry) {
+              entry = { id: tc.id || "", name: "", args: "" };
+              toolMap.set(idx, entry);
+            }
+            if (tc.id) entry.id = tc.id;
+            if (fn?.name) entry.name = fn.name;
+            if (fn?.arguments) entry.args += fn.arguments;
+          }
+        }
+        return delta?.content || void 0;
+      },
+      finish() {
+        const toolCalls = [];
+        for (const [, entry] of [...toolMap.entries()].sort((a, b) => a[0] - b[0])) {
+          let args = {};
+          try {
+            args = JSON.parse(entry.args || "{}");
+          } catch {
+            continue;
+          }
+          toolCalls.push({ id: entry.id, name: entry.name, arguments: args });
+        }
+        return { ...toolCalls.length > 0 ? { toolCalls } : {}, stopReason, ...usage ? { usage } : {} };
+      }
+    };
+  }
+};
+
+// src/ai/drivers/gemini.ts
+function buildGeminiContents(messages) {
+  return messages.map((msg) => {
+    if (msg.role === "assistant" && msg.toolCalls && msg.toolCalls.length > 0) {
+      const parts = [];
+      if (msg.content) parts.push({ text: msg.content });
+      for (const tc of msg.toolCalls) {
+        const sig = tc.providerMeta?.thoughtSignature;
+        const part = { functionCall: { name: tc.name, args: tc.arguments } };
+        if (sig) part.thoughtSignature = sig;
+        parts.push(part);
+      }
+      return { role: "model", parts };
+    } else if (msg.role === "tool") {
+      return { role: "user", parts: [{ functionResponse: { name: msg.toolName, response: { content: msg.content } } }] };
+    }
+    if (msg.role === "user" && msg.images && msg.images.length > 0) {
+      const parts = [];
+      for (const img of msg.images) parts.push({ inlineData: { mimeType: img.mimeType, data: img.base64 } });
+      if (msg.content) parts.push({ text: msg.content });
+      return { role: "user", parts };
+    }
+    return { role: msg.role === "assistant" ? "model" : "user", parts: [{ text: msg.content }] };
+  });
+}
+var geminiDriver = {
+  supportsStreaming: true,
+  buildChatRequest(config, request, stream) {
+    const baseUrl = resolveBaseUrl(config, "https://generativelanguage.googleapis.com");
+    const systemMessages = request.messages.filter((m) => m.role === "system");
+    const chatMessages = request.messages.filter((m) => m.role !== "system");
+    const generationConfig = {
+      maxOutputTokens: request.maxTokens ?? config.maxTokens ?? 41920,
+      temperature: request.temperature ?? config.temperature ?? 0.7
+    };
+    const topP = request.topP ?? config.topP;
+    if (topP !== void 0) generationConfig.topP = topP;
+    if (request.stop && request.stop.length > 0) generationConfig.stopSequences = request.stop;
+    const body = { contents: buildGeminiContents(chatMessages), generationConfig };
+    if (systemMessages.length > 0) body.systemInstruction = { parts: [{ text: systemMessages.map((m) => m.content).join("\n") }] };
+    if (request.tools && request.tools.length > 0) Object.assign(body, formatToolsForProvider("gemini", request.tools));
+    const model = request.model || config.model;
+    const verb = stream ? "streamGenerateContent?alt=sse" : "generateContent";
+    return {
+      provider: "gemini",
+      configId: config.id,
+      method: "POST",
+      url: `${baseUrl}/v1beta/models/${model}:${verb}`,
+      headers: {},
+      body: JSON.stringify(body),
+      auth: { scheme: "query", queryParam: "key" }
+    };
+  },
+  parseResponse(json, config) {
+    const parsed = parseGeminiToolCalls(json);
+    const usage = json.usageMetadata;
+    return {
+      content: parsed.textContent,
+      model: config.model,
+      usage: { inputTokens: usage?.promptTokenCount || 0, outputTokens: usage?.candidatesTokenCount || 0 },
+      ...parsed.toolCalls.length > 0 ? { toolCalls: parsed.toolCalls } : {},
+      stopReason: parsed.stopReason === "tool_use" ? "tool_use" : "end_turn"
+    };
+  },
+  createStreamFold() {
+    const toolCalls = [];
+    let stopReason = "end_turn";
+    let usage;
+    return {
+      pushEnvelope(raw) {
+        let v;
+        try {
+          v = JSON.parse(raw);
+        } catch {
+          return void 0;
+        }
+        const um = v.usageMetadata;
+        if (um) usage = { inputTokens: um.promptTokenCount || 0, outputTokens: um.candidatesTokenCount || 0 };
+        const candidates = v.candidates;
+        const cand = candidates?.[0];
+        if (!cand) return void 0;
+        const parts = cand.content?.parts;
+        let text = "";
+        if (parts) {
+          for (const part of parts) {
+            if (part.functionCall) {
+              const fc = part.functionCall;
+              const sig = part.thoughtSignature ?? fc.thoughtSignature;
+              toolCalls.push({
+                id: `gemini-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+                name: fc.name,
+                arguments: fc.args || {},
+                ...sig ? { providerMeta: { thoughtSignature: sig } } : {}
+              });
+              stopReason = "tool_use";
+            } else if (part.text) {
+              text += part.text;
+            }
+          }
+        }
+        return text || void 0;
+      },
+      finish() {
+        return { ...toolCalls.length > 0 ? { toolCalls } : {}, stopReason, ...usage ? { usage } : {} };
+      }
+    };
+  }
+};
+
+// src/ai/drivers/ollama.ts
+function buildOllamaMessages(messages) {
+  return messages.map((msg) => {
+    if (msg.role === "assistant" && msg.toolCalls && msg.toolCalls.length > 0) {
+      return {
+        role: "assistant",
+        content: msg.content || "",
+        tool_calls: msg.toolCalls.map((tc) => ({
+          id: tc.id,
+          type: "function",
+          function: { name: tc.name, arguments: JSON.stringify(tc.arguments) }
+        }))
+      };
+    } else if (msg.role === "tool") {
+      return { role: "tool", tool_call_id: msg.toolCallId, content: msg.content };
+    }
+    const result = { role: msg.role, content: msg.content };
+    if (msg.role === "user" && msg.images && msg.images.length > 0) result.images = msg.images.map((img) => img.base64);
+    return result;
+  });
+}
+var ollamaDriver = {
+  supportsStreaming: false,
+  buildChatRequest(config, request, _stream) {
+    const baseUrl = resolveBaseUrl(config, "http://localhost:11434");
+    const body = {
+      model: request.model || config.model,
+      messages: buildOllamaMessages(request.messages),
+      stream: false,
+      options: {
+        temperature: request.temperature ?? config.temperature ?? 0.7,
+        num_predict: request.maxTokens ?? config.maxTokens ?? 41920
+      }
+    };
+    if (request.tools && request.tools.length > 0) Object.assign(body, formatToolsForProvider("ollama", request.tools));
+    return {
+      provider: "ollama",
+      configId: config.id,
+      method: "POST",
+      url: `${baseUrl}/api/chat`,
+      headers: {},
+      body: JSON.stringify(body),
+      auth: { scheme: "none" }
+    };
+  },
+  parseResponse(json, _config) {
+    const message = json.message;
+    const toolCalls = [];
+    const rawToolCalls = message?.tool_calls;
+    if (rawToolCalls) {
+      for (const tc of rawToolCalls) {
+        const fn = tc.function;
+        toolCalls.push({
+          id: `ollama-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+          name: fn.name,
+          arguments: fn.arguments || {}
+        });
+      }
+    }
+    return {
+      content: message?.content || "",
+      model: json.model || _config.model,
+      usage: { inputTokens: json.prompt_eval_count || 0, outputTokens: json.eval_count || 0 },
+      ...toolCalls.length > 0 ? { toolCalls } : {},
+      stopReason: toolCalls.length > 0 ? "tool_use" : "end_turn"
+    };
+  },
+  createStreamFold() {
+    return NOOP_FOLD;
+  }
+};
+
+// src/ai/drivers/index.ts
+function getDriver(provider) {
+  switch (provider) {
+    case "claude":
+      return claudeDriver;
+    case "gemini":
+      return geminiDriver;
+    case "ollama":
+      return ollamaDriver;
+    case "openai":
+    case "deepseek":
+    case "grok":
+    case "mistral":
+    case "glm":
+    case "minimax":
+    case "doubao":
+    case "custom":
+      return openaiDriver;
+    default:
+      throw new Error(`No HTTP driver for provider: ${provider}`);
+  }
+}
+export {
+  claudeDriver,
+  geminiDriver,
+  getDriver,
+  ollamaDriver,
+  openaiDriver
+};
+//# sourceMappingURL=index.js.map