@ftarganski/omni-ai 0.1.0

package/dist/chunk-Y4EYGADJ.js

@@ -0,0 +1,216 @@
+#!/usr/bin/env node
+import {
+  registerProvider
+} from "./chunk-AWMSN7OB.js";
+
+// ../provider-openai/src/provider.ts
+import OpenAI from "openai";
+
+// ../provider-openai/src/mappers.ts
+function toOpenAIUserContentPart(part) {
+  if (part.type === "text") return { type: "text", text: part.text };
+  return {
+    type: "image_url",
+    image_url: { url: `data:${part.mimeType};base64,${part.data}` }
+  };
+}
+function contentAsString(content) {
+  if (typeof content === "string") return content;
+  return content.map((p) => p.type === "text" ? p.text : "").join("");
+}
+function toOpenAIMessages(messages) {
+  return messages.map((m) => {
+    if (m.role === "system") {
+      return { role: "system", content: contentAsString(m.content) };
+    }
+    if (m.role === "assistant") {
+      return { role: "assistant", content: contentAsString(m.content) };
+    }
+    return {
+      role: "user",
+      content: typeof m.content === "string" ? m.content : m.content.map(toOpenAIUserContentPart)
+    };
+  });
+}
+function toOpenAITools(tools) {
+  return tools.map((t) => ({
+    type: "function",
+    function: {
+      name: t.name,
+      description: t.description,
+      parameters: t.parameters
+    }
+  }));
+}
+function fromOpenAIResponse(response, providerName) {
+  const choice = response.choices[0];
+  const message = choice.message;
+  const toolCalls = [];
+  for (const tc of message.tool_calls ?? []) {
+    toolCalls.push({
+      id: tc.id,
+      name: tc.function.name,
+      arguments: JSON.parse(tc.function.arguments || "{}")
+    });
+  }
+  return {
+    content: message.content ?? "",
+    toolCalls: toolCalls.length > 0 ? toolCalls : void 0,
+    usage: response.usage ? {
+      inputTokens: response.usage.prompt_tokens,
+      outputTokens: response.usage.completion_tokens
+    } : void 0,
+    model: response.model,
+    provider: providerName
+  };
+}
+
+// ../provider-openai/src/provider.ts
+var OpenAIProvider = class {
+  name;
+  capabilities = {
+    chat: true,
+    embedding: true,
+    streaming: true,
+    toolUse: true,
+    vision: true
+  };
+  client;
+  defaultModel;
+  constructor(options) {
+    this.name = options.name ?? "openai";
+    this.defaultModel = options.defaultModel ?? "gpt-4o";
+    this.client = new OpenAI({
+      apiKey: options.apiKey,
+      baseURL: options.baseUrl
+    });
+  }
+  async complete(request) {
+    const model = request.model ?? this.defaultModel;
+    const messages = toOpenAIMessages(request.messages);
+    const tools = request.tools && request.tools.length > 0 ? toOpenAITools(request.tools) : void 0;
+    if (request.onToken) {
+      const stream = await this.client.chat.completions.create({
+        model,
+        temperature: request.temperature,
+        max_tokens: request.maxTokens,
+        messages,
+        tools,
+        tool_choice: tools ? "auto" : void 0,
+        stream: true,
+        stream_options: { include_usage: true }
+      });
+      let content = "";
+      const toolCallAccum = {};
+      let inputTokens = 0;
+      let outputTokens = 0;
+      for await (const chunk of stream) {
+        const delta = chunk.choices[0]?.delta;
+        if (delta?.content) {
+          content += delta.content;
+          request.onToken(delta.content);
+        }
+        if (delta?.tool_calls) {
+          for (const tc of delta.tool_calls) {
+            const idx = tc.index;
+            if (!toolCallAccum[idx]) {
+              toolCallAccum[idx] = { id: "", name: "", args: "" };
+            }
+            if (tc.id) toolCallAccum[idx].id = tc.id;
+            if (tc.function?.name) toolCallAccum[idx].name = tc.function.name;
+            if (tc.function?.arguments) toolCallAccum[idx].args += tc.function.arguments;
+          }
+        }
+        if (chunk.usage) {
+          inputTokens = chunk.usage.prompt_tokens;
+          outputTokens = chunk.usage.completion_tokens;
+        }
+      }
+      const toolCalls = Object.values(toolCallAccum);
+      return {
+        content,
+        toolCalls: toolCalls.length > 0 ? toolCalls.map((tc) => ({
+          id: tc.id,
+          name: tc.name,
+          arguments: (() => {
+            try {
+              return JSON.parse(tc.args);
+            } catch {
+              return {};
+            }
+          })()
+        })) : void 0,
+        usage: inputTokens > 0 ? { inputTokens, outputTokens } : void 0,
+        model,
+        provider: this.name
+      };
+    }
+    const response = await this.client.chat.completions.create({
+      model,
+      temperature: request.temperature,
+      max_tokens: request.maxTokens,
+      messages,
+      tools,
+      tool_choice: tools ? "auto" : void 0
+    });
+    return fromOpenAIResponse(response, this.name);
+  }
+  async embed(request) {
+    const model = request.model ?? "text-embedding-3-small";
+    const input = Array.isArray(request.input) ? request.input : [request.input];
+    const response = await this.client.embeddings.create({ model, input });
+    return {
+      embeddings: response.data.map((d) => d.embedding),
+      model: response.model,
+      provider: this.name
+    };
+  }
+};
+
+// ../provider-openai/src/index.ts
+registerProvider("openai", (config) => {
+  if (!config.apiKey) {
+    throw new Error(`Provider "${config.name}" (openai) requires OPENAI_API_KEY to be set in the environment.`);
+  }
+  return new OpenAIProvider({
+    apiKey: config.apiKey,
+    defaultModel: config.defaultModel,
+    baseUrl: config.baseUrl,
+    name: config.name
+  });
+});
+registerProvider("copilot", (config) => {
+  if (!config.apiKey) {
+    throw new Error(`Provider "${config.name}" (copilot) requires GITHUB_TOKEN to be set in the environment.`);
+  }
+  return new OpenAIProvider({
+    apiKey: config.apiKey,
+    defaultModel: config.defaultModel ?? "gpt-4o",
+    baseUrl: config.baseUrl ?? "https://api.githubcopilot.com",
+    name: config.name
+  });
+});
+registerProvider("groq", (config) => {
+  if (!config.apiKey) {
+    throw new Error(`Provider "${config.name}" (groq) requires GROQ_API_KEY to be set in the environment.`);
+  }
+  return new OpenAIProvider({
+    apiKey: config.apiKey,
+    defaultModel: config.defaultModel ?? "llama-3.3-70b-versatile",
+    baseUrl: config.baseUrl ?? "https://api.groq.com/openai/v1",
+    name: config.name
+  });
+});
+registerProvider("ollama", (config) => {
+  return new OpenAIProvider({
+    // Ollama does not require an API key; use a placeholder so the SDK does not complain
+    apiKey: config.apiKey ?? "ollama",
+    defaultModel: config.defaultModel ?? "llama3.2",
+    baseUrl: config.baseUrl ?? "http://localhost:11434/v1",
+    name: config.name
+  });
+});
+
+export {
+  OpenAIProvider
+};