@nevescloud/pip 2.11.0

package/runtime.esm.js

@@ -0,0 +1,386 @@
+// pip-runtime — turn loop, tool dispatch, history, slash commands.
+// Plug into pip-core via createPip({ onSubmit: rt.onSubmit, onSlash: rt.onSlash }).
+// See docs/RUNTIME.md for the full design.
+
+const DEFAULT_MAX_TURNS = 5;
+const DEFAULT_HISTORY_LIMIT = 20;
+
+export function createRuntime({
+  provider,
+  models = [],
+  systemPrompt = '',
+  tools = [],
+  maxTurns = DEFAULT_MAX_TURNS,
+  historyLimit = DEFAULT_HISTORY_LIMIT,
+  historyKey = null,
+  preprocess = null,
+} = {}) {
+  if (!provider && !models.length) {
+    throw new Error('createRuntime: `provider` or `models` is required');
+  }
+
+  const systemFn = typeof systemPrompt === 'function' ? systemPrompt : () => systemPrompt;
+  const registeredTools = new Map();
+  for (const t of tools) registeredTools.set(t.name, t);
+  const registeredSlash = new Map();
+
+  let messages = [];
+  let currentProvider = provider || models[0].provider;
+  // If `provider` was passed explicitly and matches one of the models by
+  // reference, surface its name as current. Otherwise the first model wins.
+  let currentModelName = provider
+    ? (models.find((m) => m.provider === provider)?.name || null)
+    : (models[0]?.name || null);
+  let abortCtrl = null;
+  const listeners = new Map();
+
+  if (historyKey) {
+    try {
+      const saved = localStorage.getItem(historyKey);
+      if (saved) messages = JSON.parse(saved);
+    } catch {}
+  }
+
+  function emit(name, payload) {
+    const set = listeners.get(name);
+    if (!set) return;
+    for (const fn of set) {
+      try { fn(payload); } catch (e) {
+        console.warn(`[pip-runtime] handler for "${name}" threw`, e);
+      }
+    }
+  }
+
+  function on(name, handler) {
+    if (!listeners.has(name)) listeners.set(name, new Set());
+    listeners.get(name).add(handler);
+    return () => listeners.get(name).delete(handler);
+  }
+
+  function persist() {
+    if (!historyKey) return;
+    try { localStorage.setItem(historyKey, JSON.stringify(messages)); } catch {}
+  }
+
+  function trim() {
+    // Cap by index, not by role count — assistant tool turns and user
+    // tool_result turns are part of the same compound exchange.
+    const cap = historyLimit * 4;
+    if (messages.length > cap) messages = messages.slice(-cap);
+  }
+
+  function buildToolList() {
+    return Array.from(registeredTools.values()).map((t) => ({
+      name: t.name,
+      description: t.description,
+      schema: t.schema || t.input_schema,
+    }));
+  }
+
+  async function onSubmit(text, pipCtx) {
+    let processed = text;
+    if (preprocess) {
+      try { processed = await preprocess(text, pipCtx); }
+      catch (e) {
+        console.warn('[pip-runtime] preprocess threw, using raw text', e);
+        processed = text;
+      }
+    }
+    messages.push({ role: 'user', content: processed });
+    return runTurnLoop(pipCtx, processed);
+  }
+
+  async function regenerate(pipCtx) {
+    // Drop trailing assistant turns and tool exchanges until we're back at a
+    // user-text turn, then re-run from there.
+    while (messages.length > 0) {
+      const last = messages[messages.length - 1];
+      if (last.role === 'user' && typeof last.content === 'string') break;
+      messages.pop();
+    }
+    if (messages.length === 0) {
+      throw new Error('regenerate: no user turn in history');
+    }
+    return runTurnLoop(pipCtx, messages[messages.length - 1].content);
+  }
+
+  async function runTurnLoop(pipCtx, userText) {
+    const turnEl = pipCtx?.turnEl;
+    const setReplyText = pipCtx?.setReplyText;
+
+    abortCtrl = new AbortController();
+    emit('turnStart', { turnEl, userText });
+
+    let buffer = '';
+    let lastStopReason = null;
+
+    try {
+      for (let turn = 0; turn < maxTurns; turn++) {
+        const stream = currentProvider({
+          messages: messages.slice(),
+          tools: buildToolList(),
+          system: systemFn(),
+          signal: abortCtrl.signal,
+        });
+
+        const assistantContent = [];
+        let textPart = '';
+
+        for await (const ev of stream) {
+          if (ev.type === 'text_delta') {
+            textPart += ev.text;
+            buffer += ev.text;
+            if (setReplyText && turnEl) setReplyText(turnEl, buffer, true);
+            emit('text_delta', { turnEl, delta: ev.text, full: buffer });
+          } else if (ev.type === 'tool_use') {
+            if (textPart) {
+              assistantContent.push({ type: 'text', text: textPart });
+              textPart = '';
+            }
+            assistantContent.push({ type: 'tool_use', id: ev.id, name: ev.name, input: ev.input });
+            emit('toolCall', { turnEl, name: ev.name, input: ev.input, id: ev.id });
+          } else if (ev.type === 'turn_end') {
+            if (textPart) {
+              assistantContent.push({ type: 'text', text: textPart });
+              textPart = '';
+            }
+            lastStopReason = ev.stopReason;
+            emit('turnEnd', { turnEl, stopReason: ev.stopReason, usage: ev.usage });
+          }
+        }
+
+        if (assistantContent.length) {
+          messages.push({ role: 'assistant', content: assistantContent });
+        }
+
+        if (lastStopReason !== 'tool_use') break;
+
+        const toolUses = assistantContent.filter((b) => b.type === 'tool_use');
+        const toolResults = [];
+        for (const tu of toolUses) {
+          const tool = registeredTools.get(tu.name);
+          if (!tool) {
+            const err = `Tool "${tu.name}" not registered`;
+            toolResults.push({
+              type: 'tool_result',
+              tool_use_id: tu.id,
+              content: err,
+              is_error: true,
+            });
+            emit('toolResult', { turnEl, name: tu.name, ok: false, error: err, id: tu.id });
+            continue;
+          }
+          try {
+            const ctx = {
+              signal: abortCtrl.signal,
+              turnId: tu.id,
+              runtime: handle,
+            };
+            const result = await tool.handler(tu.input, ctx);
+            const content = typeof result === 'string' ? result : JSON.stringify(result);
+            toolResults.push({ type: 'tool_result', tool_use_id: tu.id, content });
+            emit('toolResult', { turnEl, name: tu.name, ok: true, result, id: tu.id });
+          } catch (err) {
+            const msg = err && err.message ? err.message : String(err);
+            toolResults.push({
+              type: 'tool_result',
+              tool_use_id: tu.id,
+              content: msg,
+              is_error: true,
+            });
+            emit('toolResult', { turnEl, name: tu.name, ok: false, error: err, id: tu.id });
+          }
+        }
+        messages.push({ role: 'user', content: toolResults });
+      }
+
+      trim();
+      persist();
+      return buffer.trim();
+    } catch (err) {
+      if (err?.name === 'AbortError') {
+        emit('error', { turnEl, error: err });
+        return buffer.trim() || '(cancelled)';
+      }
+      emit('error', { turnEl, error: err });
+      throw err;
+    } finally {
+      abortCtrl = null;
+    }
+  }
+
+  // Registry-first dispatch. Host-registered commands win over built-ins
+  // so `/help` can be overridden if a host wants different formatting.
+  // Built-in `/help` enumerates both layers so users see one combined list.
+  function onSlash(text) {
+    const slice = text.slice(1);
+    const sp = slice.indexOf(' ');
+    const cmdRaw = sp === -1 ? slice : slice.slice(0, sp);
+    const args = sp === -1 ? '' : slice.slice(sp + 1);
+    const cmd = cmdRaw.toLowerCase();
+
+    const registered = registeredSlash.get(cmd);
+    if (registered) {
+      try { return registered.handler(args) ?? null; }
+      catch (e) { return { reply: `\`/${cmd}\` failed: ${e.message || e}` }; }
+    }
+
+    if (cmd === 'clear' || cmd === 'reset') {
+      messages = [];
+      persist();
+      return { clearedUI: true };
+    }
+    if (cmd === 'tools') {
+      const list = Array.from(registeredTools.values())
+        .map((t) => `\`${t.name}\` — ${t.description || ''}`)
+        .join('\n');
+      return { reply: list ? '**Tools:**\n' + list : 'No tools registered.' };
+    }
+    if (cmd === 'model' && models.length) {
+      const arg = args.trim();
+      if (!arg) {
+        const cur = currentModelName ? `\`${currentModelName}\`` : '(unknown)';
+        const others = models
+          .filter((m) => m.name !== currentModelName)
+          .map((m) => `\`${m.name}\``);
+        const tail = others.length ? ` Switch with \`/model <name>\` — try ${others.join(', ')}.` : '';
+        return { reply: `Current model: ${cur}.${tail}` };
+      }
+      const target = models.find((m) => m.name.toLowerCase() === arg.toLowerCase());
+      if (!target) {
+        const all = models.map((m) => `\`${m.name}\``).join(', ');
+        return { reply: `Unknown model \`${arg}\`. One of: ${all}` };
+      }
+      setModel(target.name);
+      const suffix = target.label ? ` (${target.label})` : '';
+      return { reply: `Switched to \`${target.name}\`${suffix}.` };
+    }
+    if (cmd === 'help' || cmd === '?') {
+      const lines = ['**Commands:**'];
+      for (const s of registeredSlash.values()) {
+        lines.push(`- \`/${s.name}\` — ${s.description || ''}`);
+      }
+      lines.push('- `/clear` — reset conversation');
+      lines.push('- `/tools` — list registered tools');
+      if (models.length) lines.push('- `/model` — list or switch active model');
+      lines.push('- `/help` — this list');
+      return { reply: lines.join('\n') };
+    }
+    return null;
+  }
+
+  function registerTool(t) {
+    if (!t || !t.name || typeof t.handler !== 'function') {
+      throw new Error('registerTool: { name, handler } required');
+    }
+    registeredTools.set(t.name, t);
+  }
+
+  function unregisterTool(name) {
+    registeredTools.delete(name);
+  }
+
+  // Slash commands. Same shape as registerTool: name + handler are required;
+  // description and complete() are surfaced by autocomplete + /help.
+  // handler(argsString) returns { reply?, clearedUI?, passThrough? } | null.
+  function registerSlash(s) {
+    if (!s || !s.name || typeof s.handler !== 'function') {
+      throw new Error('registerSlash: { name, handler } required');
+    }
+    registeredSlash.set(s.name.toLowerCase(), s);
+  }
+
+  function unregisterSlash(name) {
+    registeredSlash.delete(String(name).toLowerCase());
+  }
+
+  // Source for pip-core's autocomplete dropdown. Combines registered +
+  // built-ins so users see one merged list as they type. /model is only
+  // surfaced when the host configured a model registry.
+  function builtinSlash() {
+    const out = [
+      { name: 'clear', description: 'reset conversation' },
+      { name: 'tools', description: 'list registered tools' },
+    ];
+    if (models.length) {
+      out.push({
+        name: 'model',
+        description: 'list or switch active model',
+        complete: (partial) => models
+          .map((m) => m.name)
+          .filter((n) => n.toLowerCase().startsWith(partial.toLowerCase())),
+      });
+    }
+    out.push({ name: 'help', description: 'list commands' });
+    return out;
+  }
+  function slashSource() {
+    const out = [];
+    for (const s of registeredSlash.values()) out.push({ name: s.name, description: s.description, complete: s.complete });
+    for (const b of builtinSlash()) if (!registeredSlash.has(b.name)) out.push(b);
+    return out;
+  }
+
+  function setProvider(p) {
+    currentProvider = p;
+    // A bare setProvider that doesn't pass through the model registry
+    // can't keep currentModelName in sync — clear it so /model bare
+    // doesn't lie about what's active.
+    currentModelName = models.find((m) => m.provider === p)?.name || null;
+    messages = [];
+    persist();
+    emit('providerSwitched', {
+      provider: p,
+      name: currentModelName,
+      label: currentModelName ? models.find((m) => m.name === currentModelName)?.label : undefined,
+    });
+  }
+
+  function setModel(name) {
+    const m = models.find((x) => x.name === name);
+    if (!m) throw new Error(`setModel: unknown model "${name}"`);
+    currentProvider = m.provider;
+    currentModelName = m.name;
+    messages = [];
+    persist();
+    emit('providerSwitched', { provider: m.provider, name: m.name, label: m.label });
+  }
+
+  function cancel() {
+    if (abortCtrl) abortCtrl.abort();
+  }
+
+  const handle = {
+    onSubmit,
+    onSlash,
+    slashSource,
+    regenerate,
+    registerTool,
+    unregisterTool,
+    registerSlash,
+    unregisterSlash,
+    setProvider,
+    setModel,
+    get currentModel() {
+      if (!currentModelName) return null;
+      const m = models.find((x) => x.name === currentModelName);
+      return m ? { name: m.name, label: m.label } : null;
+    },
+    cancel,
+    on,
+    history: {
+      snapshot: () => messages.slice(),
+      clear: () => { messages = []; persist(); },
+      truncate: (index) => {
+        if (typeof index !== 'number' || index < 0) return;
+        if (index < messages.length) {
+          messages.length = index;
+          persist();
+        }
+      },
+      get length() { return messages.length; },
+      get limit() { return historyLimit; },
+    },
+  };
+  return handle;
+}