@aion0/forge 0.6.3 → 0.8.1

package/lib/chat/llm/anthropic.ts

@@ -0,0 +1,99 @@
+/**
+ * Anthropic adapter — ported from the extension. Server-side variant
+ * (no dangerouslyAllowBrowser). OAuth tokens (sk-ant-oat-*) get the
+ * special beta header + authToken handling.
+ */
+
+import Anthropic from '@anthropic-ai/sdk';
+import type { Message } from '../types';
+import type { LlmAdapter, LlmCallbacks, LlmRequest, LlmTurnResult, StopReason } from './types';
+
+function historyToApi(history: Message[]): Anthropic.MessageParam[] {
+  const out: Anthropic.MessageParam[] = [];
+  for (const m of history) {
+    const content: Anthropic.ContentBlockParam[] = [];
+    for (const b of m.blocks) {
+      if (b.type === 'text') {
+        if (b.text.length > 0) content.push({ type: 'text', text: b.text });
+      } else if (b.type === 'tool_use') {
+        content.push({
+          type: 'tool_use',
+          id: b.id,
+          name: b.name,
+          input: (b.input ?? {}) as Record<string, unknown>,
+        });
+      } else if (b.type === 'tool_result') {
+        content.push({
+          type: 'tool_result',
+          tool_use_id: b.tool_use_id,
+          content: b.content,
+          is_error: b.is_error,
+        });
+      }
+    }
+    if (content.length === 0) continue;
+    out.push({ role: m.role, content });
+  }
+  return out;
+}
+
+function mapStop(r: Anthropic.Message['stop_reason']): StopReason {
+  switch (r) {
+    case 'end_turn': return 'end_turn';
+    case 'tool_use': return 'tool_use';
+    case 'max_tokens': return 'max_tokens';
+    case 'refusal': return 'refusal';
+    default: return 'other';
+  }
+}
+
+function isOauthToken(key: string): boolean {
+  return key.startsWith('sk-ant-oat');
+}
+
+export function makeAnthropicClient(apiKey: string, baseUrl: string): Anthropic {
+  const opts: ConstructorParameters<typeof Anthropic>[0] = {
+    baseURL: baseUrl || undefined,
+  };
+  if (isOauthToken(apiKey)) {
+    opts.authToken = apiKey;
+    opts.defaultHeaders = { 'anthropic-beta': 'oauth-2025-04-20' };
+  } else {
+    opts.apiKey = apiKey;
+  }
+  return new Anthropic(opts);
+}
+
+export const anthropicAdapter: LlmAdapter = {
+  async stream(req: LlmRequest, cb: LlmCallbacks): Promise<LlmTurnResult> {
+    const client = makeAnthropicClient(req.apiKey, req.baseUrl);
+
+    const stream = client.messages.stream({
+      model: req.model,
+      max_tokens: req.maxTokens,
+      system: req.system,
+      tools: req.tools.map((t) => ({
+        name: t.name,
+        description: t.description,
+        input_schema: t.input_schema as Anthropic.Tool.InputSchema,
+      })),
+      messages: historyToApi(req.history),
+    });
+
+    stream.on('text', (delta: string) => cb.onTextDelta(delta));
+
+    const final = await stream.finalMessage();
+
+    const content: LlmTurnResult['content'] = [];
+    for (const block of final.content) {
+      if (block.type === 'text') {
+        content.push({ type: 'text', text: block.text });
+      } else if (block.type === 'tool_use') {
+        cb.onToolUse({ id: block.id, name: block.name, input: block.input });
+        content.push({ type: 'tool_use', id: block.id, name: block.name, input: block.input });
+      }
+    }
+
+    return { stopReason: mapStop(final.stop_reason), content };
+  },
+};

package/lib/chat/llm/index.ts

@@ -0,0 +1,20 @@
+/**
+ * LLM client — picks an adapter based on the provider type.
+ */
+
+import { anthropicAdapter } from './anthropic';
+import { openaiAdapter } from './openai';
+import type { LlmAdapter, LlmCallbacks, LlmRequest, LlmTurnResult } from './types';
+
+export type { LlmAdapter, LlmCallbacks, LlmRequest, LlmTurnResult, LlmTool, StopReason } from './types';
+
+const ADAPTERS: Record<LlmRequest['provider'], LlmAdapter> = {
+  anthropic: anthropicAdapter,
+  openai: openaiAdapter,
+};
+
+export function streamLlm(req: LlmRequest, cb: LlmCallbacks): Promise<LlmTurnResult> {
+  const adapter = ADAPTERS[req.provider];
+  if (!adapter) throw new Error(`unknown provider: ${req.provider}`);
+  return adapter.stream(req, cb);
+}

package/lib/chat/llm/openai.ts

@@ -0,0 +1,215 @@
+import type { ContentBlock, Message } from '../types';
+import type { LlmAdapter, LlmCallbacks, LlmRequest, LlmTurnResult, StopReason } from './types';
+
+// Minimal OpenAI-compatible Chat Completions types — covers what we use.
+interface OAIToolCall {
+  index?: number;
+  id?: string;
+  type?: 'function';
+  function?: { name?: string; arguments?: string };
+}
+
+interface OAITool {
+  type: 'function';
+  function: {
+    name: string;
+    description: string;
+    parameters: Record<string, unknown>;
+  };
+}
+
+type OAIMessage =
+  | { role: 'system'; content: string }
+  | { role: 'user'; content: string }
+  | { role: 'assistant'; content: string | null; tool_calls?: { id: string; type: 'function'; function: { name: string; arguments: string } }[] }
+  | { role: 'tool'; tool_call_id: string; content: string };
+
+interface OAIChunk {
+  choices?: {
+    index?: number;
+    delta?: {
+      role?: string;
+      content?: string | null;
+      tool_calls?: OAIToolCall[];
+    };
+    finish_reason?: string | null;
+  }[];
+}
+
+function defaultBase(baseUrl: string): string {
+  return (baseUrl || 'https://api.openai.com/v1').replace(/\/+$/, '');
+}
+
+function historyToApi(history: Message[]): OAIMessage[] {
+  const out: OAIMessage[] = [];
+  for (const m of history) {
+    if (m.role === 'user') {
+      // A user message in our model can be plain text OR a vehicle for tool_result blocks.
+      const toolResults = m.blocks.filter((b): b is Extract<ContentBlock, { type: 'tool_result' }> => b.type === 'tool_result');
+      if (toolResults.length > 0) {
+        for (const r of toolResults) {
+          out.push({ role: 'tool', tool_call_id: r.tool_use_id, content: r.content });
+        }
+      } else {
+        const text = m.blocks
+          .filter((b): b is Extract<ContentBlock, { type: 'text' }> => b.type === 'text')
+          .map((b) => b.text)
+          .join('\n');
+        if (text.length > 0) out.push({ role: 'user', content: text });
+      }
+    } else {
+      // assistant
+      const text = m.blocks
+        .filter((b): b is Extract<ContentBlock, { type: 'text' }> => b.type === 'text')
+        .map((b) => b.text)
+        .join('');
+      const tcs = m.blocks
+        .filter((b): b is Extract<ContentBlock, { type: 'tool_use' }> => b.type === 'tool_use')
+        .map((b) => ({
+          id: b.id,
+          type: 'function' as const,
+          function: { name: b.name, arguments: JSON.stringify(b.input ?? {}) },
+        }));
+      if (text.length === 0 && tcs.length === 0) continue;
+      out.push({
+        role: 'assistant',
+        content: text.length > 0 ? text : null,
+        ...(tcs.length > 0 ? { tool_calls: tcs } : {}),
+      });
+    }
+  }
+  return out;
+}
+
+function mapStop(r: string | null | undefined): StopReason {
+  switch (r) {
+    case 'stop':
+      return 'end_turn';
+    case 'tool_calls':
+    case 'function_call':
+      return 'tool_use';
+    case 'length':
+      return 'max_tokens';
+    case 'content_filter':
+      return 'refusal';
+    default:
+      return 'other';
+  }
+}
+
+export const openaiAdapter: LlmAdapter = {
+  async stream(req: LlmRequest, cb: LlmCallbacks): Promise<LlmTurnResult> {
+    const url = defaultBase(req.baseUrl) + '/chat/completions';
+
+    const tools: OAITool[] = req.tools.map((t) => ({
+      type: 'function',
+      function: {
+        name: t.name,
+        description: t.description,
+        parameters: t.input_schema,
+      },
+    }));
+
+    const body: Record<string, unknown> = {
+      model: req.model,
+      stream: true,
+      max_tokens: req.maxTokens,
+      messages: [{ role: 'system', content: req.system }, ...historyToApi(req.history)],
+    };
+    if (tools.length > 0) {
+      body.tools = tools;
+    }
+
+    const resp = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'content-type': 'application/json',
+        ...(req.apiKey ? { Authorization: `Bearer ${req.apiKey}` } : {}),
+      },
+      body: JSON.stringify(body),
+    });
+
+    if (!resp.ok || !resp.body) {
+      const text = await resp.text().catch(() => '');
+      throw new Error(`LLM ${resp.status}: ${text.slice(0, 400)}`);
+    }
+
+    const reader = resp.body.getReader();
+    const decoder = new TextDecoder();
+
+    let buffer = '';
+    let accumText = '';
+    // Tool call accumulators keyed by index (OpenAI streams partial JSON for arguments).
+    const toolByIndex = new Map<number, { id: string; name: string; argsRaw: string }>();
+    let finishReason: string | null | undefined;
+
+    while (true) {
+      const { value, done } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+
+      // SSE events are separated by blank lines; each event has one or more lines starting with "data: ".
+      const events = buffer.split('\n\n');
+      buffer = events.pop() ?? '';
+
+      for (const rawEvent of events) {
+        for (const line of rawEvent.split('\n')) {
+          if (!line.startsWith('data:')) continue;
+          const payload = line.slice(5).trim();
+          if (!payload || payload === '[DONE]') continue;
+          let chunk: OAIChunk;
+          try {
+            chunk = JSON.parse(payload) as OAIChunk;
+          } catch {
+            continue;
+          }
+          const choice = chunk.choices?.[0];
+          if (!choice) continue;
+          if (choice.finish_reason) finishReason = choice.finish_reason;
+          const delta = choice.delta;
+          if (!delta) continue;
+          if (typeof delta.content === 'string' && delta.content.length > 0) {
+            accumText += delta.content;
+            cb.onTextDelta(delta.content);
+          }
+          if (delta.tool_calls) {
+            for (const tc of delta.tool_calls) {
+              const idx = tc.index ?? 0;
+              let agg = toolByIndex.get(idx);
+              if (!agg) {
+                agg = { id: tc.id ?? '', name: tc.function?.name ?? '', argsRaw: '' };
+                toolByIndex.set(idx, agg);
+              }
+              if (tc.id && !agg.id) agg.id = tc.id;
+              if (tc.function?.name && !agg.name) agg.name = tc.function.name;
+              if (tc.function?.arguments) agg.argsRaw += tc.function.arguments;
+            }
+          }
+        }
+      }
+    }
+
+    const content: ContentBlock[] = [];
+    if (accumText.length > 0) content.push({ type: 'text', text: accumText });
+
+    // Sort tool calls by index for stable ordering.
+    const tcKeys = Array.from(toolByIndex.keys()).sort((a, b) => a - b);
+    for (const idx of tcKeys) {
+      const agg = toolByIndex.get(idx);
+      if (!agg) continue;
+      let input: unknown = {};
+      if (agg.argsRaw.length > 0) {
+        try {
+          input = JSON.parse(agg.argsRaw);
+        } catch {
+          input = { _raw: agg.argsRaw };
+        }
+      }
+      const id = agg.id || `call_${idx}`;
+      cb.onToolUse({ id, name: agg.name, input });
+      content.push({ type: 'tool_use', id, name: agg.name, input });
+    }
+
+    return { stopReason: mapStop(finishReason), content };
+  },
+};

package/lib/chat/llm/types.ts

@@ -0,0 +1,42 @@
+/**
+ * LLM adapter types — ported from the extension.
+ */
+
+import type { ContentBlock, Message } from '../types';
+
+export interface LlmTool {
+  name: string;
+  description: string;
+  input_schema: {
+    type: 'object';
+    properties: Record<string, unknown>;
+    required?: string[];
+  };
+}
+
+export interface LlmCallbacks {
+  onTextDelta: (delta: string) => void;
+  onToolUse: (block: { id: string; name: string; input: unknown }) => void;
+}
+
+export type StopReason = 'end_turn' | 'tool_use' | 'max_tokens' | 'refusal' | 'error' | 'other';
+
+export interface LlmTurnResult {
+  stopReason: StopReason;
+  content: ContentBlock[];
+}
+
+export interface LlmRequest {
+  provider: 'anthropic' | 'openai';
+  apiKey: string;
+  baseUrl: string;
+  model: string;
+  system: string;
+  history: Message[];
+  tools: LlmTool[];
+  maxTokens: number;
+}
+
+export interface LlmAdapter {
+  stream(req: LlmRequest, cb: LlmCallbacks): Promise<LlmTurnResult>;
+}

package/lib/chat/local-memory.ts

@@ -0,0 +1,300 @@
+/**
+ * LocalMemoryStore — SQLite-backed fallback for chat memory when
+ * Temper isn't configured. Implements the same surface as TemperClient
+ * (see lib/chat/memory-store.ts MemoryStore interface) so callers don't
+ * branch on the backend.
+ *
+ * Two tables under workflow.db:
+ *   memory_blocks   — key/value pairs (Temper "blocks")
+ *   memory_episodes — append-only event log (Temper "episodes")
+ *
+ * Differences from Temper:
+ *   - search() does case-insensitive LIKE over block values + episode
+ *     content. No embeddings, no graph extraction.
+ *   - writeEpisode() returns immediately; there is no async extraction.
+ *   - Namespaces are honored at write/read time, but `scope=global` is
+ *     a synonym for `scope=own` (local has a single tenant).
+ */
+
+import { join } from 'node:path';
+import { getDb } from '../../src/core/db/database';
+import { getDataDir } from '../dirs';
+import type Database from 'better-sqlite3';
+import type {
+  EpisodeInput,
+  MemoryBlock,
+  MemoryStore,
+  SearchHit,
+} from './memory-store';
+
+const DEFAULT_NAMESPACE = 'local';
+
+interface BlockRow {
+  ns: string;
+  key: string;
+  value: string;          // JSON-encoded
+  pinned: number;         // 0/1
+  priority: number | null;
+  description: string | null;
+  scope: string;          // 'own' | 'global'
+  updated_at: string;     // ISO
+}
+
+interface EpisodeRow {
+  id: number;
+  ns: string;
+  content: string;
+  tags: string | null;    // JSON-encoded array
+  source_type: string | null;
+  reference_time: string | null;
+  created_at: string;     // ISO
+}
+
+let schemaReady = false;
+
+function db(): Database.Database {
+  return getDb(join(getDataDir(), 'workflow.db'));
+}
+
+function ensureSchema(): void {
+  if (schemaReady) return;
+  const conn = db();
+  conn.exec(`
+    CREATE TABLE IF NOT EXISTS memory_blocks (
+      ns          TEXT NOT NULL,
+      key         TEXT NOT NULL,
+      value       TEXT NOT NULL,
+      pinned      INTEGER NOT NULL DEFAULT 0,
+      priority    INTEGER,
+      description TEXT,
+      scope       TEXT NOT NULL DEFAULT 'own',
+      updated_at  TEXT NOT NULL,
+      PRIMARY KEY (ns, key)
+    );
+    CREATE INDEX IF NOT EXISTS idx_memory_blocks_pinned
+      ON memory_blocks(ns, pinned);
+
+    CREATE TABLE IF NOT EXISTS memory_episodes (
+      id             INTEGER PRIMARY KEY AUTOINCREMENT,
+      ns             TEXT NOT NULL,
+      content        TEXT NOT NULL,
+      tags           TEXT,
+      source_type    TEXT,
+      reference_time TEXT,
+      created_at     TEXT NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_memory_episodes_ns_created
+      ON memory_episodes(ns, created_at DESC);
+  `);
+  schemaReady = true;
+}
+
+function nowIso(): string {
+  return new Date().toISOString();
+}
+
+function decodeValue(raw: string): unknown {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return raw;
+  }
+}
+
+function rowToBlock(r: BlockRow): MemoryBlock {
+  return {
+    key: r.key,
+    value: decodeValue(r.value),
+    pinned: !!r.pinned,
+    priority: r.priority ?? undefined,
+    description: r.description ?? undefined,
+    scope: (r.scope as 'own' | 'global') ?? 'own',
+  };
+}
+
+export class LocalMemoryStore implements MemoryStore {
+  readonly kind = 'local' as const;
+  private readonly ns: string;
+
+  constructor(namespace?: string) {
+    this.ns = (namespace || DEFAULT_NAMESPACE).trim() || DEFAULT_NAMESPACE;
+    ensureSchema();
+  }
+
+  get enabled(): boolean {
+    return true;
+  }
+
+  get currentNamespace(): string {
+    return this.ns;
+  }
+
+  async search(query: string, limit = 8): Promise<SearchHit[]> {
+    const q = (query || '').trim();
+    if (!q) return [];
+    const cap = Math.min(50, Math.max(1, limit));
+    const like = `%${q.replace(/[%_]/g, (m) => '\\' + m)}%`;
+    const conn = db();
+
+    const blockHits = conn.prepare(
+      `SELECT key, value, description, updated_at
+         FROM memory_blocks
+        WHERE ns = ?
+          AND (value LIKE ? ESCAPE '\\' OR key LIKE ? ESCAPE '\\' OR description LIKE ? ESCAPE '\\')
+        ORDER BY pinned DESC, updated_at DESC
+        LIMIT ?`,
+    ).all(this.ns, like, like, like, cap) as Array<Pick<BlockRow, 'key' | 'value' | 'description' | 'updated_at'>>;
+
+    const episodeHits = conn.prepare(
+      `SELECT id, content, reference_time, created_at
+         FROM memory_episodes
+        WHERE ns = ?
+          AND content LIKE ? ESCAPE '\\'
+        ORDER BY created_at DESC
+        LIMIT ?`,
+    ).all(this.ns, like, cap) as Array<Pick<EpisodeRow, 'id' | 'content' | 'reference_time' | 'created_at'>>;
+
+    const hits: SearchHit[] = [];
+    for (const b of blockHits) {
+      const valueStr = typeof decodeValue(b.value) === 'string'
+        ? String(decodeValue(b.value))
+        : b.value;
+      hits.push({
+        id: `block:${b.key}`,
+        kind: 'fact',
+        fact: `${b.key}: ${truncate(valueStr, 200)}`,
+        valid_at: b.updated_at,
+        invalid_at: null,
+        namespace: this.ns,
+      });
+    }
+    for (const e of episodeHits) {
+      hits.push({
+        id: `episode:${e.id}`,
+        kind: 'fact',
+        fact: truncate(e.content, 300),
+        valid_at: e.reference_time ?? e.created_at,
+        invalid_at: null,
+        namespace: this.ns,
+      });
+    }
+    return hits.slice(0, cap);
+  }
+
+  async writeEpisode(ep: EpisodeInput, _asyncExtract = true): Promise<boolean> {
+    if (!ep.content || !ep.content.trim()) return false;
+    try {
+      const conn = db();
+      conn.prepare(
+        `INSERT INTO memory_episodes(ns, content, tags, source_type, reference_time, created_at)
+         VALUES (?, ?, ?, ?, ?, ?)`,
+      ).run(
+        ep.namespace || this.ns,
+        ep.content,
+        ep.tags && ep.tags.length ? JSON.stringify(ep.tags) : null,
+        ep.source_type ?? 'text',
+        ep.reference_time ?? nowIso(),
+        nowIso(),
+      );
+      return true;
+    } catch (err) {
+      console.warn('[local-memory] writeEpisode failed', err);
+      return false;
+    }
+  }
+
+  async listBlocks(opts: { pinned?: boolean; scope?: 'own' | 'global' | 'both' } = {}): Promise<MemoryBlock[]> {
+    try {
+      const conn = db();
+      const where: string[] = ['ns = ?'];
+      const params: unknown[] = [this.ns];
+      if (opts.pinned) where.push('pinned = 1');
+      // scope=both means no filter; scope=own/global filters on stored value.
+      // Local store treats global ≡ own (single tenant), so we only filter when
+      // the caller explicitly asked for one or the other AND any rows actually
+      // have that scope. Otherwise return all.
+      const sql = `SELECT ns, key, value, pinned, priority, description, scope, updated_at
+                     FROM memory_blocks
+                    WHERE ${where.join(' AND ')}
+                    ORDER BY pinned DESC, updated_at DESC`;
+      const rows = conn.prepare(sql).all(...params) as BlockRow[];
+      return rows.map(rowToBlock);
+    } catch (err) {
+      console.warn('[local-memory] listBlocks failed', err);
+      return [];
+    }
+  }
+
+  async getBlock(key: string, _scope: 'own' | 'global' = 'own'): Promise<MemoryBlock | null> {
+    try {
+      const conn = db();
+      const row = conn.prepare(
+        `SELECT ns, key, value, pinned, priority, description, scope, updated_at
+           FROM memory_blocks
+          WHERE ns = ? AND key = ?`,
+      ).get(this.ns, key) as BlockRow | undefined;
+      if (!row) return null;
+      return rowToBlock(row);
+    } catch (err) {
+      console.warn('[local-memory] getBlock failed', err);
+      return null;
+    }
+  }
+
+  async putBlock(
+    key: string,
+    value: unknown,
+    extras: { pinned?: boolean; priority?: number; description?: string; scope?: 'own' | 'global' } = {},
+  ): Promise<boolean> {
+    if (!key) return false;
+    try {
+      const conn = db();
+      conn.prepare(
+        `INSERT INTO memory_blocks(ns, key, value, pinned, priority, description, scope, updated_at)
+              VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+         ON CONFLICT(ns, key) DO UPDATE SET
+            value       = excluded.value,
+            pinned      = excluded.pinned,
+            priority    = excluded.priority,
+            description = excluded.description,
+            scope       = excluded.scope,
+            updated_at  = excluded.updated_at`,
+      ).run(
+        this.ns,
+        key,
+        JSON.stringify(value),
+        extras.pinned ? 1 : 0,
+        extras.priority ?? null,
+        extras.description ?? null,
+        extras.scope ?? 'own',
+        nowIso(),
+      );
+      return true;
+    } catch (err) {
+      console.warn('[local-memory] putBlock failed', err);
+      return false;
+    }
+  }
+
+  async ping(): Promise<{ ok: boolean; message: string; pinned: number }> {
+    try {
+      const conn = db();
+      const row = conn.prepare(
+        `SELECT COUNT(*) AS n FROM memory_blocks WHERE ns = ? AND pinned = 1`,
+      ).get(this.ns) as { n: number };
+      const n = row?.n ?? 0;
+      return {
+        ok: true,
+        message: `Local memory · ${n} pinned block${n === 1 ? '' : 's'}`,
+        pinned: n,
+      };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return { ok: false, message: `Local memory unavailable: ${msg}`, pinned: 0 };
+    }
+  }
+}
+
+function truncate(s: string, max: number): string {
+  return s.length > max ? s.slice(0, max) + '…' : s;
+}