@aion0/forge 0.6.3 → 0.8.0

package/lib/chat/temper.ts

@@ -0,0 +1,281 @@
+/**
+ * Temper memory client — used by Forge chat for pinned/recall/episode I/O.
+ *
+ * Ported from the extension's pre-Phase-4 implementation. Auth: X-API-Key.
+ * Default namespace comes from the key — only set the override via
+ * settings.temperNamespace if you intentionally want a different scope.
+ *
+ * The chat agent loop calls listBlocks + search on every turn (silent on
+ * failure) and exposes memory_* tools to the LLM for explicit reads /
+ * writes. If url or key is missing, the client reports `enabled = false`
+ * and every method is a no-op returning the empty/false fallback.
+ */
+
+export interface SearchHit {
+  id: string;
+  kind: 'fact' | 'entity' | string;
+  fact?: string;
+  score?: number;
+  valid_at?: string | null;
+  invalid_at?: string | null;
+  source_node_uuid?: string;
+  target_node_uuid?: string;
+  namespace?: string;
+}
+
+export interface MemoryBlock {
+  key: string;
+  value: unknown;
+  pinned?: boolean;
+  priority?: number;
+  description?: string;
+  scope?: 'own' | 'global' | 'both';
+}
+
+interface RawBlock {
+  block_key?: string;
+  block_value?: unknown;
+  key?: string;
+  value?: unknown;
+  pinned?: boolean;
+  priority?: number;
+  description?: string;
+  scope?: 'own' | 'global' | 'both';
+}
+
+function normalizeBlock(raw: RawBlock): MemoryBlock | null {
+  const key = raw.block_key ?? raw.key;
+  if (!key) return null;
+  const value = 'block_value' in raw ? raw.block_value : raw.value;
+  return {
+    key,
+    value,
+    pinned: raw.pinned,
+    priority: raw.priority,
+    description: raw.description,
+    scope: raw.scope,
+  };
+}
+
+export type SourceType = 'message' | 'text' | 'json';
+
+export interface EpisodeInput {
+  content: string;
+  source_type?: SourceType;
+  source_description?: string;
+  reference_time?: string;
+  tags?: string[];
+  saga?: string;
+  namespace?: string;
+}
+
+export class TemperClient {
+  constructor(
+    private readonly baseUrl: string,
+    private readonly apiKey: string = '',
+    /** Optional namespace override. Empty = use the key's default. */
+    private readonly namespace: string = '',
+  ) {}
+
+  get enabled(): boolean {
+    return this.baseUrl.length > 0 && this.apiKey.length > 0;
+  }
+
+  get currentNamespace(): string {
+    return this.namespace;
+  }
+
+  private url(path: string): string {
+    return this.baseUrl.replace(/\/+$/, '') + path;
+  }
+
+  private headers(extra: Record<string, string> = {}): Record<string, string> {
+    return { 'X-API-Key': this.apiKey, ...extra };
+  }
+
+  private withNs(u: URL): URL {
+    if (this.namespace) u.searchParams.set('namespace', this.namespace);
+    return u;
+  }
+
+  async search(query: string, limit = 8): Promise<SearchHit[]> {
+    if (!this.enabled) return [];
+    try {
+      const u = this.withNs(new URL(this.url('/v1/search')));
+      u.searchParams.set('query', query);
+      u.searchParams.set('limit', String(limit));
+      const r = await fetch(u.toString(), { headers: this.headers() });
+      if (!r.ok) return [];
+      const j = await r.json();
+      if (Array.isArray(j)) return j as SearchHit[];
+      if (j && Array.isArray((j as { hits?: SearchHit[] }).hits)) {
+        return (j as { hits: SearchHit[] }).hits;
+      }
+      if (j && Array.isArray((j as { results?: SearchHit[] }).results)) {
+        return (j as { results: SearchHit[] }).results;
+      }
+      return [];
+    } catch (err) {
+      console.warn('[temper] search failed', err);
+      return [];
+    }
+  }
+
+  async writeEpisode(ep: EpisodeInput, asyncExtract = true): Promise<boolean> {
+    if (!this.enabled) return false;
+    try {
+      const u = new URL(this.url('/v1/episodes'));
+      if (asyncExtract) u.searchParams.set('async_extract', 'true');
+      const body: EpisodeInput = {
+        source_type: 'text',
+        reference_time: new Date().toISOString(),
+        ...(this.namespace && !ep.namespace ? { namespace: this.namespace } : {}),
+        ...ep,
+      };
+      const r = await fetch(u.toString(), {
+        method: 'POST',
+        headers: this.headers({ 'content-type': 'application/json' }),
+        body: JSON.stringify(body),
+      });
+      return r.ok;
+    } catch (err) {
+      console.warn('[temper] writeEpisode failed', err);
+      return false;
+    }
+  }
+
+  async listBlocks(opts: { pinned?: boolean; scope?: 'own' | 'global' | 'both' } = {}): Promise<MemoryBlock[]> {
+    if (!this.enabled) return [];
+    try {
+      const u = this.withNs(new URL(this.url('/v1/memory/blocks')));
+      if (opts.pinned) u.searchParams.set('pinned', 'true');
+      u.searchParams.set('scope', opts.scope ?? 'both');
+      const r = await fetch(u.toString(), { headers: this.headers() });
+      if (!r.ok) return [];
+      const j = await r.json();
+      const raws: RawBlock[] = Array.isArray(j)
+        ? (j as RawBlock[])
+        : j && Array.isArray((j as { blocks?: RawBlock[] }).blocks)
+          ? (j as { blocks: RawBlock[] }).blocks
+          : [];
+      return raws
+        .map(normalizeBlock)
+        .filter((b): b is MemoryBlock => b !== null);
+    } catch (err) {
+      console.warn('[temper] listBlocks failed', err);
+      return [];
+    }
+  }
+
+  async getBlock(key: string, scope: 'own' | 'global' = 'own'): Promise<MemoryBlock | null> {
+    if (!this.enabled) return null;
+    try {
+      const u = this.withNs(new URL(this.url(`/v1/memory/blocks/${encodeURIComponent(key)}`)));
+      u.searchParams.set('scope', scope);
+      const r = await fetch(u.toString(), { headers: this.headers() });
+      if (r.status === 404) return null;
+      if (!r.ok) return null;
+      const j = (await r.json()) as RawBlock | { block?: RawBlock };
+      const raw = 'block' in (j as Record<string, unknown>) ? (j as { block?: RawBlock }).block : (j as RawBlock);
+      if (!raw) return null;
+      const normalized = normalizeBlock(raw) ?? normalizeBlock({ ...raw, block_key: key });
+      return normalized;
+    } catch (err) {
+      console.warn('[temper] getBlock failed', err);
+      return null;
+    }
+  }
+
+  async putBlock(
+    key: string,
+    value: unknown,
+    extras: { pinned?: boolean; priority?: number; description?: string; scope?: 'own' | 'global' } = {},
+  ): Promise<boolean> {
+    if (!this.enabled) return false;
+    try {
+      const u = this.withNs(new URL(this.url(`/v1/memory/blocks/${encodeURIComponent(key)}`)));
+      const r = await fetch(u.toString(), {
+        method: 'PUT',
+        headers: this.headers({ 'content-type': 'application/json' }),
+        body: JSON.stringify({ value, ...extras }),
+      });
+      return r.ok;
+    } catch (err) {
+      console.warn('[temper] putBlock failed', err);
+      return false;
+    }
+  }
+
+  /** Reachability probe — returns ok + pinned count. */
+  async ping(): Promise<{ ok: boolean; message: string; pinned: number }> {
+    if (!this.baseUrl) return { ok: false, message: 'URL is empty', pinned: 0 };
+    if (!this.apiKey) return { ok: false, message: 'API key is empty', pinned: 0 };
+    try {
+      const u = this.withNs(new URL(this.url('/v1/memory/blocks')));
+      u.searchParams.set('pinned', 'true');
+      u.searchParams.set('scope', 'both');
+      const r = await fetch(u.toString(), { headers: this.headers() });
+      if (!r.ok) {
+        const text = await r.text().catch(() => '');
+        return {
+          ok: false,
+          message: `${r.status} ${r.statusText}${text ? ': ' + text.slice(0, 200) : ''}`,
+          pinned: 0,
+        };
+      }
+      const j = await r.json();
+      const arr = Array.isArray(j)
+        ? (j as unknown[])
+        : j && Array.isArray((j as { blocks?: unknown[] }).blocks)
+          ? (j as { blocks: unknown[] }).blocks
+          : [];
+      const count = arr.length;
+      return { ok: true, message: `OK · ${count} pinned block${count === 1 ? '' : 's'}`, pinned: count };
+    } catch (err) {
+      return { ok: false, message: err instanceof Error ? err.message : String(err), pinned: 0 };
+    }
+  }
+}
+
+// ─── System-prompt rendering ──────────────────────────────
+
+function valueShort(v: unknown, max = 200): string {
+  const s = typeof v === 'string' ? v : JSON.stringify(v);
+  return s.length > max ? s.slice(0, max) + '…' : s;
+}
+
+const MAX_INLINED_BLOCKS = 50;
+
+/**
+ * Inline all known block values into the system prompt. Smaller models
+ * won't proactively call memory_get_block from a key listing — they'll
+ * just answer what's asked. So we hand them the values directly. The
+ * memory_get_block tool is still available for explicit lookups (a
+ * value too long to inline, scopes not auto-loaded), but the chat loop
+ * does not depend on the LLM choosing to use it.
+ */
+export function renderMemoryContext(blocks: MemoryBlock[], hits: SearchHit[]): string {
+  const out: string[] = [];
+  if (blocks.length > 0) {
+    out.push('Known facts about the user (from memory):');
+    const inlined = blocks.slice(0, MAX_INLINED_BLOCKS);
+    for (const b of inlined) {
+      const desc = b.description ? `  (note: ${b.description})` : '';
+      out.push(`- ${b.key} = ${valueShort(b.value)}${desc}`);
+    }
+    if (blocks.length > inlined.length) {
+      out.push(`- … and ${blocks.length - inlined.length} more (use memory_list_blocks to enumerate)`);
+    }
+    out.push('');
+  }
+
+  const factHits = hits.filter((h) => h.fact && h.invalid_at == null);
+  if (factHits.length > 0) {
+    out.push('Recalled facts (semantic graph search):');
+    for (const h of factHits.slice(0, 6)) {
+      out.push(`- ${h.fact}`);
+    }
+  }
+
+  return out.join('\n');
+}

package/lib/chat/tool-dispatcher.ts

@@ -0,0 +1,190 @@
+/**
+ * Tool dispatcher — routes an LLM tool call to the right executor.
+ *
+ *   <plugin_id>.<tool_name>  →  connector tool
+ *       browser protocol → dispatched to extension via bridge.connector_run
+ *       (http/ssh/mcp/etc. → reserved for Phase 3 runtimes)
+ *   builtin name              →  in-process function
+ *
+ * Returns the tool_result block content (string) + is_error flag.
+ */
+
+import { bridgeRpc } from './bridge-client';
+import { runHttp } from './protocols/http';
+import { runShell } from './protocols/shell';
+import {
+  getPlugin,
+  getInstalledPlugin,
+  getConnectorsForPlugin,
+} from '@/lib/plugins/registry';
+import { expandSettingsTokens } from '@/lib/plugins/templates';
+import type { Connector, ConnectorTool } from '@/lib/plugins/types';
+
+export interface ToolCall {
+  id: string;
+  name: string;
+  input: unknown;
+}
+
+export interface ToolResult {
+  content: string;
+  is_error?: boolean;
+}
+
+// ─── Builtins ─────────────────────────────────────────────
+
+export type BuiltinHandler = (input: unknown) => Promise<string>;
+
+const BUILTINS: Record<string, BuiltinHandler> = {
+  get_current_time: async () => new Date().toISOString(),
+};
+
+export interface BuiltinToolDef {
+  name: string;
+  description: string;
+  input_schema: { type: 'object'; properties: Record<string, unknown>; required?: string[] };
+}
+
+export const BUILTIN_TOOL_DEFS: BuiltinToolDef[] = [
+  {
+    name: 'get_current_time',
+    description: 'Get the current local time as an ISO 8601 string. Use whenever the user asks about "now" or "today".',
+    input_schema: { type: 'object', properties: {} },
+  },
+];
+
+// ─── Connector dispatch ──────────────────────────────────
+
+/** Look up a connector tool by `<plugin_id>.<tool_name>` form. */
+function findConnectorTool(qualified: string): {
+  pluginId: string;
+  toolName: string;
+  entry: Connector;
+  tool: ConnectorTool;
+  settings: Record<string, any>;
+} | null {
+  const dot = qualified.indexOf('.');
+  if (dot < 1) return null;
+  const pluginId = qualified.slice(0, dot);
+  const toolName = qualified.slice(dot + 1);
+  const def = getPlugin(pluginId);
+  if (!def || def.category !== 'connector') return null;
+  const entries = getConnectorsForPlugin(def);
+  for (const entry of entries) {
+    const tool = entry.tools?.[toolName];
+    if (tool) {
+      const inst = getInstalledPlugin(pluginId);
+      return { pluginId, toolName, entry, tool, settings: inst?.config || {} };
+    }
+  }
+  return null;
+}
+
+/**
+ * Build the ConnectorPayload-ish object the extension's runner expects.
+ * Expands {base_url}/{settings.*} tokens here; {args.*} stays literal —
+ * the extension's runner finishes those at execution time.
+ */
+function buildConnectorPayload(
+  def: { id: string; name: string; mode?: string; runner?: 'main' | 'isolated'; host_match?: string; login_redirect?: string },
+  entry: Connector,
+  settings: Record<string, any>,
+) {
+  const expand = (s: string | undefined) => (s ? expandSettingsTokens(s, settings) : s);
+  const hostMatch = expand(entry.host_match || def.host_match);
+  const loginRedirect = expand(entry.login_redirect || def.login_redirect);
+
+  // Build entries with expanded page URLs
+  const expandedEntry: any = {
+    ...entry,
+    host_match: hostMatch,
+    login_redirect: loginRedirect,
+    tools: Object.fromEntries(
+      Object.entries(entry.tools || {}).map(([n, t]: [string, any]) => [
+        n,
+        {
+          ...t,
+          page: t.page
+            ? {
+                url: expand(t.page.url),
+                ...(t.page.on_target ? { on_target: expand(t.page.on_target) } : {}),
+                ...(t.page.settle_after_load_ms != null ? { settle_after_load_ms: t.page.settle_after_load_ms } : {}),
+              }
+            : undefined,
+        },
+      ]),
+    ),
+  };
+
+  return {
+    plugin_id: def.id,
+    name: def.name,
+    mode: def.mode || 'browser-side',
+    installed: true,
+    host_match: hostMatch,
+    login_redirect: loginRedirect,
+    runner: def.runner || entry.runner || 'main',
+    entries: [expandedEntry],
+  };
+}
+
+// ─── Public entry ─────────────────────────────────────────
+
+export async function dispatchTool(
+  call: ToolCall,
+  /** Per-turn extra builtins (e.g. memory_* when Temper is configured). */
+  extraBuiltins?: Record<string, BuiltinHandler>,
+): Promise<ToolResult> {
+  // Per-turn builtins first (memory tools), then global builtins.
+  const dynBuiltin = extraBuiltins?.[call.name];
+  if (dynBuiltin) {
+    try { return { content: await dynBuiltin(call.input) }; }
+    catch (e) { return { content: `tool '${call.name}' failed: ${(e as Error).message}`, is_error: true }; }
+  }
+  const builtin = BUILTINS[call.name];
+  if (builtin) {
+    try {
+      const content = await builtin(call.input);
+      return { content };
+    } catch (e) {
+      return { content: `builtin tool '${call.name}' failed: ${(e as Error).message}`, is_error: true };
+    }
+  }
+
+  // Connector tool
+  const located = findConnectorTool(call.name);
+  if (!located) {
+    return { content: `unknown tool: ${call.name}`, is_error: true };
+  }
+
+  const def = getPlugin(located.pluginId)!;
+  const protocol = located.tool.protocol || 'browser';
+  const argInput = (call.input ?? {}) as Record<string, any>;
+
+  try {
+    switch (protocol) {
+      case 'http':
+        return await runHttp({ tool: located.tool, settings: located.settings, args: argInput });
+      case 'shell':
+        return await runShell({ tool: located.tool, settings: located.settings, args: argInput });
+      case 'browser': {
+        // Hand the whole connector + tool spec + input + settings to the
+        // extension's runner.ts via the bridge. The extension keeps owning
+        // the runner logic (tab acquire, navigate, executeScript).
+        const connector = buildConnectorPayload(def, located.entry, located.settings);
+        const result = (await bridgeRpc('connector.run', {
+          pluginId: located.pluginId,
+          toolName: located.toolName,
+          input: argInput,
+          connector,
+          settings: located.settings,
+        })) as { content?: string; is_error?: boolean } | null;
+        return { content: result?.content ?? '(no content returned)', is_error: !!result?.is_error };
+      }
+      default:
+        return { content: `unknown protocol "${protocol}" on tool ${call.name}`, is_error: true };
+    }
+  } catch (e) {
+    return { content: `connector tool failed: ${(e as Error).message}`, is_error: true };
+  }
+}

package/lib/chat/types.ts

@@ -0,0 +1,50 @@
+/**
+ * Chat types — shared between session store, LLM client, and HTTP API.
+ *
+ * Block shape mirrors the Anthropic Messages API (text / tool_use /
+ * tool_result) so the extension and Forge speak the same dialect.
+ */
+
+export type Role = 'user' | 'assistant';
+
+export interface TextBlock {
+  type: 'text';
+  text: string;
+}
+
+export interface ToolUseBlock {
+  type: 'tool_use';
+  id: string;
+  name: string;
+  input: unknown;
+}
+
+export interface ToolResultBlock {
+  type: 'tool_result';
+  tool_use_id: string;
+  content: string;
+  is_error?: boolean;
+}
+
+export type ContentBlock = TextBlock | ToolUseBlock | ToolResultBlock;
+
+export interface Message {
+  id: string;
+  session_id: string;
+  role: Role;
+  blocks: ContentBlock[];
+  ts: number;
+  error?: string;
+}
+
+export interface Session {
+  id: string;
+  title: string | null;
+  created_at: number;
+  updated_at: number;
+  model: string | null;
+  provider: string | null;
+  system_prompt: string | null;
+  /** Free-form metadata (e.g. linked workspace, project, etc.) */
+  meta?: Record<string, unknown>;
+}