bloby-bot 0.46.3 → 0.47.1

package/supervisor/harnesses/pi/test-completion.ts

@@ -0,0 +1,196 @@
+/**
+ * Pi test-completion — single-shot, non-streaming completion call.
+ *
+ * Iteration 1 of the pi harness: just enough to verify the saved sub-provider
+ * + credentials actually reach an LLM and return text. Replaces the full
+ * pi-ai streaming stack until we vendor it alongside the agent loop.
+ *
+ * Supported API flavors:
+ *   - openai-completions  → POST {baseUrl}/chat/completions
+ *   - anthropic-messages  → POST {baseUrl}/messages
+ *   - google-gemini       → POST {baseUrl}/models/{modelId}:generateContent
+ */
+import { getPiSubProvider, type PiApiFlavor } from './sub-providers.js';
+
+export interface PiTestCompletionInput {
+  subProvider: string;
+  apiKey?: string;
+  baseUrl?: string;
+  modelId?: string;
+  prompt: string;
+}
+
+export interface PiTestCompletionResult {
+  ok: boolean;
+  text?: string;
+  error?: string;
+  status?: number;
+  modelId?: string;
+  subProvider?: string;
+}
+
+const REQUEST_TIMEOUT_MS = 30_000;
+
+async function timedFetch(url: string, init: RequestInit): Promise<Response> {
+  const ctl = new AbortController();
+  const timer = setTimeout(() => ctl.abort(), REQUEST_TIMEOUT_MS);
+  try {
+    return await fetch(url, { ...init, signal: ctl.signal });
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+function pickBaseUrl(input: PiTestCompletionInput): string | undefined {
+  if (input.baseUrl?.trim()) return input.baseUrl.replace(/\/+$/, '');
+  const def = getPiSubProvider(input.subProvider)?.baseUrl;
+  return def?.replace(/\/+$/, '');
+}
+
+function pickModelId(input: PiTestCompletionInput): string | undefined {
+  if (input.modelId?.trim()) return input.modelId.trim();
+  return getPiSubProvider(input.subProvider)?.defaultModel;
+}
+
+export async function runPiTestCompletion(input: PiTestCompletionInput): Promise<PiTestCompletionResult> {
+  const provider = getPiSubProvider(input.subProvider);
+  if (!provider) {
+    return { ok: false, error: `Unknown sub-provider: ${input.subProvider}` };
+  }
+
+  const baseUrl = pickBaseUrl(input);
+  if (!baseUrl) return { ok: false, error: 'Missing base URL' };
+
+  const modelId = pickModelId(input);
+  if (!modelId) return { ok: false, error: 'Missing model ID' };
+
+  if (provider.needsApiKey && !input.apiKey?.trim()) {
+    return { ok: false, error: 'Missing API key' };
+  }
+
+  try {
+    const text = await callByFlavor(provider.flavor, {
+      baseUrl,
+      modelId,
+      apiKey: input.apiKey?.trim() || '',
+      prompt: input.prompt,
+    });
+    return { ok: true, text, modelId, subProvider: provider.id };
+  } catch (err: any) {
+    return {
+      ok: false,
+      error: err?.message || String(err),
+      status: err?.status,
+      modelId,
+      subProvider: provider.id,
+    };
+  }
+}
+
+interface DispatchArgs {
+  baseUrl: string;
+  modelId: string;
+  apiKey: string;
+  prompt: string;
+}
+
+async function callByFlavor(flavor: PiApiFlavor, args: DispatchArgs): Promise<string> {
+  switch (flavor) {
+    case 'openai-completions':
+      return callOpenAICompletions(args);
+    case 'anthropic-messages':
+      return callAnthropicMessages(args);
+    case 'google-gemini':
+      return callGoogleGemini(args);
+  }
+}
+
+/* ── OpenAI / OpenAI-compatible ── */
+
+async function callOpenAICompletions({ baseUrl, modelId, apiKey, prompt }: DispatchArgs): Promise<string> {
+  const headers: Record<string, string> = { 'content-type': 'application/json' };
+  if (apiKey) headers['authorization'] = `Bearer ${apiKey}`;
+
+  const res = await timedFetch(`${baseUrl}/chat/completions`, {
+    method: 'POST',
+    headers,
+    body: JSON.stringify({
+      model: modelId,
+      messages: [{ role: 'user', content: prompt }],
+      max_tokens: 256,
+      stream: false,
+    }),
+  });
+
+  if (!res.ok) throw await httpError(res);
+
+  const body: any = await res.json();
+  const text = body?.choices?.[0]?.message?.content;
+  if (typeof text !== 'string' || !text.trim()) {
+    throw new Error(`Empty response (${JSON.stringify(body).slice(0, 200)})`);
+  }
+  return text.trim();
+}
+
+/* ── Anthropic Messages API ── */
+
+async function callAnthropicMessages({ baseUrl, modelId, apiKey, prompt }: DispatchArgs): Promise<string> {
+  const res = await timedFetch(`${baseUrl}/messages`, {
+    method: 'POST',
+    headers: {
+      'content-type': 'application/json',
+      'x-api-key': apiKey,
+      'anthropic-version': '2023-06-01',
+    },
+    body: JSON.stringify({
+      model: modelId,
+      max_tokens: 256,
+      messages: [{ role: 'user', content: prompt }],
+    }),
+  });
+
+  if (!res.ok) throw await httpError(res);
+
+  const body: any = await res.json();
+  const block = Array.isArray(body?.content)
+    ? body.content.find((b: any) => b?.type === 'text')
+    : null;
+  const text = block?.text;
+  if (typeof text !== 'string' || !text.trim()) {
+    throw new Error(`Empty response (${JSON.stringify(body).slice(0, 200)})`);
+  }
+  return text.trim();
+}
+
+/* ── Google Gemini ── */
+
+async function callGoogleGemini({ baseUrl, modelId, apiKey, prompt }: DispatchArgs): Promise<string> {
+  const url = `${baseUrl}/models/${encodeURIComponent(modelId)}:generateContent?key=${encodeURIComponent(apiKey)}`;
+  const res = await timedFetch(url, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify({
+      contents: [{ role: 'user', parts: [{ text: prompt }] }],
+      generationConfig: { maxOutputTokens: 256 },
+    }),
+  });
+
+  if (!res.ok) throw await httpError(res);
+
+  const body: any = await res.json();
+  const parts: any[] = body?.candidates?.[0]?.content?.parts || [];
+  const text = parts.map((p) => p?.text).filter(Boolean).join('\n').trim();
+  if (!text) throw new Error(`Empty response (${JSON.stringify(body).slice(0, 200)})`);
+  return text;
+}
+
+/* ── Helpers ── */
+
+async function httpError(res: Response): Promise<Error> {
+  let detail = '';
+  try { detail = await res.text(); } catch {}
+  const trimmed = detail.length > 400 ? `${detail.slice(0, 400)}…` : detail;
+  const err: any = new Error(`HTTP ${res.status} ${res.statusText}${trimmed ? `: ${trimmed}` : ''}`);
+  err.status = res.status;
+  return err;
+}

package/supervisor/index.ts

@@ -351,6 +351,12 @@ export async function startSupervisor() {
     'POST /api/auth/codex/start',
     'POST /api/auth/codex/cancel',
     'GET /api/auth/codex/status',
+    'GET /api/auth/pi/providers',
+    'GET /api/auth/pi/status',
+    'POST /api/auth/pi/test',
+    'POST /api/auth/pi/save',
+    'DELETE /api/auth/pi',
+    'POST /api/auth/pi/completion',
     'POST /api/portal/totp/setup',
     'POST /api/portal/totp/verify-setup',
     'POST /api/portal/totp/disable',

package/worker/index.ts

@@ -16,6 +16,9 @@ import {
 import { startClaudeOAuth, exchangeClaudeCode, getClaudeAuthStatus, readClaudeAccessToken } from './claude-auth.js';
 import { checkAvailability, registerHandle, claimReservedHandle, releaseHandle, updateTunnelUrl, startHeartbeat, stopHeartbeat } from '../shared/relay.js';
 import { ensureFileDirs } from '../supervisor/file-saver.js';
+import { readPiAuth, writePiAuth, clearPiAuth, getPiAuthStatus } from '../supervisor/harnesses/pi/auth-storage.js';
+import { runPiTestCompletion } from '../supervisor/harnesses/pi/test-completion.js';
+import { PI_SUB_PROVIDERS, getPiSubProvider } from '../supervisor/harnesses/pi/sub-providers.js';
 
 // ── Password hashing (scrypt) ──
 
@@ -228,6 +231,89 @@ app.get('/api/auth/claude/status', async (_req, res) => {
   res.json(await getClaudeAuthStatus());
 });
 
+// ── Pi (Bloby third harness) auth routes ──
+
+app.get('/api/auth/pi/providers', (_req, res) => {
+  res.json({
+    providers: PI_SUB_PROVIDERS.map((p) => ({
+      id: p.id,
+      name: p.name,
+      subtitle: p.subtitle,
+      flavor: p.flavor,
+      baseUrl: p.baseUrl,
+      needsBaseUrl: !!p.needsBaseUrl,
+      needsApiKey: p.needsApiKey !== false,
+      apiKeyUrl: p.apiKeyUrl,
+      models: p.models,
+      defaultModel: p.defaultModel,
+    })),
+  });
+});
+
+app.get('/api/auth/pi/status', (_req, res) => {
+  res.json(getPiAuthStatus());
+});
+
+app.post('/api/auth/pi/test', async (req, res) => {
+  const { subProvider, apiKey, baseUrl, modelId } = req.body || {};
+  if (!subProvider || typeof subProvider !== 'string') {
+    res.json({ ok: false, error: 'Missing subProvider' });
+    return;
+  }
+  const provider = getPiSubProvider(subProvider);
+  if (!provider) {
+    res.json({ ok: false, error: `Unknown sub-provider: ${subProvider}` });
+    return;
+  }
+  const prompt = 'Reply with the single word OK so we can confirm this LLM endpoint is reachable.';
+  const result = await runPiTestCompletion({ subProvider, apiKey, baseUrl, modelId, prompt });
+  res.json(result);
+});
+
+app.post('/api/auth/pi/save', (req, res) => {
+  const { subProvider, apiKey, baseUrl, modelId } = req.body || {};
+  if (!subProvider || typeof subProvider !== 'string') {
+    res.json({ ok: false, error: 'Missing subProvider' });
+    return;
+  }
+  const provider = getPiSubProvider(subProvider);
+  if (!provider) {
+    res.json({ ok: false, error: `Unknown sub-provider: ${subProvider}` });
+    return;
+  }
+  const saved = writePiAuth({
+    subProvider,
+    apiKey: typeof apiKey === 'string' ? apiKey : undefined,
+    baseUrl: typeof baseUrl === 'string' && baseUrl.trim() ? baseUrl.trim() : provider.baseUrl,
+    modelId: typeof modelId === 'string' && modelId.trim() ? modelId.trim() : provider.defaultModel,
+  });
+  res.json({ ok: true, status: { configured: true, subProvider: saved.subProvider, modelId: saved.modelId, baseUrl: saved.baseUrl } });
+});
+
+app.delete('/api/auth/pi', (_req, res) => {
+  clearPiAuth();
+  res.json({ ok: true });
+});
+
+app.post('/api/auth/pi/completion', async (req, res) => {
+  const auth = readPiAuth();
+  if (!auth) {
+    res.json({ ok: false, error: 'Bloby provider is not configured yet' });
+    return;
+  }
+  const prompt = (req.body?.prompt && typeof req.body.prompt === 'string')
+    ? req.body.prompt
+    : 'In one short sentence, introduce yourself as the model behind this endpoint and confirm the connection is working.';
+  const result = await runPiTestCompletion({
+    subProvider: auth.subProvider,
+    apiKey: auth.apiKey,
+    baseUrl: auth.baseUrl,
+    modelId: auth.modelId,
+    prompt,
+  });
+  res.json(result);
+});
+
 // ── Handle registration ──
 
 app.get('/api/handle/check/:username', async (req, res) => {