anorion 0.1.0

package/src/gateway/ws.ts

@@ -0,0 +1,75 @@
+import { logger } from '../shared/logger';
+import { eventBus, type EventName } from '../shared/events';
+
+type WsClient = { send: (data: string) => void; addEventListener: (type: string, fn: (ev: any) => void) => void; readyState: number };
+const clients = new Map<WsClient, Set<string>>();
+
+const WS_OPEN = 1;
+
+const AGENT_EVENTS: EventName[] = [
+  'agent:processing',
+  'agent:tool-call',
+  'agent:response',
+  'agent:error',
+  'agent:idle',
+];
+
+export function handleWebSocket(ws: WsClient) {
+  clients.set(ws, new Set());
+  logger.info('WebSocket client connected');
+
+  ws.addEventListener('message', (event: { data: string }) => {
+    try {
+      const msg = JSON.parse(typeof event.data === 'string' ? event.data : String(event.data));
+      logger.debug({ msg }, 'WS message received');
+
+      if (msg.type === 'subscribe') {
+        const subs = clients.get(ws);
+        if (subs) {
+          const agents = msg.agents || [];
+          for (const a of agents) subs.add(a);
+        }
+        ws.send(JSON.stringify({ type: 'subscribed', agents: msg.agents || [] }));
+      }
+
+      if (msg.type === 'unsubscribe') {
+        const subs = clients.get(ws);
+        if (subs) {
+          for (const a of msg.agents || []) subs.delete(a);
+        }
+      }
+    } catch {
+      ws.send(JSON.stringify({ type: 'error', message: 'Invalid JSON' }));
+    }
+  });
+
+  ws.addEventListener('close', () => {
+    clients.delete(ws);
+    logger.info('WebSocket client disconnected');
+  });
+}
+
+function broadcastEvent(eventName: string, data: any) {
+  const payload = JSON.stringify({ type: eventName, ...data });
+  for (const [ws, subs] of clients) {
+    if ((ws as any).readyState !== WS_OPEN) continue;
+    // If client subscribed to specific agents, filter; else send all
+    if (subs.size > 0 && data.agentId && !subs.has(data.agentId)) continue;
+    ws.send(payload);
+  }
+}
+
+// Subscribe to all agent events from the event bus
+for (const ev of AGENT_EVENTS) {
+  eventBus.on(ev, (data: any) => broadcastEvent(ev, data));
+}
+
+/** Broadcast a raw message to all connected WebSocket clients */
+export function broadcast(message: object) {
+  const data = JSON.stringify(message);
+  for (const ws of clients.keys()) {
+    if ((ws as any).readyState === WS_OPEN) {
+      ws.send(data);
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1,182 @@
+import { loadConfig } from './shared/config';
+import { initDatabase } from './shared/db';
+import { logger } from './shared/logger';
+import { toolRegistry } from './tools/registry';
+import { agentRegistry } from './agents/registry';
+import { sessionManager } from './agents/session';
+import { memoryManager } from './memory/store';
+import { channelRouter } from './channels/router';
+import { TelegramChannel } from './channels/telegram';
+import { WebhookChannel } from './channels/webhook';
+import app, { setApiKeys, setBridge, registerBridgeRoutes } from './gateway/server';
+import routesV2 from './gateway/routes-v2';
+import { skillManager } from './tools/skill-manager';
+import { scheduleManager } from './scheduler/cron';
+import { tokenBudget } from './shared/token-budget';
+import { auditLog } from './shared/audit';
+import { eventBus } from './shared/events';
+import { loadPipelinesFromFile, listPipelines } from './agents/pipeline';
+import { listConfiguredProviders } from './llm/providers';
+import { Federator } from './bridge/federator';
+
+import echoTool from './tools/builtin/echo';
+import shellTool from './tools/builtin/shell';
+import httpRequestTool from './tools/builtin/http-request';
+import fileReadTool from './tools/builtin/file-read';
+import fileWriteTool from './tools/builtin/file-write';
+import webSearchTool from './tools/builtin/web-search';
+import { memorySaveTool, memorySearchTool, memoryListTool } from './tools/builtin/memory';
+import { spawnAgentTool } from './agents/subagent';
+
+const builtinTools = [
+  echoTool, shellTool, httpRequestTool, fileReadTool, fileWriteTool,
+  webSearchTool, memorySaveTool, memorySearchTool, memoryListTool, spawnAgentTool,
+];
+
+// ── Bootstrap ──
+
+async function main() {
+  logger.info('Anorion starting...');
+
+  // 1. Load config
+  const config = loadConfig();
+  logger.info({ port: config.gateway.port }, 'Config loaded');
+
+  // 2. Init database
+  const database = initDatabase(config.gateway.database);
+
+  // 3. Load agents from directory
+  if (config.agents.dir) {
+    agentRegistry.setDb(database.raw, database.prepared);
+    memoryManager.setDb(database.raw);
+    sessionManager.setDb(database.db, database.prepared);
+    await agentRegistry.loadFromDirectory(config.agents.dir);
+    logger.info({ agents: agentRegistry.list().map(a => a.name) }, 'Agents loaded from directory');
+  }
+
+  // 4. Register builtin tools
+  for (const tool of builtinTools) {
+    try {
+      toolRegistry.register(tool);
+    } catch {
+      // Already registered — skip
+    }
+  }
+  logger.info({ tools: builtinTools.map(t => t.name) }, 'Builtin tools registered');
+
+  // 5. Set API keys
+  if (config.gateway.apiKeys.length > 0) {
+    setApiKeys(config.gateway.apiKeys);
+    logger.info({ keys: config.gateway.apiKeys.map(k => k.name) }, 'API keys configured');
+  }
+
+  // 6. Register v2 + bridge routes
+  registerBridgeRoutes(app);
+  try {
+    app.route('/', routesV2);
+  } catch {
+    // May already be mounted
+  }
+
+  // 7. Start HTTP server FIRST (so API is available immediately)
+  const server = Bun.serve({
+    port: config.gateway.port,
+    hostname: config.gateway.host,
+    fetch: app.fetch,
+  });
+
+  logger.info(`
+╔══════════════════════════════════════════════╗
+║  Anorion Gateway                             ║
+║  http://${config.gateway.host}:${config.gateway.port}                    ║
+║  Agents: ${agentRegistry.list().length.toString().padEnd(30)}║
+║  Tools:  ${toolRegistry.list().length.toString().padEnd(30)}║
+║  Bridge: ${(config.bridge.enabled ? 'enabled' : 'disabled').padEnd(29)}║
+╚══════════════════════════════════════════════╝
+  `);
+
+  // 8. Register and start channels (after HTTP server is up)
+  const channels = config.channels;
+
+  const tgConfig = channels.telegram;
+  const tg = new TelegramChannel({
+    botToken: tgConfig.botToken,
+    allowedUsers: tgConfig.allowedUsers,
+    defaultAgent: tgConfig.defaultAgent,
+  });
+  channelRouter.registerChannel(tg);
+  channelRouter.configure({
+    routes: [],
+    defaultAgent: tgConfig.defaultAgent,
+  });
+
+  if (channels.telegram.enabled) {
+    // Don't await — Telegram long-polling blocks
+    channelRouter.startChannel('telegram').then(() => {
+      logger.info('Telegram channel started');
+    }).catch((err: Error) => {
+      logger.error({ error: err.message }, 'Telegram channel failed to start');
+    });
+  }
+
+  if (channels.webhook.enabled) {
+    const wh = new WebhookChannel({
+      inboundSecret: channels.webhook.inboundSecret,
+      outboundUrls: channels.webhook.outboundUrls,
+    });
+    channelRouter.registerChannel(wh);
+    await channelRouter.startChannel('webhook');
+    logger.info('Webhook channel started');
+  }
+
+  // 9. Load pipelines
+  const { existsSync } = await import('fs');
+  const pipelinesPath = new URL('../../pipelines.yaml', import.meta.url).pathname;
+  if (existsSync(pipelinesPath)) {
+    loadPipelinesFromFile(pipelinesPath);
+    logger.info({ pipelines: listPipelines().length }, 'Pipelines loaded');
+  }
+
+  // 10. Bridge / Federation
+  if (config.bridge.enabled) {
+    const { BridgeServer } = await import('./bridge/server');
+    const bridgeServer = new BridgeServer(config.bridge.port, config.bridge.secret);
+    const federator = new Federator(crypto.randomUUID(), config.bridge.secret, bridgeServer);
+    setBridge(federator);
+
+    for (const peer of config.bridge.peers) {
+      await federator.connectPeer(peer.url, peer.secret || '').catch((err: Error) => {
+        logger.warn({ url: peer.url, error: err.message }, 'Failed to connect to peer');
+      });
+    }
+    logger.info({ peers: config.bridge.peers.length }, 'Bridge enabled');
+  }
+
+  // 11. Scheduler
+  if (config.scheduler.enabled) {
+    logger.info('Scheduler enabled');
+  }
+
+  // 12. Log provider status
+  const providers = listConfiguredProviders();
+  const configured = providers.filter(p => p.configured);
+  logger.info({ providers: configured.map(p => `${p.icon} ${p.name}`) }, 'Configured LLM providers');
+
+  // 13. Graceful shutdown
+  const shutdown = async (signal: string) => {
+    logger.info({ signal }, 'Shutting down...');
+    await channelRouter.stopAll();
+    server.stop(true);
+    database.raw.close();
+    logger.info('Goodbye');
+    process.exit(0);
+  };
+
+  process.on('SIGINT', () => shutdown('SIGINT'));
+  process.on('SIGTERM', () => shutdown('SIGTERM'));
+}
+
+main().catch((err) => {
+  logger.fatal({ error: err.message, stack: err.stack }, 'Fatal startup error');
+  process.exit(1);
+});

package/src/llm/provider.ts

@@ -0,0 +1,243 @@
+// LLM Provider — unified interface using multi-provider registry
+
+import { generateText, streamText, type ModelMessage, type Tool as AiTool } from 'ai';
+import { resolveModel, type ResolvedModel } from './providers';
+import { logger } from '../shared/logger';
+import { eventBus } from '../shared/events';
+import type { ToolDefinition } from '../shared/types';
+import { tokenBudget } from '../shared/token-budget';
+
+export interface LlmOptions {
+  systemPrompt: string;
+  messages: ModelMessage[];
+  tools: ToolDefinition[];
+  modelId: string;
+  fallbackModelId?: string;
+  maxTokens?: number;
+  temperature?: number;
+}
+
+// ── Retry with exponential backoff + jitter ──
+
+interface RetryConfig {
+  maxRetries: number;
+  baseDelayMs: number;
+  maxDelayMs: number;
+}
+
+const DEFAULT_RETRY: RetryConfig = {
+  maxRetries: 3,
+  baseDelayMs: 1000,
+  maxDelayMs: 15000,
+};
+
+async function withRetry<T>(fn: () => Promise<T>, retry: Partial<RetryConfig> = {}): Promise<T> {
+  const cfg = { ...DEFAULT_RETRY, ...retry };
+  let lastError: Error | null = null;
+
+  for (let attempt = 0; attempt <= cfg.maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastError = err as Error;
+      if (attempt < cfg.maxRetries) {
+        const delay = Math.min(cfg.baseDelayMs * Math.pow(2, attempt) + Math.random() * 1000, cfg.maxDelayMs);
+        logger.warn({ attempt: attempt + 1, delay: Math.round(delay), error: lastError.message }, 'LLM call failed, retrying');
+        await new Promise((r) => setTimeout(r, delay));
+      }
+    }
+  }
+
+  throw lastError!;
+}
+
+// ── Circuit Breaker ──
+
+interface CircuitState {
+  failures: number;
+  lastFailure: number;
+  open: boolean;
+}
+
+const circuits = new Map<string, CircuitState>();
+const CIRCUIT_THRESHOLD = 5;
+const CIRCUIT_RESET_MS = 60_000;
+
+function checkCircuit(modelId: string): void {
+  const state = circuits.get(modelId);
+  if (!state || !state.open) return;
+  if (Date.now() - state.lastFailure > CIRCUIT_RESET_MS) {
+    state.open = false;
+    state.failures = 0;
+    logger.info({ modelId }, 'Circuit breaker reset');
+    return;
+  }
+  throw new Error(`Circuit breaker open for ${modelId} — too many failures`);
+}
+
+function recordFailure(modelId: string): void {
+  if (!circuits.has(modelId)) circuits.set(modelId, { failures: 0, lastFailure: 0, open: false });
+  const state = circuits.get(modelId)!;
+  state.failures++;
+  state.lastFailure = Date.now();
+  if (state.failures >= CIRCUIT_THRESHOLD) {
+    state.open = true;
+    logger.warn({ modelId, failures: state.failures }, 'Circuit breaker opened');
+  }
+}
+
+function recordSuccess(modelId: string): void {
+  const state = circuits.get(modelId);
+  if (state) { state.failures = 0; state.open = false; }
+}
+
+// ── Main LLM Interface ──
+
+export async function callLlm(options: LlmOptions): Promise<{
+  content: string;
+  toolCalls: { id: string; name: string; arguments: string }[];
+  usage?: { promptTokens: number; completionTokens: number; totalTokens: number };
+}> {
+  const { modelId, fallbackModelId, tools, systemPrompt, messages, maxTokens, temperature } = options;
+
+  const aiTools: Record<string, AiTool> = {};
+  for (const tool of tools) {
+    aiTools[tool.name] = {
+      description: tool.description,
+      parameters: tool.parameters as Record<string, unknown>,
+      execute: undefined as unknown as AiTool['execute'],
+    };
+  }
+
+  const models = [modelId, ...(fallbackModelId ? [fallbackModelId] : [])];
+  let lastError: Error | null = null;
+
+  for (const mid of models) {
+    try {
+      checkCircuit(mid);
+      const resolved = resolveModel(mid);
+
+      // Token budget check (estimate ~4 chars per token for check)
+      const estimatedTokens = Math.ceil(
+        (systemPrompt.length + JSON.stringify(messages).length) / 4 + (maxTokens || 4096)
+      );
+      const budget = tokenBudget.canSpend('global', 'llm-call', estimatedTokens);
+      if (!budget.allowed) {
+        throw new Error(`Token budget: ${budget.reason}`);
+      }
+
+      logger.debug({ model: mid, provider: resolved.providerName, toolCount: Object.keys(aiTools).length }, 'Calling LLM');
+
+      const result = await withRetry(() => generateText({
+        model: resolved.instance,
+        system: systemPrompt,
+        messages,
+        tools: Object.keys(aiTools).length > 0 ? aiTools : undefined,
+        maxTokens,
+        temperature,
+      }));
+
+      recordSuccess(mid);
+
+      // Emit token usage event
+      if (result.usage) {
+        eventBus.emit('token:usage', {
+          agentId: 'global',
+          sessionId: 'llm-call',
+          model: mid,
+          promptTokens: result.usage.promptTokens,
+          completionTokens: result.usage.completionTokens,
+          timestamp: Date.now(),
+        });
+      }
+
+      const toolCalls = result.toolCalls.map((tc) => ({
+        id: tc.toolCallId,
+        name: tc.toolName,
+        arguments: JSON.stringify(tc.args),
+      }));
+
+      return {
+        content: result.text,
+        toolCalls,
+        usage: result.usage ? {
+          promptTokens: result.usage.promptTokens,
+          completionTokens: result.usage.completionTokens,
+          totalTokens: result.usage.promptTokens + result.usage.completionTokens,
+        } : undefined,
+      };
+    } catch (err) {
+      lastError = err as Error;
+      recordFailure(mid);
+      logger.warn({ model: mid, error: lastError.message }, 'LLM call failed');
+    }
+  }
+
+  throw lastError || new Error('All LLM providers failed');
+}
+
+export async function* streamLlm(options: LlmOptions) {
+  const { modelId, tools, systemPrompt, messages, maxTokens, temperature } = options;
+
+  const aiTools: Record<string, AiTool> = {};
+  for (const tool of tools) {
+    aiTools[tool.name] = {
+      description: tool.description,
+      parameters: tool.parameters as Record<string, unknown>,
+      execute: undefined as unknown as AiTool['execute'],
+    };
+  }
+
+  const resolved = resolveModel(modelId);
+  checkCircuit(modelId);
+
+  const result = streamText({
+    model: resolved.instance,
+    system: systemPrompt,
+    messages,
+    tools: Object.keys(aiTools).length > 0 ? aiTools : undefined,
+    maxTokens,
+    temperature,
+  });
+
+  let totalInput = 0;
+  let totalOutput = 0;
+
+  for await (const chunk of result.fullStream) {
+    switch (chunk.type) {
+      case 'text-delta':
+        totalOutput += chunk.textDelta.length;
+        yield { type: 'delta' as const, content: chunk.textDelta };
+        break;
+      case 'tool-call':
+        yield {
+          type: 'tool_call' as const,
+          id: chunk.toolCallId,
+          name: chunk.toolName,
+          arguments: chunk.args,
+        };
+        break;
+      case 'finish':
+        if (chunk.usage) {
+          totalInput = chunk.usage.promptTokens;
+          totalOutput = chunk.usage.completionTokens;
+          eventBus.emit('token:usage', {
+            agentId: 'global',
+            sessionId: 'llm-stream',
+            model: modelId,
+            promptTokens: totalInput,
+            completionTokens: totalOutput,
+            timestamp: Date.now(),
+          });
+        }
+        yield { type: 'done' as const, usage: chunk.usage };
+        recordSuccess(modelId);
+        break;
+    }
+  }
+}
+
+export type StreamChunk =
+  | { type: 'delta'; content: string }
+  | { type: 'tool_call'; id: string; name: string; arguments: unknown }
+  | { type: 'done'; usage?: { promptTokens: number; completionTokens: number; totalTokens: number } };