bloby-bot 0.46.3 → 0.47.1

package/supervisor/harnesses/pi/providers/stream-google.ts

@@ -0,0 +1,156 @@
+/**
+ * Google Gemini streaming provider.
+ *
+ * Hand-written equivalent of the slice of pi-ai/providers/google.ts that bloby
+ * needs — text streaming via `:streamGenerateContent?alt=sse`. Function-calling
+ * is wired up in Phase 2; for now we drop tools and stream text only.
+ *
+ * Endpoint: POST {baseUrl}/models/{modelId}:streamGenerateContent?alt=sse&key={apiKey}
+ * Stream:   SSE — each `data: {...}` is one candidate update.
+ */
+import type {
+  PiStreamRequest,
+  PiStreamEvent,
+  PiMessage,
+  PiContentBlock,
+  PiStopReason,
+} from './types.js';
+
+/** Walk an SSE byte stream and yield each parsed JSON event. */
+async function* parseSse(res: Response): AsyncIterable<any> {
+  if (!res.body) return;
+  const reader = res.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = '';
+  try {
+    while (true) {
+      const { value, done } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      // SSE event boundary is a blank line. Process every complete event in buffer.
+      let idx;
+      while ((idx = buffer.indexOf('\n\n')) !== -1) {
+        const raw = buffer.slice(0, idx);
+        buffer = buffer.slice(idx + 2);
+        const dataLines = raw.split('\n').filter((l) => l.startsWith('data:'));
+        if (!dataLines.length) continue;
+        const data = dataLines.map((l) => l.slice(5).trimStart()).join('\n');
+        if (!data || data === '[DONE]') continue;
+        try {
+          yield JSON.parse(data);
+        } catch {
+          // Skip malformed chunks rather than killing the whole turn.
+        }
+      }
+    }
+  } finally {
+    try { reader.releaseLock(); } catch {}
+  }
+}
+
+function toGeminiRole(role: PiMessage['role']): 'user' | 'model' {
+  return role === 'assistant' ? 'model' : 'user';
+}
+
+function toGeminiParts(content: PiContentBlock[]): any[] {
+  const parts: any[] = [];
+  for (const b of content) {
+    if (b.type === 'text') parts.push({ text: b.text });
+    else if (b.type === 'image') parts.push({ inlineData: { mimeType: b.mediaType, data: b.data } });
+    // tool_use / tool_result are Phase 2.
+  }
+  return parts;
+}
+
+function mapStopReason(reason?: string): PiStopReason {
+  switch (reason) {
+    case 'STOP':
+    case 'FINISH_REASON_STOP':
+      return 'end_turn';
+    case 'MAX_TOKENS':
+      return 'max_tokens';
+    case 'SAFETY':
+    case 'RECITATION':
+    case 'OTHER':
+      return 'error';
+    default:
+      return 'end_turn';
+  }
+}
+
+export async function* streamGoogle(req: PiStreamRequest): AsyncIterable<PiStreamEvent> {
+  const url =
+    `${req.baseUrl.replace(/\/+$/, '')}/models/${encodeURIComponent(req.modelId)}:streamGenerateContent` +
+    `?alt=sse&key=${encodeURIComponent(req.apiKey)}`;
+
+  // Filter out empty messages — Gemini rejects requests with no user content.
+  const contents = req.messages
+    .filter((m) => m.content.length > 0)
+    .map((m) => ({ role: toGeminiRole(m.role), parts: toGeminiParts(m.content) }))
+    .filter((m) => m.parts.length > 0);
+
+  const body: any = {
+    contents,
+    generationConfig: {
+      maxOutputTokens: req.maxOutputTokens ?? 4096,
+    },
+  };
+  if (req.systemPrompt?.trim()) {
+    body.systemInstruction = { parts: [{ text: req.systemPrompt }] };
+  }
+
+  let res: Response;
+  try {
+    res = await fetch(url, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify(body),
+      signal: req.signal,
+    });
+  } catch (err: any) {
+    yield { type: 'error', error: err?.message || String(err) };
+    return;
+  }
+
+  if (!res.ok) {
+    let detail = '';
+    try { detail = await res.text(); } catch {}
+    yield { type: 'error', error: `Google ${res.status} ${res.statusText}${detail ? `: ${detail.slice(0, 400)}` : ''}` };
+    return;
+  }
+
+  let accumulated = '';
+  let lastFinish: string | undefined;
+  let usage: { inputTokens?: number; outputTokens?: number } | undefined;
+
+  try {
+    for await (const chunk of parseSse(res)) {
+      const candidate = chunk?.candidates?.[0];
+      const parts: any[] = candidate?.content?.parts || [];
+      for (const part of parts) {
+        if (typeof part?.text === 'string' && part.text.length > 0) {
+          accumulated += part.text;
+          yield { type: 'text_delta', delta: part.text };
+        }
+      }
+      if (candidate?.finishReason) lastFinish = candidate.finishReason;
+      const usageMeta = chunk?.usageMetadata;
+      if (usageMeta) {
+        usage = {
+          inputTokens: usageMeta.promptTokenCount,
+          outputTokens: usageMeta.candidatesTokenCount,
+        };
+      }
+    }
+  } catch (err: any) {
+    if (err?.name === 'AbortError') {
+      yield { type: 'done', stopReason: 'aborted' };
+      return;
+    }
+    yield { type: 'error', error: err?.message || String(err) };
+    return;
+  }
+
+  if (accumulated) yield { type: 'text_end', text: accumulated };
+  yield { type: 'done', stopReason: mapStopReason(lastFinish), usage };
+}

package/supervisor/harnesses/pi/providers/stream.ts

@@ -0,0 +1,21 @@
+/**
+ * Provider dispatcher.
+ *
+ * One function that turns a `(flavor, request)` into a `PiStreamEvent`
+ * AsyncIterable. The session loop only knows this entry point — provider
+ * choice happens here based on the sub-provider's `flavor` field.
+ */
+import type { PiApiFlavor } from '../sub-providers.js';
+import type { PiStreamRequest, PiStreamEvent } from './types.js';
+import { streamGoogle } from './stream-google.js';
+
+export function streamProvider(flavor: PiApiFlavor, req: PiStreamRequest): AsyncIterable<PiStreamEvent> {
+  switch (flavor) {
+    case 'google-gemini':
+      return streamGoogle(req);
+    case 'openai-completions':
+      throw new Error('openai-completions streaming is not implemented yet (Phase 3).');
+    case 'anthropic-messages':
+      throw new Error('anthropic-messages streaming is not implemented yet (Phase 3).');
+  }
+}

package/supervisor/harnesses/pi/providers/types.ts

@@ -0,0 +1,60 @@
+/**
+ * Provider-shared types for the pi harness.
+ *
+ * One unified message + event shape regardless of which underlying LLM API
+ * (Google Gemini, OpenAI-compatible /v1/chat/completions, Anthropic Messages)
+ * is handling the request. Each provider implements `streamProvider(req): AsyncIterable<StreamEvent>`
+ * and the session loop consumes the events without knowing the flavor.
+ *
+ * Modelled after pi-ai's event vocabulary (text_start/delta/end, toolcall_*,
+ * done, error) so we can copy fixes from upstream if needed, but only the
+ * fields bloby actually consumes are kept.
+ */
+
+export type PiRole = 'user' | 'assistant' | 'tool';
+
+/** A single content block inside a message. */
+export type PiContentBlock =
+  | { type: 'text'; text: string }
+  | { type: 'image'; mediaType: string; data: string }   // base64
+  | { type: 'tool_use'; id: string; name: string; input: any }
+  | { type: 'tool_result'; toolUseId: string; content: string; isError?: boolean };
+
+export interface PiMessage {
+  role: PiRole;
+  content: PiContentBlock[];
+}
+
+/** Schema for one tool the model can call. Plain JSON Schema for input. */
+export interface PiToolDef {
+  name: string;
+  description: string;
+  inputSchema: Record<string, any>;
+}
+
+export interface PiStreamRequest {
+  modelId: string;
+  baseUrl: string;
+  apiKey: string;
+  systemPrompt: string;
+  messages: PiMessage[];
+  tools?: PiToolDef[];
+  /** Hard cap on output tokens for a single turn. */
+  maxOutputTokens?: number;
+  /** Optional abort signal so the session can interrupt in-flight requests. */
+  signal?: AbortSignal;
+}
+
+export type PiStopReason = 'end_turn' | 'tool_use' | 'max_tokens' | 'error' | 'aborted';
+
+export type PiStreamEvent =
+  | { type: 'text_delta'; delta: string }
+  | { type: 'text_end'; text: string }
+  | { type: 'tool_use'; id: string; name: string; input: any }
+  | { type: 'done'; stopReason: PiStopReason; usage?: PiUsage }
+  | { type: 'error'; error: string };
+
+export interface PiUsage {
+  inputTokens?: number;
+  outputTokens?: number;
+}

package/supervisor/harnesses/pi/session.ts

@@ -0,0 +1,140 @@
+/**
+ * Pi agent session — the live conversation loop.
+ *
+ * Mirrors the *shape* of the Claude harness loop in `harnesses/claude.ts`:
+ *   - one long-lived session per conversation
+ *   - user messages arrive via an `AsyncQueue<PiMessage>` input
+ *   - the loop drains the queue one turn at a time
+ *   - each turn streams provider events back through a single `onEvent`
+ *     callback the caller hooked up
+ *
+ * Phase 1 scope: text-only, no tools. Each user turn = one provider call.
+ * Phase 2 will plug tools into the inner loop (model emits `tool_use` →
+ * execute → append `tool_result` → re-stream → repeat until `end_turn`).
+ *
+ * Phase 1 explicitly does NOT spawn sub-agents — Bruno will add those later.
+ */
+import { log } from '../../../shared/logger.js';
+import type { PiApiFlavor } from './sub-providers.js';
+import { streamProvider } from './providers/stream.js';
+import type { PiMessage, PiStreamEvent, PiToolDef } from './providers/types.js';
+import type { AsyncQueue } from './async-queue.js';
+
+export type PiSessionEvent =
+  | { type: 'turn_started' }
+  | { type: 'text_delta'; delta: string }
+  | { type: 'text_end'; text: string }
+  | { type: 'tool_use'; id: string; name: string; input: any }   // Phase 2
+  | { type: 'turn_complete'; usedFileTools: boolean }
+  | { type: 'error'; error: string };
+
+export interface PiSessionInit {
+  flavor: PiApiFlavor;
+  modelId: string;
+  baseUrl: string;
+  apiKey: string;
+  systemPrompt: string;
+  /** Pre-loaded history before the first new user turn. */
+  initialMessages?: PiMessage[];
+  /** Phase 2 wires this through. Empty for Phase 1. */
+  tools?: PiToolDef[];
+  maxOutputTokens?: number;
+  /** Used to interrupt in-flight provider calls when the session ends. */
+  abortController: AbortController;
+  /** Caller's event sink — translated to bloby's `bot:*` events one layer up. */
+  onEvent: (evt: PiSessionEvent) => void;
+}
+
+export interface PiSession {
+  /** Resolves when the loop exits (queue closed or aborted). */
+  run(input: AsyncQueue<PiMessage>): Promise<void>;
+  /** Cumulative history including prefilled context and live turns. */
+  getMessages(): PiMessage[];
+}
+
+const FILE_TOOL_NAMES = new Set(['Write', 'Edit', 'write', 'edit']);
+
+export function createPiSession(init: PiSessionInit): PiSession {
+  const messages: PiMessage[] = init.initialMessages ? [...init.initialMessages] : [];
+
+  async function runOneTurn(userMsg: PiMessage): Promise<void> {
+    if (init.abortController.signal.aborted) return;
+    messages.push(userMsg);
+    init.onEvent({ type: 'turn_started' });
+
+    let accumulated = '';
+    const usedTools = new Set<string>();
+    let errored = false;
+
+    try {
+      const stream = streamProvider(init.flavor, {
+        modelId: init.modelId,
+        baseUrl: init.baseUrl,
+        apiKey: init.apiKey,
+        systemPrompt: init.systemPrompt,
+        messages,
+        tools: init.tools,
+        maxOutputTokens: init.maxOutputTokens,
+        signal: init.abortController.signal,
+      });
+
+      for await (const evt of stream as AsyncIterable<PiStreamEvent>) {
+        if (init.abortController.signal.aborted) return;
+        switch (evt.type) {
+          case 'text_delta':
+            accumulated += evt.delta;
+            init.onEvent({ type: 'text_delta', delta: evt.delta });
+            break;
+          case 'text_end':
+            // Provider gives us the final accumulated text; trust the deltas
+            // we already forwarded and reconcile state from here.
+            accumulated = evt.text;
+            init.onEvent({ type: 'text_end', text: evt.text });
+            break;
+          case 'tool_use':
+            // Phase 2: execute the tool, append a tool_result message, re-stream.
+            usedTools.add(evt.name);
+            init.onEvent({ type: 'tool_use', id: evt.id, name: evt.name, input: evt.input });
+            break;
+          case 'error':
+            errored = true;
+            init.onEvent({ type: 'error', error: evt.error });
+            break;
+          case 'done':
+            // Loop back if the model is waiting on a tool result (Phase 2);
+            // for now `tool_use` is impossible since we don't pass tools.
+            break;
+        }
+      }
+    } catch (err: any) {
+      if (init.abortController.signal.aborted) return;
+      errored = true;
+      init.onEvent({ type: 'error', error: err?.message || String(err) });
+    }
+
+    if (accumulated) {
+      messages.push({ role: 'assistant', content: [{ type: 'text', text: accumulated }] });
+    }
+    if (!errored) {
+      const usedFileTools = Array.from(usedTools).some((t) => FILE_TOOL_NAMES.has(t));
+      init.onEvent({ type: 'turn_complete', usedFileTools });
+    }
+  }
+
+  return {
+    async run(input) {
+      for await (const userMsg of input) {
+        if (init.abortController.signal.aborted) break;
+        try {
+          await runOneTurn(userMsg);
+        } catch (err: any) {
+          log.warn(`[pi/session] Turn failed: ${err?.message || err}`);
+          init.onEvent({ type: 'error', error: err?.message || String(err) });
+        }
+      }
+    },
+    getMessages() {
+      return messages;
+    },
+  };
+}

package/supervisor/harnesses/pi/sub-providers.ts

@@ -0,0 +1,191 @@
+/**
+ * Pi sub-provider catalog.
+ *
+ * The Bloby (pi) harness is a meta-provider: the user picks an underlying LLM
+ * vendor and supplies their own credentials. This file enumerates the set we
+ * currently support in the onboarding wizard plus enough metadata to drive the
+ * test-completion call without per-provider branching at the call site.
+ *
+ * Iteration 1 scope: API-key flows only. OAuth-based sub-providers (Anthropic
+ * Pro/Max, GitHub Copilot, OpenAI Codex) are deliberately out of scope — they
+ * duplicate auth flows we already ship under the dedicated Claude and OpenAI
+ * Codex harnesses.
+ *
+ * Per-provider model lists come from `models-catalog.generated.ts`, which is
+ * synced from upstream pi via `npm run sync:pi-models`. Sub-providers without
+ * a pi mapping (Ollama, LM Studio, custom) stay `'dynamic'` — free-form ID.
+ */
+import { PI_MODELS_CATALOG } from './models-catalog.generated.js';
+
+export type PiApiFlavor = 'openai-completions' | 'anthropic-messages' | 'google-gemini';
+
+export interface PiSubProviderModel {
+  id: string;
+  label: string;
+}
+
+export interface PiSubProvider {
+  id: string;
+  name: string;
+  subtitle: string;
+  flavor: PiApiFlavor;
+  /** Default base URL — Ollama / LM Studio / custom let the user override it. */
+  baseUrl?: string;
+  /** Whether the user must supply a base URL (Ollama, LM Studio, custom). */
+  needsBaseUrl?: boolean;
+  /** Whether the user must supply an API key. Ollama defaults to false. */
+  needsApiKey?: boolean;
+  /** Optional: where to obtain a key (shown as a help link). */
+  apiKeyUrl?: string;
+  /** Hand-curated model list. `dynamic` ⇒ free-form ID input. */
+  models: PiSubProviderModel[] | 'dynamic';
+  /** Default model selection when the user hasn't picked one. */
+  defaultModel?: string;
+}
+
+function fromCatalog(key: string): PiSubProviderModel[] | 'dynamic' {
+  const list = PI_MODELS_CATALOG[key];
+  return list && list.length > 0 ? list : 'dynamic';
+}
+
+function defaultFor(key: string): string | undefined {
+  return PI_MODELS_CATALOG[key]?.[0]?.id;
+}
+
+export const PI_SUB_PROVIDERS: PiSubProvider[] = [
+  {
+    id: 'google',
+    name: 'Google Gemini',
+    subtitle: 'AI Studio API key',
+    flavor: 'google-gemini',
+    baseUrl: 'https://generativelanguage.googleapis.com/v1beta',
+    needsApiKey: true,
+    apiKeyUrl: 'https://aistudio.google.com/apikey',
+    models: fromCatalog('google'),
+    defaultModel: defaultFor('google'),
+  },
+  {
+    id: 'deepseek',
+    name: 'DeepSeek',
+    subtitle: 'deepseek.com API',
+    flavor: 'openai-completions',
+    baseUrl: 'https://api.deepseek.com/v1',
+    needsApiKey: true,
+    apiKeyUrl: 'https://platform.deepseek.com/api_keys',
+    models: fromCatalog('deepseek'),
+    defaultModel: defaultFor('deepseek'),
+  },
+  {
+    id: 'groq',
+    name: 'Groq',
+    subtitle: 'Fast inference (Llama / Kimi / Qwen)',
+    flavor: 'openai-completions',
+    baseUrl: 'https://api.groq.com/openai/v1',
+    needsApiKey: true,
+    apiKeyUrl: 'https://console.groq.com/keys',
+    models: fromCatalog('groq'),
+    defaultModel: defaultFor('groq'),
+  },
+  {
+    id: 'xai',
+    name: 'xAI (Grok)',
+    subtitle: 'x.ai API',
+    flavor: 'openai-completions',
+    baseUrl: 'https://api.x.ai/v1',
+    needsApiKey: true,
+    apiKeyUrl: 'https://console.x.ai/',
+    models: fromCatalog('xai'),
+    defaultModel: defaultFor('xai'),
+  },
+  {
+    id: 'cerebras',
+    name: 'Cerebras',
+    subtitle: 'Wafer-scale inference',
+    flavor: 'openai-completions',
+    baseUrl: 'https://api.cerebras.ai/v1',
+    needsApiKey: true,
+    apiKeyUrl: 'https://cloud.cerebras.ai/?tab=api-keys',
+    models: fromCatalog('cerebras'),
+    defaultModel: defaultFor('cerebras'),
+  },
+  {
+    id: 'openrouter',
+    name: 'OpenRouter',
+    subtitle: 'Aggregator: 300+ models, one key',
+    flavor: 'openai-completions',
+    baseUrl: 'https://openrouter.ai/api/v1',
+    needsApiKey: true,
+    apiKeyUrl: 'https://openrouter.ai/keys',
+    // OpenRouter has 270+ entries — too many to list. Free-form ID input instead.
+    models: 'dynamic',
+    defaultModel: 'anthropic/claude-sonnet-4',
+  },
+  {
+    id: 'mistral',
+    name: 'Mistral',
+    subtitle: 'mistral.ai API',
+    flavor: 'openai-completions',
+    baseUrl: 'https://api.mistral.ai/v1',
+    needsApiKey: true,
+    apiKeyUrl: 'https://console.mistral.ai/api-keys/',
+    models: fromCatalog('mistral'),
+    defaultModel: defaultFor('mistral'),
+  },
+  {
+    id: 'openai-api',
+    name: 'OpenAI (API key)',
+    subtitle: 'platform.openai.com',
+    flavor: 'openai-completions',
+    baseUrl: 'https://api.openai.com/v1',
+    needsApiKey: true,
+    apiKeyUrl: 'https://platform.openai.com/api-keys',
+    models: fromCatalog('openai-api'),
+    defaultModel: defaultFor('openai-api'),
+  },
+  {
+    id: 'anthropic-api',
+    name: 'Anthropic (API key)',
+    subtitle: 'console.anthropic.com',
+    flavor: 'anthropic-messages',
+    baseUrl: 'https://api.anthropic.com/v1',
+    needsApiKey: true,
+    apiKeyUrl: 'https://console.anthropic.com/settings/keys',
+    models: fromCatalog('anthropic-api'),
+    defaultModel: defaultFor('anthropic-api'),
+  },
+  {
+    id: 'ollama',
+    name: 'Ollama',
+    subtitle: 'Local — http://localhost:11434',
+    flavor: 'openai-completions',
+    baseUrl: 'http://localhost:11434/v1',
+    needsBaseUrl: true,
+    needsApiKey: false,
+    apiKeyUrl: 'https://ollama.com/library',
+    models: 'dynamic',
+    defaultModel: 'llama3.1',
+  },
+  {
+    id: 'lm-studio',
+    name: 'LM Studio',
+    subtitle: 'Local — http://localhost:1234',
+    flavor: 'openai-completions',
+    baseUrl: 'http://localhost:1234/v1',
+    needsBaseUrl: true,
+    needsApiKey: false,
+    models: 'dynamic',
+  },
+  {
+    id: 'custom',
+    name: 'Custom (OpenAI-compatible)',
+    subtitle: 'Any /v1/chat/completions endpoint',
+    flavor: 'openai-completions',
+    needsBaseUrl: true,
+    needsApiKey: true,
+    models: 'dynamic',
+  },
+];
+
+export function getPiSubProvider(id: string): PiSubProvider | undefined {
+  return PI_SUB_PROVIDERS.find((p) => p.id === id);
+}