@blackbelt-technology/pi-agent-dashboard 0.5.1 → 0.5.2

package/packages/server/src/model-proxy/registry-singleton.ts

@@ -0,0 +1,109 @@
+/**
+ * Singleton accessor for the server-resident model registry.
+ *
+ * Lazy initialization: on first call, resolves pi-ai via ToolRegistry,
+ * constructs InternalAuthStorage + InternalRegistry, and caches the instance.
+ *
+ * See change: add-dashboard-model-proxy, design §1.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { getDefaultRegistry, ModuleResolutionError } from "@blackbelt-technology/pi-dashboard-shared/tool-registry/index.js";
+import { InternalRegistry, type PiAiModule, type CustomProviderEntry, type CustomModelEntry } from "./internal-registry.js";
+import { InternalAuthStorage, type PiAiOAuthModule } from "./internal-auth-storage.js";
+import { readAuthJson } from "../provider-auth-storage.js";
+
+let cachedRegistry: InternalRegistry | null = null;
+let cachedPiAi: PiAiModule | null = null;
+let lastError: string | null = null;
+
+// ── Disk readers ──────────────────────────────────────────────────────────────
+
+const PROVIDERS_PATH = join(homedir(), ".pi", "agent", "providers.json");
+const MODELS_PATH = join(homedir(), ".pi", "agent", "models.json");
+
+function readProviders(): Record<string, CustomProviderEntry> {
+  if (!existsSync(PROVIDERS_PATH)) return {};
+  try {
+    const raw = JSON.parse(readFileSync(PROVIDERS_PATH, "utf-8"));
+    return raw.providers ?? {};
+  } catch {
+    return {};
+  }
+}
+
+function readModels(): CustomModelEntry[] {
+  if (!existsSync(MODELS_PATH)) return [];
+  try {
+    const raw = JSON.parse(readFileSync(MODELS_PATH, "utf-8"));
+    if (Array.isArray(raw)) return raw;
+    if (raw.models && Array.isArray(raw.models)) return raw.models;
+    return [];
+  } catch {
+    return [];
+  }
+}
+
+// ── Public API ────────────────────────────────────────────────────────────────
+
+export async function getModelRegistry(): Promise<InternalRegistry> {
+  if (cachedRegistry) return cachedRegistry;
+
+  try {
+    const { resolution, module: piAi } = await getDefaultRegistry().resolveModule<PiAiModule>("pi-ai");
+
+    // Resolve oauth subpath
+    let oauthModule: PiAiOAuthModule | null = null;
+    if (resolution.path) {
+      const oauthPath = resolution.path.replace(/\/dist\/index\.js$/, "/dist/oauth.js");
+      try {
+        oauthModule = (await import(pathToFileURL(oauthPath).href)) as PiAiOAuthModule;
+      } catch {
+        // OAuth subpath may not exist; non-fatal
+      }
+    }
+
+    const authStorage = new InternalAuthStorage(oauthModule);
+    cachedPiAi = piAi;
+    cachedRegistry = new InternalRegistry(piAi, authStorage, {
+      readProviders,
+      readModels,
+      readAuth: readAuthJson,
+    });
+    lastError = null;
+    return cachedRegistry;
+  } catch (err) {
+    const msg = err instanceof ModuleResolutionError
+      ? err.message
+      : (err as Error).message;
+    lastError = msg;
+    throw err;
+  }
+}
+
+export async function refreshModelRegistry(): Promise<void> {
+  if (!cachedRegistry) return;
+  await cachedRegistry.refresh();
+}
+
+export function disposeModelRegistry(): void {
+  cachedRegistry = null;
+  cachedPiAi = null;
+  lastError = null;
+}
+
+/**
+ * Returns pi-ai's streamSimple after registry is initialized.
+ * Throws if registry has not been initialized.
+ */
+export function getStreamSimpleFn(): PiAiModule["streamSimple"] | null {
+  return cachedPiAi?.streamSimple ?? null;
+}
+
+export function getModelProxyStatus(): { status: "ready" | "degraded"; reason?: string } {
+  if (cachedRegistry) return { status: "ready" };
+  if (lastError) return { status: "degraded", reason: lastError };
+  return { status: "degraded", reason: "Model registry not yet initialized" };
+}

package/packages/server/src/model-proxy/request-log.ts

@@ -0,0 +1,53 @@
+/**
+ * Optional JSONL request log for the model proxy.
+ *
+ * Appends one line per completed request to ~/.pi/dashboard/model-proxy.jsonl.
+ * Never logs request/response body or API keys — only metadata.
+ * Daily rotation when file exceeds 50MB.
+ *
+ * See change: add-dashboard-model-proxy.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+
+const LOG_DIR = path.join(os.homedir(), ".pi", "dashboard");
+const LOG_FILE = path.join(LOG_DIR, "model-proxy.jsonl");
+const MAX_SIZE_BYTES = 50 * 1024 * 1024; // 50MB
+
+export interface RequestLogEntry {
+  ts: string;
+  requestId: string;
+  apiKeyId?: string;
+  model: string;
+  format: "openai" | "anthropic";
+  status: number;
+  durationMs: number;
+  inputTokens?: number;
+  outputTokens?: number;
+  error?: string;
+}
+
+function rotateIfNeeded(): void {
+  try {
+    const stat = fs.statSync(LOG_FILE);
+    if (stat.size >= MAX_SIZE_BYTES) {
+      const date = new Date().toISOString().split("T")[0];
+      const rotatedPath = `${LOG_FILE}.${date}`;
+      fs.renameSync(LOG_FILE, rotatedPath);
+    }
+  } catch {
+    // File doesn't exist or stat failed — no rotation needed
+  }
+}
+
+export function logRequest(entry: RequestLogEntry): void {
+  try {
+    fs.mkdirSync(LOG_DIR, { recursive: true });
+    rotateIfNeeded();
+    const line = JSON.stringify(entry) + "\n";
+    fs.appendFileSync(LOG_FILE, line, "utf-8");
+  } catch {
+    // Best-effort logging — never crash the server
+  }
+}

package/packages/server/src/model-proxy/streamer.ts

@@ -0,0 +1,59 @@
+/**
+ * Wrapper around pi-ai's streamSimple for model proxy route handlers.
+ *
+ * Resolves model credentials from the InternalRegistry, then delegates
+ * to pi-ai's streamSimple. Returns an AsyncIterable of pi-ai StreamEvents.
+ *
+ * See change: add-dashboard-model-proxy, task 6.1.
+ */
+import { getModelRegistry } from "./registry-singleton.js";
+import type { PiAiModule } from "./internal-registry.js";
+
+export interface StreamCompletionOpts {
+  model: any;
+  messages: any[];
+  system?: string;
+  tools?: any[];
+  maxTokens?: number;
+  temperature?: number;
+  signal?: AbortSignal;
+}
+
+export interface RegistryLike {
+  getApiKeyAndHeaders(model: any): Promise<{ apiKey: string; headers: Record<string, string> }>;
+}
+
+/**
+ * Stream a completion from the upstream provider via pi-ai's streamSimple.
+ *
+ * Resolves API key + headers from the registry, then calls streamSimple.
+ * The returned iterable yields pi-ai's AssistantMessageEvent objects.
+ *
+ * @param opts - stream options
+ * @param piAiStreamSimple - pi-ai's streamSimple function
+ * @param registryOverride - optional registry for testing (defaults to getModelRegistry())
+ */
+export async function streamCompletion(
+  opts: StreamCompletionOpts,
+  piAiStreamSimple: PiAiModule["streamSimple"],
+  registryOverride?: RegistryLike,
+): Promise<AsyncIterable<any>> {
+  const registry = registryOverride ?? await getModelRegistry();
+  const { apiKey, headers } = await registry.getApiKeyAndHeaders(opts.model);
+
+  const context: any = {
+    messages: opts.messages,
+    ...(opts.system !== undefined ? { systemPrompt: opts.system } : {}),
+    ...(opts.tools ? { tools: opts.tools } : {}),
+  };
+
+  const options: any = {
+    apiKey,
+    headers,
+    ...(opts.maxTokens != null ? { maxTokens: opts.maxTokens } : {}),
+    ...(opts.temperature != null ? { temperature: opts.temperature } : {}),
+    ...(opts.signal ? { signal: opts.signal } : {}),
+  };
+
+  return piAiStreamSimple(opts.model, context, options);
+}