echospace 0.0.1 → 0.1.0-alpha.1

package/dist/core/providers/index.js

@@ -0,0 +1,384 @@
+// src/core/providers/anthropic.ts
+function toAnthropicContent(msg) {
+  const blocks = [];
+  for (const part of msg.parts) {
+    switch (part.type) {
+      case "text":
+        blocks.push({ type: "text", text: part.text });
+        break;
+      case "thinking":
+        blocks.push({ type: "thinking", thinking: part.text });
+        break;
+      case "tool_call":
+        blocks.push({
+          type: "tool_use",
+          id: part.id,
+          name: part.name,
+          input: part.input
+        });
+        break;
+      case "tool_result":
+        blocks.push({
+          type: "tool_result",
+          tool_use_id: part.id,
+          content: typeof part.output === "string" ? part.output : JSON.stringify(part.output),
+          is_error: part.is_error
+        });
+        break;
+      case "image":
+        if (part.base64) {
+          blocks.push({
+            type: "image",
+            source: {
+              type: "base64",
+              media_type: part.media_type ?? "image/png",
+              data: part.base64
+            }
+          });
+        }
+        break;
+    }
+  }
+  return blocks.length > 0 ? blocks : [{ type: "text", text: "" }];
+}
+var anthropicAdapter = {
+  type: "anthropic",
+  buildRequest(messages, settings, config) {
+    const baseUrl = config.base_url ?? "https://api.anthropic.com";
+    const url = `${baseUrl.replace(/\/$/, "")}/v1/messages`;
+    const systemMessages = messages.filter((m) => m.role === "system");
+    const nonSystemMessages = messages.filter((m) => m.role !== "system");
+    const system = systemMessages.flatMap((m) => m.parts.filter((p) => p.type === "text")).map((p) => p.text).join("\n\n");
+    const body = {
+      model: settings.model ?? config.models[0],
+      messages: nonSystemMessages.map((msg) => ({
+        role: msg.role === "tool" ? "user" : msg.role,
+        content: toAnthropicContent(msg)
+      })),
+      max_tokens: settings.max_tokens ?? 4096,
+      stream: true
+    };
+    if (system) body.system = system;
+    if (settings.temperature != null) body.temperature = settings.temperature;
+    if (settings.top_p != null) body.top_p = settings.top_p;
+    if (settings.tools && settings.tools.length > 0) {
+      body.tools = settings.tools.map((t) => ({
+        name: t.name,
+        description: t.description,
+        input_schema: t.parameters
+      }));
+    }
+    const headers = {
+      "Content-Type": "application/json",
+      "anthropic-version": "2023-06-01"
+    };
+    if (config.api_key) {
+      headers["x-api-key"] = config.api_key;
+    }
+    return { url, headers, body };
+  },
+  parseChunk(chunk) {
+    try {
+      const event = JSON.parse(chunk);
+      const parts = [];
+      switch (event.type) {
+        case "content_block_delta": {
+          const delta = event.delta;
+          if (delta?.type === "text_delta" && delta.text) {
+            parts.push({ type: "text", text: delta.text });
+          }
+          if (delta?.type === "thinking_delta" && delta.thinking) {
+            parts.push({ type: "thinking", text: delta.thinking });
+          }
+          if (delta?.type === "input_json_delta" && delta.partial_json) {
+            parts.push({
+              type: "tool_call",
+              id: "",
+              name: "",
+              input: delta.partial_json
+            });
+          }
+          break;
+        }
+        case "content_block_start": {
+          const block = event.content_block;
+          if (block?.type === "tool_use") {
+            parts.push({
+              type: "tool_call",
+              id: block.id ?? "",
+              name: block.name ?? "",
+              input: ""
+            });
+          }
+          break;
+        }
+      }
+      return parts;
+    } catch {
+      return [];
+    }
+  },
+  isDone(chunk) {
+    try {
+      const event = JSON.parse(chunk);
+      return event.type === "message_stop";
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/core/providers/google.ts
+function toGeminiContent(msg) {
+  const parts = [];
+  for (const part of msg.parts) {
+    switch (part.type) {
+      case "text":
+      case "thinking":
+        parts.push({ text: part.text });
+        break;
+      case "tool_call":
+        parts.push({
+          functionCall: {
+            name: part.name,
+            args: typeof part.input === "string" ? JSON.parse(part.input) : part.input
+          }
+        });
+        break;
+      case "tool_result":
+        parts.push({
+          functionResponse: {
+            name: part.id,
+            response: { result: part.output }
+          }
+        });
+        break;
+      case "image":
+        if (part.base64) {
+          parts.push({
+            inlineData: {
+              mimeType: part.media_type ?? "image/png",
+              data: part.base64
+            }
+          });
+        }
+        break;
+    }
+  }
+  const role = msg.role === "assistant" ? "model" : "user";
+  return { role, parts };
+}
+var googleAdapter = {
+  type: "google",
+  buildRequest(messages, settings, config) {
+    const model = settings.model ?? config.models[0];
+    const baseUrl = config.base_url ?? "https://generativelanguage.googleapis.com/v1beta";
+    const url = `${baseUrl}/models/${model}:streamGenerateContent?alt=sse&key=${config.api_key ?? ""}`;
+    const systemMessages = messages.filter((m) => m.role === "system");
+    const nonSystemMessages = messages.filter((m) => m.role !== "system");
+    const systemInstruction = systemMessages.length > 0 ? {
+      parts: systemMessages.flatMap(
+        (m) => m.parts.filter((p) => p.type === "text").map((p) => ({ text: p.text }))
+      )
+    } : void 0;
+    const body = {
+      contents: nonSystemMessages.map(toGeminiContent),
+      generationConfig: {
+        ...settings.temperature != null && {
+          temperature: settings.temperature
+        },
+        ...settings.max_tokens != null && {
+          maxOutputTokens: settings.max_tokens
+        },
+        ...settings.top_p != null && { topP: settings.top_p }
+      }
+    };
+    if (systemInstruction) body.systemInstruction = systemInstruction;
+    if (settings.tools && settings.tools.length > 0) {
+      body.tools = [
+        {
+          functionDeclarations: settings.tools.map((t) => ({
+            name: t.name,
+            description: t.description,
+            parameters: t.parameters
+          }))
+        }
+      ];
+    }
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    return { url, headers, body };
+  },
+  parseChunk(chunk) {
+    try {
+      const data = JSON.parse(chunk);
+      const candidate = data?.candidates?.[0];
+      if (!candidate?.content?.parts) return [];
+      const parts = [];
+      for (const part of candidate.content.parts) {
+        if (part.text) {
+          parts.push({ type: "text", text: part.text });
+        }
+        if (part.functionCall) {
+          parts.push({
+            type: "tool_call",
+            id: part.functionCall.name ?? "",
+            name: part.functionCall.name ?? "",
+            input: part.functionCall.args ?? {}
+          });
+        }
+      }
+      return parts;
+    } catch {
+      return [];
+    }
+  },
+  isDone(chunk) {
+    try {
+      const data = JSON.parse(chunk);
+      const candidate = data?.candidates?.[0];
+      return candidate?.finishReason === "STOP";
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/core/providers/openai.ts
+function toOpenAIMessage(msg) {
+  const result = { role: msg.role };
+  const textParts = msg.parts.filter((p) => p.type === "text");
+  const toolCalls = msg.parts.filter((p) => p.type === "tool_call");
+  const toolResults = msg.parts.filter((p) => p.type === "tool_result");
+  const thinkingParts = msg.parts.filter((p) => p.type === "thinking");
+  if (msg.role === "tool" && toolResults.length > 0) {
+    const tr = toolResults[0];
+    result.content = typeof tr.output === "string" ? tr.output : JSON.stringify(tr.output);
+    result.tool_call_id = tr.id;
+    return result;
+  }
+  if (msg.role === "assistant") {
+    result.content = textParts.map((p) => p.text).join("") || null;
+    if (thinkingParts.length > 0) {
+      result.reasoning_content = thinkingParts.map((p) => p.text).join("");
+    }
+    if (toolCalls.length > 0) {
+      result.tool_calls = toolCalls.map((tc) => ({
+        id: tc.id,
+        type: "function",
+        function: {
+          name: tc.name,
+          arguments: typeof tc.input === "string" ? tc.input : JSON.stringify(tc.input)
+        }
+      }));
+    }
+    return result;
+  }
+  result.content = textParts.map((p) => p.text).join("");
+  return result;
+}
+var openaiAdapter = {
+  type: "openai",
+  buildRequest(messages, settings, config) {
+    const baseUrl = config.base_url ?? "https://api.openai.com/v1";
+    const url = `${baseUrl.replace(/\/$/, "")}/chat/completions`;
+    const body = {
+      model: settings.model ?? config.models[0],
+      messages: messages.map(toOpenAIMessage),
+      stream: true
+    };
+    if (settings.temperature != null) body.temperature = settings.temperature;
+    if (settings.max_tokens != null) body.max_tokens = settings.max_tokens;
+    if (settings.top_p != null) body.top_p = settings.top_p;
+    if (settings.response_format && settings.response_format !== "text") {
+      if (settings.response_format === "json_schema" && settings.json_schema) {
+        body.response_format = {
+          type: "json_schema",
+          json_schema: settings.json_schema
+        };
+      } else {
+        body.response_format = { type: settings.response_format };
+      }
+    }
+    if (settings.tools && settings.tools.length > 0) {
+      body.tools = settings.tools.map((t) => ({
+        type: "function",
+        function: {
+          name: t.name,
+          description: t.description,
+          parameters: t.parameters,
+          ...t.strict != null && { strict: t.strict }
+        }
+      }));
+    }
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (config.api_key) {
+      headers["Authorization"] = `Bearer ${config.api_key}`;
+    }
+    return { url, headers, body };
+  },
+  parseChunk(chunk) {
+    if (chunk === "[DONE]") return [];
+    try {
+      const data = JSON.parse(chunk);
+      const delta = data?.choices?.[0]?.delta;
+      if (!delta) return [];
+      const parts = [];
+      if (delta.content) {
+        parts.push({ type: "text", text: delta.content });
+      }
+      if (delta.reasoning_content) {
+        parts.push({ type: "thinking", text: delta.reasoning_content });
+      }
+      if (delta.tool_calls) {
+        for (const tc of delta.tool_calls) {
+          if (tc.function) {
+            parts.push({
+              type: "tool_call",
+              id: tc.id ?? "",
+              name: tc.function.name ?? "",
+              input: tc.function.arguments ?? ""
+            });
+          }
+        }
+      }
+      return parts;
+    } catch {
+      return [];
+    }
+  },
+  isDone(chunk) {
+    return chunk === "[DONE]";
+  }
+};
+
+// src/core/providers/registry.ts
+var DefaultProviderRegistry = class {
+  adapters = /* @__PURE__ */ new Map();
+  get(type) {
+    const adapter = this.adapters.get(type);
+    if (!adapter) {
+      throw new Error(`Unknown provider type: ${type}`);
+    }
+    return adapter;
+  }
+  register(adapter) {
+    this.adapters.set(adapter.type, adapter);
+  }
+};
+function createProviderRegistry() {
+  const registry = new DefaultProviderRegistry();
+  registry.register(openaiAdapter);
+  registry.register(anthropicAdapter);
+  registry.register(googleAdapter);
+  return registry;
+}
+export {
+  anthropicAdapter,
+  createProviderRegistry,
+  googleAdapter,
+  openaiAdapter
+};

package/dist/core/smart-paste/index.d.ts

@@ -0,0 +1,15 @@
+import { a as EchoMessage } from '../types-CYpEmXbp.js';
+
+type DetectedFormat = "openai" | "anthropic" | "google" | "vercel" | "echo" | "raw" | "unknown";
+/**
+ * Detect the format of pasted conversation text.
+ */
+declare function detectFormat(input: string): DetectedFormat;
+
+/**
+ * Smart-parse any pasted conversation text into EchoMessages.
+ * Auto-detects the format and converts accordingly.
+ */
+declare function smartParse(input: string): EchoMessage[];
+
+export { type DetectedFormat, detectFormat, smartParse };