@ftarganski/omni-ai 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+export * from '@omni-ai/core';
+import '@omni-ai/skills';
+import '@omni-ai/skills/fs';
+import '@omni-ai/skills/code';
+import '@omni-ai/skills/ux';
+import '@omni-ai/skills/git';
+import '@omni-ai/skills/http';
+import '@omni-ai/skills/multimodal';
+import '@omni-ai/skills/backend';
+import '@omni-ai/skills/frontend';
+import '@omni-ai/skills/qa';
+import '@omni-ai/memory';
+import '@omni-ai/mcp';
+import '@omni-ai/provider-anthropic';
+import '@omni-ai/provider-openai';
+import '@omni-ai/provider-google';

package/dist/index.js

@@ -0,0 +1,42 @@
+import {
+  Agent,
+  AgentConfigSchema,
+  FallbackProvider,
+  OmniAiConfigSchema,
+  ProviderConfigSchema,
+  RetryConfigSchema,
+  RetryProvider,
+  ScaffoldPathsSchema,
+  SkillRegistry,
+  buildProvider,
+  composeMiddleware,
+  contentToString,
+  createProvider,
+  createRuntime,
+  getRegisteredProviders,
+  loadAgent,
+  loadConfig,
+  parallel,
+  registerProvider
+} from "./chunk-6APAA6WD.js";
+export {
+  Agent,
+  AgentConfigSchema,
+  FallbackProvider,
+  OmniAiConfigSchema,
+  ProviderConfigSchema,
+  RetryConfigSchema,
+  RetryProvider,
+  ScaffoldPathsSchema,
+  SkillRegistry,
+  buildProvider,
+  composeMiddleware,
+  contentToString,
+  createProvider,
+  createRuntime,
+  getRegisteredProviders,
+  loadAgent,
+  loadConfig,
+  parallel,
+  registerProvider
+};

package/dist/mcp.d.ts

@@ -0,0 +1 @@
+export * from '@omni-ai/mcp';

package/dist/mcp.js

@@ -0,0 +1,86 @@
+// ../mcp/src/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+var stubProvider = {
+  name: "mcp-stub",
+  capabilities: {},
+  complete: () => {
+    throw new Error("Provider not available in MCP server context");
+  }
+};
+function createMcpServer(skills, options) {
+  const server = new McpServer({
+    name: options?.name ?? "omni-ai",
+    version: options?.version ?? "0.1.0"
+  });
+  const ctx = {
+    provider: options?.ctx?.provider ?? stubProvider,
+    config: options?.ctx?.config ?? {}
+  };
+  for (const skill of skills) {
+    server.registerTool(
+      skill.name,
+      { description: skill.description, inputSchema: z.record(z.unknown()) },
+      async (args) => {
+        try {
+          const result = await skill.execute(args, ctx);
+          const text = typeof result === "string" ? result : JSON.stringify(result);
+          return { content: [{ type: "text", text }] };
+        } catch (err) {
+          return {
+            content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }],
+            isError: true
+          };
+        }
+      }
+    );
+  }
+  return server;
+}
+async function serveMcp(skills, transport, options) {
+  const server = createMcpServer(skills, options);
+  await server.connect(transport);
+  return server;
+}
+async function serveStdioMcp(skills, options) {
+  const transport = new StdioServerTransport();
+  return serveMcp(skills, transport, options);
+}
+
+// ../mcp/src/skill.ts
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+var McpSkill = class {
+  name;
+  description;
+  client;
+  constructor(name, description, client) {
+    this.name = name;
+    this.description = description;
+    this.client = client;
+  }
+  async execute(input, _ctx) {
+    const args = typeof input === "object" && input !== null ? input : { input };
+    const result = await this.client.callTool({ name: this.name, arguments: args });
+    const content = result.content;
+    const first = content?.[0];
+    if (first?.type === "text") return first.text;
+    return JSON.stringify(content);
+  }
+};
+async function connectMcpSkills(transport, options) {
+  const client = new Client({
+    name: options?.name ?? "omni-ai-client",
+    version: options?.version ?? "0.1.0"
+  });
+  await client.connect(transport);
+  const { tools } = await client.listTools();
+  return tools.map((t) => new McpSkill(t.name, t.description ?? "", client));
+}
+export {
+  McpSkill,
+  connectMcpSkills,
+  createMcpServer,
+  serveMcp,
+  serveStdioMcp
+};

package/dist/memory.d.ts

@@ -0,0 +1 @@
+export * from '@omni-ai/memory';

package/dist/memory.js

@@ -0,0 +1,320 @@
+import {
+  contentToString
+} from "./chunk-6APAA6WD.js";
+
+// ../memory/src/utils.ts
+function estimateTokens(messages) {
+  return messages.reduce((sum, m) => sum + Math.ceil(contentToString(m.content).length / 4), 0);
+}
+
+// ../memory/src/compactors/observation-masking.ts
+var TOOL_RESULT_PREFIX = "[Tool ";
+function isToolResult(msg) {
+  return msg.role === "user" && contentToString(msg.content).startsWith(TOOL_RESULT_PREFIX);
+}
+var ObservationMaskingCompactor = class {
+  threshold;
+  lastMessages;
+  /**
+   * @param threshold Fraction of maxTokens at which to trigger. Default: 0.7
+   * @param lastMessages Number of recent messages to keep verbatim. Default: 6
+   */
+  constructor(threshold = 0.7, lastMessages = 6) {
+    this.threshold = threshold;
+    this.lastMessages = lastMessages;
+  }
+  shouldCompact(messages, maxTokens) {
+    return estimateTokens(messages) > maxTokens * this.threshold;
+  }
+  async compact(messages, _provider) {
+    if (messages.length <= this.lastMessages) return messages;
+    const cutoff = messages.length - this.lastMessages;
+    return messages.map((msg, i) => {
+      if (i >= cutoff || !isToolResult(msg)) return msg;
+      const str = contentToString(msg.content);
+      const tokenCount = Math.ceil(str.length / 4);
+      const match = /^\[Tool ([^\]]+) result\]:/.exec(str);
+      const toolName = match?.[1] ?? "unknown";
+      return {
+        role: msg.role,
+        content: `[Tool ${toolName} result: masked, ~${tokenCount} tokens]`
+      };
+    });
+  }
+};
+
+// ../memory/src/compactors/summary.ts
+function formatForSummary(messages) {
+  return messages.map((m) => {
+    const label = m.role === "assistant" ? "Assistant" : "User/Tool";
+    return `[${label}]: ${contentToString(m.content)}`;
+  }).join("\n\n");
+}
+var SummaryCompactor = class {
+  threshold;
+  lastMessages;
+  /**
+   * @param threshold Fraction of maxTokens at which to trigger. Default: 0.7
+   * @param lastMessages Number of recent messages to keep verbatim. Default: 6
+   */
+  constructor(threshold = 0.7, lastMessages = 6) {
+    this.threshold = threshold;
+    this.lastMessages = lastMessages;
+  }
+  shouldCompact(messages, maxTokens) {
+    return estimateTokens(messages) > maxTokens * this.threshold;
+  }
+  async compact(messages, provider) {
+    if (messages.length <= this.lastMessages) return messages;
+    const cutoff = messages.length - this.lastMessages;
+    const toSummarize = messages.slice(0, cutoff);
+    const toKeep = messages.slice(cutoff);
+    const summaryResponse = await provider.complete({
+      messages: [
+        {
+          role: "user",
+          content: [
+            "Summarize the following conversation history concisely.",
+            "Preserve: decisions made, key facts found, files read, errors encountered, and current task state.",
+            "Omit: raw file contents, full search results, repetitive tool outputs.",
+            "Write the summary as a compact factual paragraph or bullet list.",
+            "",
+            "--- CONVERSATION TO SUMMARIZE ---",
+            formatForSummary(toSummarize)
+          ].join("\n")
+        }
+      ],
+      systemPrompt: "You are a precise conversation summarizer. Be concise and factual.",
+      temperature: 0.1
+    });
+    const summaryMsg = {
+      role: "user",
+      content: `[Context summary \u2014 ${toSummarize.length} messages compressed]:
+${summaryResponse.content}`
+    };
+    return [summaryMsg, ...toKeep];
+  }
+};
+
+// ../memory/src/stores/in-memory.ts
+function sessionKey(session) {
+  return `${session.resourceId}:${session.threadId}`;
+}
+var InMemoryStore = class {
+  messages = /* @__PURE__ */ new Map();
+  working = /* @__PURE__ */ new Map();
+  async saveMessages(session, messages) {
+    const key = sessionKey(session);
+    const existing = this.messages.get(key) ?? [];
+    this.messages.set(key, [...existing, ...messages]);
+  }
+  async loadMessages(session, limit) {
+    const entries = this.messages.get(sessionKey(session)) ?? [];
+    return limit ? entries.slice(-limit) : entries;
+  }
+  async search(session, query, topK = 5) {
+    const entries = this.messages.get(sessionKey(session)) ?? [];
+    const q = query.toLowerCase();
+    return entries.filter((e) => e.content.toLowerCase().includes(q)).slice(-topK).map((e) => ({ content: e.content, score: 1 }));
+  }
+  async getWorkingMemory(session) {
+    return this.working.get(sessionKey(session)) ?? null;
+  }
+  async setWorkingMemory(session, content) {
+    this.working.set(sessionKey(session), content);
+  }
+};
+
+// ../memory/src/vector.ts
+function cosineSimilarity(a, b) {
+  let dot = 0;
+  let normA = 0;
+  let normB = 0;
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i] * b[i];
+    normA += a[i] * a[i];
+    normB += b[i] * b[i];
+  }
+  const denom = Math.sqrt(normA) * Math.sqrt(normB);
+  return denom === 0 ? 0 : dot / denom;
+}
+var VectorIndex = class {
+  entries = [];
+  add(id, vector) {
+    this.entries.push({ id, vector });
+  }
+  query(queryVector, topK = 5) {
+    return this.entries.map((e) => ({ id: e.id, score: cosineSimilarity(queryVector, e.vector) })).sort((a, b) => b.score - a.score).slice(0, topK);
+  }
+  remove(id) {
+    this.entries = this.entries.filter((e) => e.id !== id);
+  }
+  clear() {
+    this.entries = [];
+  }
+  get size() {
+    return this.entries.length;
+  }
+};
+
+// ../memory/src/stores/semantic-memory-store.ts
+var SemanticMemoryStore = class {
+  provider;
+  inner;
+  cache = /* @__PURE__ */ new Map();
+  constructor(provider, inner) {
+    if (!provider.embed) {
+      throw new Error(
+        `Provider "${provider.name}" does not support embeddings \u2014 use a provider with capabilities.embedding = true`
+      );
+    }
+    this.provider = provider;
+    this.inner = inner ?? new InMemoryStore();
+  }
+  async saveMessages(session, messages) {
+    await this.inner.saveMessages(session, messages);
+    const key = sessionKey2(session);
+    const cached = this.cache.get(key) ?? [];
+    for (const m of messages) {
+      try {
+        const resp = await this.provider.embed?.({ input: m.content });
+        if (resp) cached.push({ content: m.content, vector: resp.embeddings[0] });
+      } catch {
+      }
+    }
+    this.cache.set(key, cached);
+  }
+  async search(session, query, topK = 5) {
+    const key = sessionKey2(session);
+    const cached = this.cache.get(key);
+    if (!cached || cached.length === 0) {
+      return this.inner.search ? this.inner.search(session, query, topK) : [];
+    }
+    try {
+      const resp = await this.provider.embed?.({ input: query });
+      if (!resp) return this.inner.search?.(session, query, topK) ?? [];
+      const queryVector = resp.embeddings[0];
+      return cached.map((e) => ({ content: e.content, score: cosineSimilarity(queryVector, e.vector) })).sort((a, b) => b.score - a.score).slice(0, topK);
+    } catch {
+      return this.inner.search ? this.inner.search(session, query, topK) : [];
+    }
+  }
+  async loadMessages(session, limit) {
+    return this.inner.loadMessages(session, limit);
+  }
+  async getWorkingMemory(session) {
+    return this.inner.getWorkingMemory?.(session) ?? null;
+  }
+  async setWorkingMemory(session, content) {
+    return this.inner.setWorkingMemory?.(session, content);
+  }
+  async close() {
+    return this.inner.close?.();
+  }
+};
+function sessionKey2(session) {
+  return `${session.resourceId}:${session.threadId}`;
+}
+
+// ../memory/src/stores/sqlite.ts
+import Database from "better-sqlite3";
+var SQLiteMemoryStore = class {
+  db;
+  defaultLimit;
+  constructor(options = {}) {
+    const path = options.path ?? "./omni-ai-memory.db";
+    this.defaultLimit = options.defaultLimit ?? 100;
+    this.db = new Database(path);
+    this.db.pragma("journal_mode = WAL");
+    this.migrate();
+  }
+  migrate() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS messages (
+        id          INTEGER PRIMARY KEY AUTOINCREMENT,
+        resource_id TEXT    NOT NULL,
+        thread_id   TEXT    NOT NULL,
+        role        TEXT    NOT NULL,
+        content     TEXT    NOT NULL,
+        timestamp   INTEGER NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_messages_session
+        ON messages (resource_id, thread_id, id);
+
+      CREATE VIRTUAL TABLE IF NOT EXISTS messages_fts USING fts5(
+        content,
+        content='messages',
+        content_rowid='id'
+      );
+
+      CREATE TRIGGER IF NOT EXISTS messages_ai AFTER INSERT ON messages BEGIN
+        INSERT INTO messages_fts (rowid, content) VALUES (new.id, new.content);
+      END;
+
+      CREATE TABLE IF NOT EXISTS working_memory (
+        resource_id TEXT NOT NULL,
+        thread_id   TEXT NOT NULL,
+        content     TEXT NOT NULL,
+        updated_at  INTEGER NOT NULL,
+        PRIMARY KEY (resource_id, thread_id)
+      );
+    `);
+  }
+  async saveMessages(session, messages) {
+    const insert = this.db.prepare(
+      `INSERT INTO messages (resource_id, thread_id, role, content, timestamp)
+       VALUES (@resourceId, @threadId, @role, @content, @timestamp)`
+    );
+    const insertMany = this.db.transaction((entries) => {
+      for (const e of entries) {
+        insert.run({ ...session, role: e.role, content: e.content, timestamp: e.timestamp });
+      }
+    });
+    insertMany(messages);
+  }
+  async loadMessages(session, limit) {
+    const n = limit ?? this.defaultLimit;
+    const rows = this.db.prepare(
+      `SELECT role, content, timestamp FROM (
+         SELECT role, content, timestamp FROM messages
+         WHERE resource_id = ? AND thread_id = ?
+         ORDER BY id DESC LIMIT ?
+       ) ORDER BY timestamp ASC`
+    ).all(session.resourceId, session.threadId, n);
+    return rows;
+  }
+  async search(session, query, topK = 5) {
+    const rows = this.db.prepare(
+      `SELECT m.content, rank AS score
+       FROM messages_fts fts
+       JOIN messages m ON m.id = fts.rowid
+       WHERE fts.content MATCH ?
+         AND m.resource_id = ? AND m.thread_id = ?
+       ORDER BY rank LIMIT ?`
+    ).all(query, session.resourceId, session.threadId, topK);
+    return rows.map((r) => ({ content: r.content, score: r.score }));
+  }
+  async getWorkingMemory(session) {
+    const row = this.db.prepare(`SELECT content FROM working_memory WHERE resource_id = ? AND thread_id = ?`).get(session.resourceId, session.threadId);
+    return row?.content ?? null;
+  }
+  async setWorkingMemory(session, content) {
+    this.db.prepare(
+      `INSERT INTO working_memory (resource_id, thread_id, content, updated_at)
+       VALUES (?, ?, ?, ?)
+       ON CONFLICT (resource_id, thread_id) DO UPDATE SET content = excluded.content, updated_at = excluded.updated_at`
+    ).run(session.resourceId, session.threadId, content, Date.now());
+  }
+  async close() {
+    this.db.close();
+  }
+};
+export {
+  InMemoryStore,
+  ObservationMaskingCompactor,
+  SQLiteMemoryStore,
+  SemanticMemoryStore,
+  SummaryCompactor,
+  VectorIndex,
+  cosineSimilarity
+};

package/dist/provider-anthropic.d.ts

@@ -0,0 +1 @@
+export * from '@omni-ai/provider-anthropic';

package/dist/provider-anthropic.js

@@ -0,0 +1,120 @@
+import {
+  registerProvider
+} from "./chunk-6APAA6WD.js";
+
+// ../provider-anthropic/src/provider.ts
+import Anthropic from "@anthropic-ai/sdk";
+
+// ../provider-anthropic/src/mappers.ts
+function toAnthropicContentPart(part) {
+  if (part.type === "text") return { type: "text", text: part.text };
+  return {
+    type: "image",
+    source: { type: "base64", media_type: part.mimeType, data: part.data }
+  };
+}
+function toAnthropicMessages(messages) {
+  return messages.filter((m) => m.role !== "system").map((m) => ({
+    role: m.role,
+    content: typeof m.content === "string" ? m.content : m.content.map(toAnthropicContentPart)
+  }));
+}
+function toAnthropicTools(tools) {
+  return tools.map((t) => ({
+    name: t.name,
+    description: t.description,
+    input_schema: t.parameters
+  }));
+}
+function extractSystemPrompt(request) {
+  const systemMsg = request.messages.find((m) => m.role === "system");
+  const raw = request.systemPrompt ?? systemMsg?.content;
+  if (raw === void 0) return void 0;
+  return typeof raw === "string" ? raw : raw.map((p) => p.type === "text" ? p.text : "").join("");
+}
+function fromAnthropicResponse(response, providerName) {
+  let content = "";
+  const toolCalls = [];
+  for (const block of response.content) {
+    if (block.type === "text") {
+      content += block.text;
+    } else if (block.type === "tool_use") {
+      toolCalls.push({
+        id: block.id,
+        name: block.name,
+        arguments: block.input
+      });
+    }
+  }
+  return {
+    content,
+    toolCalls: toolCalls.length > 0 ? toolCalls : void 0,
+    usage: {
+      inputTokens: response.usage.input_tokens,
+      outputTokens: response.usage.output_tokens
+    },
+    model: response.model,
+    provider: providerName
+  };
+}
+
+// ../provider-anthropic/src/provider.ts
+var AnthropicProvider = class {
+  name;
+  capabilities = {
+    chat: true,
+    embedding: false,
+    streaming: true,
+    toolUse: true,
+    vision: true
+  };
+  client;
+  defaultModel;
+  constructor(options) {
+    this.name = options.name ?? "anthropic";
+    this.defaultModel = options.defaultModel ?? "claude-sonnet-4-6";
+    this.client = new Anthropic({ apiKey: options.apiKey });
+  }
+  async complete(request) {
+    const model = request.model ?? this.defaultModel;
+    if (request.temperature !== void 0 && request.temperature > 1) {
+      throw new Error(
+        `Anthropic models require temperature <= 1.0 (got ${request.temperature}). Update the agent YAML or use an OpenAI provider for higher temperature values.`
+      );
+    }
+    const system = extractSystemPrompt(request);
+    const messages = toAnthropicMessages(request.messages);
+    const tools = request.tools && request.tools.length > 0 ? toAnthropicTools(request.tools) : void 0;
+    const params = {
+      model,
+      max_tokens: request.maxTokens ?? 8096,
+      temperature: request.temperature,
+      system,
+      messages,
+      tools
+    };
+    if (request.onToken) {
+      const stream = this.client.messages.stream(params);
+      stream.on("text", request.onToken);
+      const finalMessage = await stream.finalMessage();
+      return fromAnthropicResponse(finalMessage, this.name);
+    }
+    const response = await this.client.messages.create(params);
+    return fromAnthropicResponse(response, this.name);
+  }
+};
+
+// ../provider-anthropic/src/index.ts
+registerProvider("anthropic", (config) => {
+  if (!config.apiKey) {
+    throw new Error(`Provider "${config.name}" (anthropic) requires ANTHROPIC_API_KEY to be set in the environment.`);
+  }
+  return new AnthropicProvider({
+    apiKey: config.apiKey,
+    defaultModel: config.defaultModel,
+    name: config.name
+  });
+});
+export {
+  AnthropicProvider
+};

package/dist/provider-google.d.ts

@@ -0,0 +1 @@
+export * from '@omni-ai/provider-google';