openbot 0.2.12 → 0.2.14

package/dist/marketplace.js

@@ -1,80 +0,0 @@
-import { installAgentFromSource, installPluginFromSource } from "./installers.js";
-const DEFAULT_MARKETPLACE_REGISTRY_URL = "https://raw.githubusercontent.com/meetopenbot/openbot-registry/main/registry.json";
-const CACHE_TTL_MS = 5 * 60 * 1000;
-let cachedRegistry = null;
-let cacheExpiresAt = 0;
-function normalizeSource(source) {
-    if (!source || typeof source !== "object") {
-        throw new Error("invalid source");
-    }
-    const value = source;
-    if ((value.type !== "github" && value.type !== "npm") || typeof value.value !== "string" || !value.value.trim()) {
-        throw new Error("invalid source");
-    }
-    return { type: value.type, value: value.value.trim() };
-}
-function normalizeItem(item) {
-    if (!item || typeof item !== "object")
-        throw new Error("invalid item");
-    const value = item;
-    if (typeof value.id !== "string" || !value.id.trim())
-        throw new Error("invalid item id");
-    if (typeof value.name !== "string" || !value.name.trim())
-        throw new Error("invalid item name");
-    if (typeof value.description !== "string")
-        throw new Error("invalid item description");
-    const tags = Array.isArray(value.tags) ? value.tags.filter((tag) => typeof tag === "string") : undefined;
-    return {
-        id: value.id.trim(),
-        name: value.name.trim(),
-        description: value.description,
-        source: normalizeSource(value.source),
-        tags,
-        image: typeof value.image === "string" ? value.image.trim() : undefined,
-    };
-}
-function normalizeRegistry(value) {
-    if (!value || typeof value !== "object")
-        throw new Error("invalid registry");
-    const raw = value;
-    if (typeof raw.version !== "number")
-        throw new Error("invalid version");
-    const agents = Array.isArray(raw.agents) ? raw.agents.map(normalizeItem) : [];
-    const plugins = Array.isArray(raw.plugins) ? raw.plugins.map(normalizeItem) : [];
-    return { version: raw.version, agents, plugins };
-}
-export async function getMarketplaceRegistry(forceRefresh = false) {
-    const now = Date.now();
-    if (!forceRefresh && cachedRegistry && now < cacheExpiresAt) {
-        return cachedRegistry;
-    }
-    const registryUrl = process.env.OPENBOT_MARKETPLACE_REGISTRY_URL || DEFAULT_MARKETPLACE_REGISTRY_URL;
-    const response = await fetch(registryUrl);
-    if (!response.ok) {
-        throw new Error(`Failed to fetch marketplace registry (${response.status})`);
-    }
-    const json = await response.json();
-    const normalized = normalizeRegistry(json);
-    cachedRegistry = normalized;
-    cacheExpiresAt = now + CACHE_TTL_MS;
-    return normalized;
-}
-export async function installMarketplaceAgent(agentId) {
-    const registry = await getMarketplaceRegistry(true);
-    const agent = registry.agents.find((entry) => entry.id === agentId);
-    if (!agent)
-        throw new Error(`Agent "${agentId}" was not found in marketplace`);
-    if (agent.source.type !== "github") {
-        throw new Error(`Marketplace agent "${agentId}" has unsupported source type "${agent.source.type}"`);
-    }
-    const installedName = await installAgentFromSource({ type: "github", value: agent.source.value }, { id: agent.id });
-    return { installedName, agent };
-}
-export async function installMarketplacePlugin(pluginId) {
-    const registry = await getMarketplaceRegistry(true);
-    const plugin = registry.plugins.find((entry) => entry.id === pluginId);
-    if (!plugin)
-        throw new Error(`Plugin "${pluginId}" was not found in marketplace`);
-    const installedName = await installPluginFromSource(plugin.source, { id: plugin.id });
-    return { installedName, plugin };
-}

package/dist/model-catalog.js

@@ -1,132 +0,0 @@
-import { loadConfig } from "./config.js";
-import { FALLBACK_MODELS } from "./model-defaults.js";
-const CACHE_TTL_MS = 5 * 60 * 1000;
-let cachedCatalog = null;
-let cachedAt = 0;
-let cachedFingerprint = "";
-function keyFingerprint(value) {
-    if (!value)
-        return "none";
-    const trimmed = value.trim();
-    if (!trimmed)
-        return "none";
-    return `${trimmed.slice(0, 4)}:${trimmed.length}`;
-}
-function buildFingerprint(input) {
-    return [
-        `openai=${keyFingerprint(input.openaiApiKey)}`,
-        `anthropic=${keyFingerprint(input.anthropicApiKey)}`,
-        `model=${input.model ?? ""}`,
-    ].join("|");
-}
-function titleCaseModel(raw) {
-    return raw
-        .split("-")
-        .map((part) => (part ? part[0].toUpperCase() + part.slice(1) : part))
-        .join(" ");
-}
-function toProviderModel(provider, modelId) {
-    const id = `${provider}/${modelId}`;
-    const providerLabel = provider === "openai" ? "OpenAI" : "Anthropic";
-    return { id, label: `${providerLabel} ${titleCaseModel(modelId)}` };
-}
-function dedupeModels(models) {
-    const seen = new Set();
-    const deduped = [];
-    for (const model of models) {
-        if (seen.has(model.id))
-            continue;
-        seen.add(model.id);
-        deduped.push(model);
-    }
-    return deduped;
-}
-function sortModels(models) {
-    return [...models].sort((a, b) => a.id.localeCompare(b.id));
-}
-function keepLikelyOpenAIChatModel(modelId) {
-    return /^(gpt|o[1-9]|chatgpt)/.test(modelId);
-}
-async function fetchOpenAIModels(apiKey) {
-    const res = await fetch("https://api.openai.com/v1/models", {
-        headers: {
-            Authorization: `Bearer ${apiKey}`,
-        },
-    });
-    if (!res.ok) {
-        throw new Error(`OpenAI models request failed (${res.status})`);
-    }
-    const data = await res.json();
-    const models = (data.data ?? [])
-        .map((m) => (typeof m.id === "string" ? m.id : ""))
-        .filter((id) => !!id && keepLikelyOpenAIChatModel(id))
-        .map((id) => toProviderModel("openai", id));
-    return sortModels(dedupeModels(models));
-}
-async function fetchAnthropicModels(apiKey) {
-    const res = await fetch("https://api.anthropic.com/v1/models", {
-        headers: {
-            "x-api-key": apiKey,
-            "anthropic-version": "2023-06-01",
-        },
-    });
-    if (!res.ok) {
-        throw new Error(`Anthropic models request failed (${res.status})`);
-    }
-    const data = await res.json();
-    const models = (data.data ?? [])
-        .map((m) => {
-        const modelId = typeof m.id === "string" ? m.id : "";
-        if (!modelId)
-            return null;
-        const label = typeof m.display_name === "string" && m.display_name.trim()
-            ? m.display_name.trim()
-            : toProviderModel("anthropic", modelId).label;
-        return { id: `anthropic/${modelId}`, label };
-    })
-        .filter((m) => !!m);
-    return sortModels(dedupeModels(models));
-}
-export async function fetchProviderModels(provider, apiKey) {
-    if (provider === "openai") {
-        return fetchOpenAIModels(apiKey);
-    }
-    return fetchAnthropicModels(apiKey);
-}
-export async function getModelCatalog(forceRefresh = false) {
-    const cfg = loadConfig();
-    const openaiApiKey = cfg.openaiApiKey || process.env.OPENAI_API_KEY;
-    const anthropicApiKey = cfg.anthropicApiKey || process.env.ANTHROPIC_API_KEY;
-    const now = Date.now();
-    const fingerprint = buildFingerprint({
-        openaiApiKey,
-        anthropicApiKey,
-        model: cfg.model,
-    });
-    if (!forceRefresh &&
-        cachedCatalog &&
-        now - cachedAt < CACHE_TTL_MS &&
-        cachedFingerprint === fingerprint) {
-        return cachedCatalog;
-    }
-    const providerFetches = [];
-    if (openaiApiKey) {
-        providerFetches.push(fetchOpenAIModels(openaiApiKey));
-    }
-    if (anthropicApiKey) {
-        providerFetches.push(fetchAnthropicModels(anthropicApiKey));
-    }
-    const results = await Promise.allSettled(providerFetches);
-    const fetched = results
-        .filter((r) => r.status === "fulfilled")
-        .flatMap((r) => r.value);
-    const merged = dedupeModels([...fetched, ...FALLBACK_MODELS]);
-    if (cfg.model && !merged.some((m) => m.id === cfg.model)) {
-        merged.push({ id: cfg.model, label: cfg.model });
-    }
-    const catalog = sortModels(merged);
-    cachedCatalog = catalog;
-    cachedAt = now;
-    cachedFingerprint = fingerprint;
-    return catalog;
-}

package/dist/model-defaults.js

@@ -1,25 +0,0 @@
-export const DEFAULT_MODEL_ID = "openai/gpt-5-nano";
-export const DEFAULT_MODEL_BY_PROVIDER = {
-    openai: DEFAULT_MODEL_ID,
-    anthropic: "anthropic/claude-sonnet-4-5-20250929",
-};
-export const FALLBACK_MODELS = [
-    { id: "openai/gpt-5.2", label: "OpenAI GPT-5.2" },
-    { id: "openai/gpt-5.2-chat-latest", label: "OpenAI GPT-5.2 Chat Latest" },
-    { id: "openai/gpt-5.2-pro", label: "OpenAI GPT-5.2 Pro" },
-    { id: "openai/gpt-5", label: "OpenAI GPT-5" },
-    { id: "openai/gpt-5-mini", label: "OpenAI GPT-5 Mini" },
-    { id: "openai/gpt-5-nano", label: "OpenAI GPT-5 Nano" },
-    { id: "openai/gpt-4.1", label: "OpenAI GPT-4.1" },
-    { id: "openai/gpt-4.1-mini", label: "OpenAI GPT-4.1 Mini" },
-    { id: "openai/gpt-4o", label: "OpenAI GPT-4o" },
-    { id: "openai/gpt-4o-mini", label: "OpenAI GPT-4o Mini" },
-    { id: "openai/o4-mini", label: "OpenAI o4-mini" },
-    { id: "anthropic/claude-opus-4-6", label: "Claude Opus 4.6" },
-    { id: "anthropic/claude-sonnet-4-6", label: "Claude Sonnet 4.6" },
-    { id: "anthropic/claude-opus-4-5-20251101", label: "Claude Opus 4.5" },
-    { id: "anthropic/claude-sonnet-4-5-20250929", label: "Claude Sonnet 4.5" },
-    { id: "anthropic/claude-3-7-sonnet-latest", label: "Claude 3.7 Sonnet" },
-    { id: "anthropic/claude-3-5-sonnet-latest", label: "Claude 3.5 Sonnet" },
-    { id: "anthropic/claude-3-5-haiku-latest", label: "Claude 3.5 Haiku" },
-];

package/dist/models.js

@@ -1,47 +0,0 @@
-import { openai } from "@ai-sdk/openai";
-import { anthropic } from "@ai-sdk/anthropic";
-import { loadConfig } from "./config.js";
-import { DEFAULT_MODEL_ID } from "./model-defaults.js";
-/**
- * Parse model string to extract provider and model ID
- * Supports formats: "provider/model" or just "model" (defaults to openai)
- */
-export function parseModelString(modelString) {
-    // Check for provider/model format
-    if (modelString.includes("/")) {
-        const [provider, modelId] = modelString.split("/");
-        if (provider === "openai" || provider === "anthropic") {
-            return { provider: provider, modelId };
-        }
-    }
-    // Auto-detect provider based on model name
-    if (modelString.startsWith("claude") || modelString.startsWith("claude-")) {
-        return { provider: "anthropic", modelId: modelString };
-    }
-    // Default to OpenAI
-    return { provider: "openai", modelId: modelString };
-}
-export function createModel(options) {
-    const config = loadConfig();
-    const openaiKey = options?.openaiApiKey || config.openaiApiKey || process.env.OPENAI_API_KEY;
-    const anthropicKey = options?.anthropicApiKey || config.anthropicApiKey || process.env.ANTHROPIC_API_KEY;
-    if (openaiKey) {
-        process.env.OPENAI_API_KEY = openaiKey;
-    }
-    if (anthropicKey) {
-        process.env.ANTHROPIC_API_KEY = anthropicKey;
-    }
-    const { provider, modelId } = parseModelString(options?.model || config.model || DEFAULT_MODEL_ID);
-    if (provider === "anthropic") {
-        if (!anthropicKey) {
-            console.warn("Warning: Anthropic model selected but ANTHROPIC_API_KEY is not set");
-        }
-        return anthropic(modelId);
-    }
-    else {
-        if (!openaiKey) {
-            console.warn("Warning: OpenAI model selected but OPENAI_API_KEY is not set");
-        }
-        return openai(modelId);
-    }
-}

package/dist/open-bot.js

@@ -1,51 +0,0 @@
-import { melony } from "melony";
-import { loadConfig, resolvePath, DEFAULT_BASE_DIR } from "./config.js";
-import { createModel, parseModelString } from "./models.js";
-import { DEFAULT_MODEL_ID } from "./model-defaults.js";
-import { setupPluginRegistry } from "./core/plugins.js";
-import { createManagerPlugin } from "./core/manager.js";
-import { setupDelegation } from "./core/delegation.js";
-import { runOpenBot } from "./core/router.js";
-/**
- * Create the OpenBot runtime.
- */
-export async function createOpenBot(options) {
-    const config = loadConfig();
-    const baseDir = config.baseDir || DEFAULT_BASE_DIR;
-    const resolvedBaseDir = resolvePath(baseDir);
-    const configuredModel = config.model || DEFAULT_MODEL_ID;
-    const { provider, modelId } = parseModelString(configuredModel);
-    const resolvedModelId = `${provider}/${modelId}`;
-    const model = createModel(options);
-    // 1. Setup unified registry (built-in tools + agents + community plugins)
-    const registry = await setupPluginRegistry(resolvedBaseDir, model, options);
-    // 2. Initialize agent runtimes
-    const agentRuntimes = new Map();
-    for (const agent of registry.getAgents()) {
-        const builder = melony();
-        builder.use(agent.plugin);
-        agentRuntimes.set(agent.id, builder.build());
-    }
-    // 3. Initialize manager runtime
-    const managerBuilder = melony();
-    managerBuilder.use(createManagerPlugin(model, resolvedModelId, resolvedBaseDir, registry));
-    // 4. Setup delegation
-    setupDelegation(managerBuilder, agentRuntimes);
-    const managerRuntime = managerBuilder.build();
-    // 5. Trigger initialization for all runtimes
-    const initPromises = [];
-    const exhaust = async (runtime) => {
-        const iterator = runtime.run({ type: "init" }, { runId: "init", state: {} });
-        for await (const _ of iterator) { /* side-effects only */ }
-    };
-    for (const agentRuntime of agentRuntimes.values()) {
-        initPromises.push(exhaust(agentRuntime));
-    }
-    initPromises.push(exhaust(managerRuntime));
-    await Promise.all(initPromises);
-    // 6. Return the runtime
-    return {
-        registry,
-        run: (event, context) => runOpenBot(event, context, managerRuntime, agentRuntimes, registry),
-    };
-}

package/dist/orchestrator/direct-invocation.js

@@ -1,13 +0,0 @@
-export function parseDirectAgentInvocation(content, hasAgent) {
-    const trimmed = content.trim();
-    if (!trimmed || (!trimmed.startsWith("/") && !trimmed.startsWith("@"))) {
-        return undefined;
-    }
-    const firstSpace = trimmed.indexOf(" ");
-    const agentName = firstSpace === -1 ? trimmed.slice(1) : trimmed.slice(1, firstSpace);
-    if (!hasAgent(agentName)) {
-        return undefined;
-    }
-    const task = firstSpace === -1 ? "" : trimmed.slice(firstSpace + 1).trim();
-    return { agentName, task };
-}

package/dist/orchestrator/events.js

@@ -1,36 +0,0 @@
-const AGENT_TEXT_TYPES = new Set(["assistant:text-delta", "assistant:text"]);
-export function isAgentTextEvent(event) {
-    return AGENT_TEXT_TYPES.has(event.type);
-}
-export function isApprovalEvent(event) {
-    return event.type === "action:approve" || event.type === "action:deny";
-}
-export function makeManagerInputEvent(data) {
-    return { type: "manager:input", data };
-}
-export function makeManagerResultEvent(options) {
-    const { action = "delegateTask", toolCallId, result } = options;
-    return {
-        type: "manager:result",
-        data: { action, toolCallId, result },
-    };
-}
-export function makeAgentInputEvent(agentName, task) {
-    return {
-        type: `agent:${agentName}:input`,
-        data: { content: task },
-    };
-}
-export function makeAgentResultType(agentName) {
-    return `agent:${agentName}:result`;
-}
-export function makeAgentOutputType(agentName) {
-    return `agent:${agentName}:output`;
-}
-export function makeAssistantTextEvent(content, agentName) {
-    return {
-        type: "assistant:text",
-        data: { content },
-        meta: { agent: agentName },
-    };
-}

package/dist/orchestrator/state.js

@@ -1,54 +0,0 @@
-let pendingTaskCounter = 0;
-export function getAgentState(sessionState, agentName) {
-    if (!sessionState.agentStates) {
-        sessionState.agentStates = {};
-    }
-    if (!sessionState.agentStates[agentName]) {
-        sessionState.agentStates[agentName] = {};
-    }
-    const agentState = sessionState.agentStates[agentName];
-    if (!agentState.cwd) {
-        agentState.cwd = sessionState.cwd;
-    }
-    return agentState;
-}
-export function addPendingAgentTask(state, agentName, toolCallId) {
-    if (!state.pendingAgentTasks) {
-        state.pendingAgentTasks = {};
-    }
-    const taskKey = toolCallId ?? `pending_${Date.now()}_${pendingTaskCounter++}`;
-    state.pendingAgentTasks[taskKey] = { agentName, toolCallId };
-    return taskKey;
-}
-export function removePendingAgentTask(state, taskKey) {
-    if (!state.pendingAgentTasks) {
-        return;
-    }
-    delete state.pendingAgentTasks[taskKey];
-}
-export function findPendingTaskByToolCallId(state, toolCallId) {
-    if (!toolCallId || !state.pendingAgentTasks) {
-        return undefined;
-    }
-    const task = state.pendingAgentTasks[toolCallId];
-    if (task) {
-        return { key: toolCallId, toolCallId: task.toolCallId };
-    }
-    for (const [key, pendingTask] of Object.entries(state.pendingAgentTasks)) {
-        if (pendingTask.toolCallId === toolCallId) {
-            return { key, toolCallId: pendingTask.toolCallId };
-        }
-    }
-    return undefined;
-}
-export function findPendingTaskByAgent(state, agentName) {
-    if (!state.pendingAgentTasks) {
-        return undefined;
-    }
-    for (const [key, pendingTask] of Object.entries(state.pendingAgentTasks)) {
-        if (pendingTask.agentName === agentName) {
-            return { key, toolCallId: pendingTask.toolCallId };
-        }
-    }
-    return undefined;
-}