@ftarganski/omni-ai 0.1.0

package/dist/chunk-6YFFZMXY.js

@@ -0,0 +1,104 @@
+// ../skills/src/http/http-request.ts
+import { z } from "zod";
+var BearerAuthSchema = z.object({
+  type: z.literal("bearer"),
+  token: z.string().describe("Bearer token value")
+});
+var BasicAuthSchema = z.object({
+  type: z.literal("basic"),
+  username: z.string(),
+  password: z.string()
+});
+var OAuth2ClientSchema = z.object({
+  type: z.literal("oauth2-client-credentials"),
+  tokenUrl: z.string().url().describe("Token endpoint URL"),
+  clientId: z.string(),
+  clientSecret: z.string(),
+  scope: z.string().optional().describe("Space-separated OAuth2 scopes")
+});
+var AuthSchema = z.discriminatedUnion("type", [BearerAuthSchema, BasicAuthSchema, OAuth2ClientSchema]);
+var InputSchema = z.object({
+  url: z.string().url().describe("Target URL"),
+  method: z.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD"]).default("GET").describe("HTTP method"),
+  headers: z.record(z.string()).optional().describe("Additional request headers"),
+  body: z.union([z.string(), z.record(z.unknown())]).optional().describe("Request body \u2014 string or JSON object"),
+  auth: AuthSchema.optional().describe("Authentication configuration"),
+  timeoutMs: z.number().int().positive().default(3e4).describe("Request timeout in milliseconds")
+});
+async function resolveToken(auth) {
+  if (auth.type === "bearer") return `Bearer ${auth.token}`;
+  if (auth.type === "basic") {
+    const encoded = Buffer.from(`${auth.username}:${auth.password}`).toString("base64");
+    return `Basic ${encoded}`;
+  }
+  const params = new URLSearchParams({
+    grant_type: "client_credentials",
+    client_id: auth.clientId,
+    client_secret: auth.clientSecret
+  });
+  if (auth.scope) params.set("scope", auth.scope);
+  const tokenRes = await fetch(auth.tokenUrl, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: params.toString()
+  });
+  if (!tokenRes.ok) {
+    throw new Error(`OAuth2 token request failed: ${tokenRes.status} ${tokenRes.statusText}`);
+  }
+  const json = await tokenRes.json();
+  if (!json.access_token) throw new Error("OAuth2 response did not include access_token");
+  const tokenType = json.token_type ?? "Bearer";
+  return `${tokenType} ${json.access_token}`;
+}
+var httpRequestSkill = {
+  name: "http-request",
+  description: "Make an authenticated HTTP request to any URL. Supports Bearer token, HTTP Basic, and OAuth2 client-credentials flows. Returns status, headers and body. Use this to call external REST APIs from an agent.",
+  async execute(input) {
+    const { url, method, headers: extraHeaders, body, auth, timeoutMs } = InputSchema.parse(input);
+    const headers = {
+      Accept: "application/json",
+      ...extraHeaders
+    };
+    if (auth) {
+      headers.Authorization = await resolveToken(auth);
+    }
+    let bodyStr;
+    if (body !== void 0) {
+      if (typeof body === "string") {
+        bodyStr = body;
+      } else {
+        bodyStr = JSON.stringify(body);
+        headers["Content-Type"] ??= "application/json";
+      }
+    }
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    let response;
+    try {
+      response = await fetch(url, {
+        method,
+        headers,
+        body: bodyStr,
+        signal: controller.signal
+      });
+    } finally {
+      clearTimeout(timer);
+    }
+    const responseHeaders = {};
+    response.headers.forEach((value, key) => {
+      responseHeaders[key] = value;
+    });
+    const responseBody = await response.text();
+    return {
+      status: response.status,
+      statusText: response.statusText,
+      headers: responseHeaders,
+      body: responseBody,
+      ok: response.ok
+    };
+  }
+};
+
+export {
+  httpRequestSkill
+};

package/dist/chunk-AG6NZIJ3.js

@@ -0,0 +1,122 @@
+#!/usr/bin/env node
+import {
+  registerProvider
+} from "./chunk-AWMSN7OB.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/chunk-AWMSN7OB.js

@@ -0,0 +1,451 @@
+#!/usr/bin/env node
+
+// ../core/src/providers/fallback.ts
+var FallbackProvider = class {
+  name;
+  capabilities;
+  providers;
+  constructor(providers) {
+    if (providers.length === 0) throw new Error("FallbackProvider requires at least one provider");
+    this.providers = providers;
+    this.name = providers.map((p) => p.name).join("|");
+    this.capabilities = providers.reduce(
+      (acc, p) => ({
+        chat: acc.chat || p.capabilities.chat,
+        embedding: acc.embedding || p.capabilities.embedding,
+        streaming: acc.streaming || p.capabilities.streaming,
+        toolUse: acc.toolUse || p.capabilities.toolUse,
+        vision: acc.vision || p.capabilities.vision
+      }),
+      { chat: false, embedding: false, streaming: false, toolUse: false, vision: false }
+    );
+  }
+  async complete(request) {
+    const errors = [];
+    for (const provider of this.providers) {
+      try {
+        return await provider.complete(request);
+      } catch (err) {
+        errors.push(err instanceof Error ? err : new Error(String(err)));
+      }
+    }
+    throw new Error(
+      `All providers failed:
+${errors.map((e, i) => `  [${this.providers[i].name}] ${e.message}`).join("\n")}`
+    );
+  }
+  async embed(request) {
+    const errors = [];
+    for (const provider of this.providers) {
+      if (!provider.embed) continue;
+      try {
+        return await provider.embed(request);
+      } catch (err) {
+        errors.push(err instanceof Error ? err : new Error(String(err)));
+      }
+    }
+    if (errors.length === 0) throw new Error(`No provider in "${this.name}" supports embeddings`);
+    throw new Error(
+      `All providers failed for embed:
+${errors.map((e, i) => `  [${this.providers[i].name}] ${e.message}`).join("\n")}`
+    );
+  }
+};
+
+// ../core/src/providers/retry.ts
+function isRetryable(err) {
+  if (!(err instanceof Error)) return false;
+  const msg = err.message.toLowerCase();
+  return msg.includes("429") || msg.includes("rate limit") || msg.includes("too many requests") || msg.includes("500") || msg.includes("502") || msg.includes("503") || msg.includes("504") || msg.includes("econnreset") || msg.includes("etimedout") || msg.includes("enotfound");
+}
+function delay(ms) {
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
+}
+var RetryProvider = class {
+  name;
+  capabilities;
+  inner;
+  maxRetries;
+  initialDelayMs;
+  maxDelayMs;
+  constructor(inner, options = {}) {
+    this.inner = inner;
+    this.name = inner.name;
+    this.capabilities = inner.capabilities;
+    this.maxRetries = options.maxRetries ?? 3;
+    this.initialDelayMs = options.initialDelayMs ?? 500;
+    this.maxDelayMs = options.maxDelayMs ?? 3e4;
+  }
+  async complete(request) {
+    return this.withRetry(() => this.inner.complete(request));
+  }
+  async embed(request) {
+    const embedFn = this.inner.embed;
+    if (!embedFn) throw new Error(`Provider "${this.name}" does not support embeddings`);
+    return this.withRetry(() => embedFn.call(this.inner, request));
+  }
+  async withRetry(fn) {
+    let attempt = 0;
+    while (true) {
+      try {
+        return await fn();
+      } catch (err) {
+        attempt++;
+        if (attempt > this.maxRetries || !isRetryable(err)) throw err;
+        const base = this.initialDelayMs * 2 ** (attempt - 1);
+        const jitter = Math.random() * base * 0.2;
+        const wait = Math.min(base + jitter, this.maxDelayMs);
+        await delay(wait);
+      }
+    }
+  }
+};
+
+// ../core/src/providers/registry.ts
+var factories = /* @__PURE__ */ new Map();
+function registerProvider(type, factory) {
+  factories.set(type, factory);
+}
+function createProvider(config) {
+  const factory = factories.get(config.type);
+  if (!factory) {
+    throw new Error(`Unknown provider type "${config.type}". Registered: ${[...factories.keys()].join(", ")}`);
+  }
+  return factory(config);
+}
+function buildProvider(cfg, allConfigs) {
+  let provider = createProvider(cfg);
+  if (cfg.retry) {
+    provider = new RetryProvider(provider, cfg.retry);
+  }
+  if (cfg.fallback) {
+    const fallbackCfg = allConfigs.find((p) => p.name === cfg.fallback);
+    if (!fallbackCfg) {
+      throw new Error(`Fallback provider "${cfg.fallback}" not found in config for provider "${cfg.name}"`);
+    }
+    let fallbackProvider = createProvider(fallbackCfg);
+    if (fallbackCfg.retry) {
+      fallbackProvider = new RetryProvider(fallbackProvider, fallbackCfg.retry);
+    }
+    provider = new FallbackProvider([provider, fallbackProvider]);
+  }
+  return provider;
+}
+function getRegisteredProviders() {
+  return [...factories.keys()];
+}
+
+// ../core/src/middleware/compose.ts
+function composeMiddleware(fns, skill) {
+  if (fns.length === 0) return skill;
+  return {
+    name: skill.name,
+    description: skill.description,
+    execute(input, ctx) {
+      let index = 0;
+      const dispatch = () => {
+        if (index < fns.length) {
+          const fn = fns[index++];
+          return fn(skill.name, input, ctx, dispatch);
+        }
+        return skill.execute(input, ctx);
+      };
+      return dispatch();
+    }
+  };
+}
+
+// ../core/src/types.ts
+function contentToString(content) {
+  if (typeof content === "string") return content;
+  return content.map((p) => p.type === "text" ? p.text : `[image:${p.mimeType}]`).join("");
+}
+
+// ../core/src/agents/agent.ts
+var Agent = class {
+  config;
+  provider;
+  skills;
+  constructor(config, provider, skills = []) {
+    this.config = config;
+    this.provider = provider;
+    this.skills = new Map(skills.map((s) => [s.name, s]));
+  }
+  async run(options) {
+    const memCfg = this.config.memory;
+    const session = options.session;
+    const store = memCfg?.store;
+    const compactor = memCfg?.compactor;
+    const maxCtxTokens = memCfg?.maxContextTokens ?? 8e4;
+    const history = session && store ? (await store.loadMessages(session)).map((e) => ({ role: e.role, content: e.content })) : [];
+    const messages = [...history];
+    const newMessages = [];
+    const firstMsg = { role: "user", content: options.input };
+    messages.push(firstMsg);
+    newMessages.push(firstMsg);
+    const tools = this.buildToolDefinitions();
+    const ctx = { provider: this.provider, config: options.context ?? {} };
+    const maxIterations = this.config.maxIterations ?? 10;
+    let iterations = 0;
+    let totalInput = 0;
+    let totalOutput = 0;
+    while (iterations < maxIterations) {
+      iterations++;
+      if (compactor?.shouldCompact(messages, maxCtxTokens)) {
+        const compacted = await compactor.compact(messages, this.provider);
+        messages.splice(0, messages.length, ...compacted);
+      }
+      const response = await this.provider.complete({
+        messages,
+        model: this.config.model,
+        systemPrompt: this.config.systemPrompt,
+        temperature: this.config.temperature,
+        tools: tools.length > 0 ? tools : void 0,
+        onToken: options.onToken
+      });
+      if (response.usage) {
+        totalInput += response.usage.inputTokens;
+        totalOutput += response.usage.outputTokens;
+      }
+      if (!response.toolCalls || response.toolCalls.length === 0) {
+        const finalMsg = { role: "assistant", content: response.content };
+        messages.push(finalMsg);
+        newMessages.push(finalMsg);
+        await this.persist(store, session, newMessages);
+        return {
+          output: response.content,
+          iterations,
+          usage: { inputTokens: totalInput, outputTokens: totalOutput }
+        };
+      }
+      const assistantMsg = { role: "assistant", content: response.content };
+      messages.push(assistantMsg);
+      newMessages.push(assistantMsg);
+      for (const call of response.toolCalls) {
+        const result = await this.executeToolCall(call, ctx);
+        const toolMsg = { role: "user", content: `[Tool ${call.name} result]: ${result}` };
+        messages.push(toolMsg);
+        newMessages.push(toolMsg);
+      }
+    }
+    await this.persist(store, session, newMessages);
+    throw new Error(`Agent "${this.config.name}" exceeded maxIterations (${maxIterations})`);
+  }
+  async persist(store, session, messages) {
+    if (!store || !session || messages.length === 0) return;
+    const entries = messages.map((m) => ({
+      role: m.role,
+      content: contentToString(m.content),
+      timestamp: Date.now()
+    }));
+    await store.saveMessages(session, entries);
+  }
+  buildToolDefinitions() {
+    return [...this.skills.values()].map((skill) => ({
+      name: skill.name,
+      description: skill.description,
+      parameters: { type: "object", properties: {}, additionalProperties: true }
+    }));
+  }
+  async executeToolCall(call, ctx) {
+    const skill = this.skills.get(call.name);
+    if (!skill) return `Error: skill "${call.name}" not found`;
+    try {
+      const middleware = this.config.middleware ?? [];
+      const wrapped = composeMiddleware(middleware, skill);
+      const result = await wrapped.execute(call.arguments, ctx);
+      return typeof result === "string" ? result : JSON.stringify(result);
+    } catch (err) {
+      return `Error: ${err instanceof Error ? err.message : String(err)}`;
+    }
+  }
+};
+
+// ../core/src/agents/loader.ts
+import { readFile } from "fs/promises";
+import YAML from "yaml";
+
+// ../core/src/config/schema.ts
+import { z } from "zod";
+var RetryConfigSchema = z.object({
+  maxRetries: z.number().int().positive().default(3),
+  initialDelayMs: z.number().int().positive().default(500),
+  maxDelayMs: z.number().int().positive().default(3e4)
+});
+var ProviderConfigSchema = z.object({
+  name: z.string(),
+  type: z.enum(["anthropic", "openai", "copilot", "google", "groq", "ollama", "custom"]),
+  // nullish handles YAML empty value (parsed as null) and absent key (undefined)
+  apiKey: z.string().nullish().transform((v) => v ?? void 0),
+  baseUrl: z.string().url().nullish().transform((v) => v ?? void 0),
+  defaultModel: z.string().nullish().transform((v) => v ?? void 0),
+  options: z.record(z.unknown()).optional(),
+  retry: RetryConfigSchema.optional(),
+  fallback: z.string().optional()
+});
+var AgentConfigSchema = z.object({
+  name: z.string(),
+  description: z.string(),
+  provider: z.string().optional(),
+  model: z.string().optional(),
+  systemPrompt: z.string(),
+  skills: z.array(z.string()).optional(),
+  maxIterations: z.number().int().positive().default(10),
+  temperature: z.number().min(0).max(2).optional()
+});
+var ScaffoldPathsSchema = z.object({
+  agents: z.string().default("agents"),
+  skills: z.string().default("src/skills"),
+  providers: z.string().default("packages")
+});
+var OmniAiConfigSchema = z.object({
+  version: z.string().default("1"),
+  providers: z.array(ProviderConfigSchema).min(1, "At least one provider must be configured"),
+  defaultProvider: z.string(),
+  agentsDir: z.string().default("agents"),
+  scaffoldPaths: ScaffoldPathsSchema.optional(),
+  agents: z.array(AgentConfigSchema).optional()
+});
+
+// ../core/src/agents/loader.ts
+async function loadAgent(yamlPath, config, skills) {
+  const raw = await readFile(yamlPath, "utf-8");
+  const data = YAML.parse(raw);
+  const agentConfig = AgentConfigSchema.parse(data);
+  const providerName = agentConfig.provider ?? config.defaultProvider;
+  const providerConfig = config.providers.find((p) => p.name === providerName);
+  if (!providerConfig) {
+    throw new Error(
+      `Provider "${providerName}" not found in config. Available: ${config.providers.map((p) => p.name).join(", ")}`
+    );
+  }
+  const provider = buildProvider(providerConfig, config.providers);
+  const resolvedSkills = (agentConfig.skills ?? []).map((name) => skills.get(name));
+  return new Agent(agentConfig, provider, resolvedSkills);
+}
+
+// ../core/src/bootstrap.ts
+import { readFile as readFile3 } from "fs/promises";
+import { dirname, resolve as resolve2 } from "path";
+import { glob } from "glob";
+import YAML3 from "yaml";
+
+// ../core/src/config/loader.ts
+import { readFile as readFile2 } from "fs/promises";
+import { resolve } from "path";
+import YAML2 from "yaml";
+import { ZodError } from "zod";
+function substituteEnvVars(text) {
+  return text.replace(/\$\{([^}]+)\}/g, (_, name) => process.env[name] ?? "");
+}
+function formatZodError(err) {
+  const lines = err.errors.map((e) => `  \u2022 ${e.path.join(".")}: ${e.message}`);
+  return `Invalid omni-ai.yaml configuration:
+${lines.join("\n")}`;
+}
+async function loadConfig(configPath) {
+  const filePath = configPath ?? resolve(process.cwd(), "config", "omni-ai.yaml");
+  const raw = await readFile2(filePath, "utf-8");
+  const substituted = substituteEnvVars(raw);
+  const data = YAML2.parse(substituted);
+  try {
+    return OmniAiConfigSchema.parse(data);
+  } catch (err) {
+    if (err instanceof ZodError) {
+      throw new Error(formatZodError(err));
+    }
+    throw err;
+  }
+}
+
+// ../core/src/skills/registry.ts
+var SkillRegistry = class {
+  skills = /* @__PURE__ */ new Map();
+  register(skill) {
+    this.skills.set(skill.name, skill);
+    return this;
+  }
+  get(name) {
+    const skill = this.skills.get(name);
+    if (!skill) {
+      throw new Error(`Skill "${name}" not found. Available: ${[...this.skills.keys()].join(", ")}`);
+    }
+    return skill;
+  }
+  all() {
+    return [...this.skills.values()];
+  }
+};
+
+// ../core/src/bootstrap.ts
+async function createRuntime(options) {
+  const config = await loadConfig(options?.configPath);
+  const skills = new SkillRegistry();
+  for (const skill of options?.skills ?? []) {
+    skills.register(skill);
+  }
+  const configDir = options?.configPath ? dirname(resolve2(options.configPath)) : resolve2(process.cwd(), "config");
+  const agentsBaseDir = resolve2(configDir, "..", config.agentsDir);
+  async function resolveAgent(nameOrPath) {
+    if (nameOrPath.includes("/") || nameOrPath.endsWith(".yaml")) {
+      return loadAgent(resolve2(nameOrPath), config, skills);
+    }
+    const inlineCfg = config.agents?.find((a) => a.name === nameOrPath);
+    if (inlineCfg) {
+      const providerName = inlineCfg.provider ?? config.defaultProvider;
+      const providerConfig = config.providers.find((p) => p.name === providerName);
+      if (!providerConfig) {
+        throw new Error(`Provider "${providerName}" not found in config for agent "${nameOrPath}"`);
+      }
+      const provider = buildProvider(providerConfig, config.providers);
+      const resolvedSkills = (inlineCfg.skills ?? []).map((n) => skills.get(n));
+      return new Agent(inlineCfg, provider, resolvedSkills);
+    }
+    const files = await glob("**/*.yaml", { cwd: agentsBaseDir, absolute: true });
+    for (const file of files) {
+      const raw = await readFile3(file, "utf-8");
+      const data = YAML3.parse(raw);
+      if (data?.name === nameOrPath) return loadAgent(file, config, skills);
+    }
+    throw new Error(`Agent "${nameOrPath}" not found in ${agentsBaseDir}`);
+  }
+  return {
+    config,
+    skills,
+    async run(nameOrPath, input, opts = {}) {
+      const agent = await resolveAgent(nameOrPath);
+      if (options?.memoryStore && opts.session && !agent.config.memory?.store) {
+        agent.config.memory = {
+          ...agent.config.memory ?? {},
+          store: options.memoryStore
+        };
+      }
+      return agent.run({ ...opts, input });
+    },
+    async listAgents(agentsDir) {
+      const summaries = [];
+      for (const a of config.agents ?? []) {
+        summaries.push({ name: a.name, description: a.description, path: "(config)" });
+      }
+      const dir = agentsDir ?? agentsBaseDir;
+      const files = await glob("**/*.yaml", { cwd: dir, absolute: true });
+      for (const file of files) {
+        try {
+          const raw = await readFile3(file, "utf-8");
+          const data = YAML3.parse(raw);
+          if (data?.name && !summaries.find((s) => s.name === data.name)) {
+            summaries.push({ name: data.name, description: data.description ?? "", path: file });
+          }
+        } catch {
+        }
+      }
+      return summaries.sort((a, b) => a.name.localeCompare(b.name));
+    }
+  };
+}
+
+export {
+  registerProvider,
+  getRegisteredProviders,
+  createRuntime
+};