@gitpagedocs/tools 1.1.44

package/README.md

@@ -0,0 +1,33 @@
+# @gitpagedocs/tools
+
+The **shared business-logic core** of the [Git Page Docs](../README.md) monorepo — the single home for domain logic consumed by the frontend, the CLI, and the MCP server. It ships **TypeScript source** and is consumed via `tsx` (CLI/MCP) or a TS-aware bundler (Next `transpilePackages`).
+
+## Modules (`src/`)
+
+| Module | Responsibility |
+|---|---|
+| `ai/` | 14-provider AI system — data-driven `PROVIDER_CATALOG`, registry + factory (no switch chains), 5 family adapters (OpenAI-compatible, Anthropic, Gemini, Ollama, Cohere), SSE/NDJSON streaming, legacy↔catalog id mapping |
+| `security/` | `EncryptedCredentialVault` (AES-256-GCM), `SessionPasswordGate`, plaintext migration; web + file storage adapters |
+| `crypto/` | `NodeCryptoService` + `WebCryptoService` (SHA-256, PBKDF2, AES-256-GCM, masking, secure wipe) |
+| `cache/` | `MemoryCache`, `FileCache`, `WebStorageCache` (Strategy over one `Cache` port) |
+| `config/` | `GitPageDocsConfigLoader` (`.json` / `.js` / `.ts`) |
+| `logger/` | Level-filtered logger with **secret redaction** |
+| `errors/` | `AppError` + typed subclasses |
+| `filesystem/` | `FileService` (root-bounded list/read/write/search) |
+| `documentation/` | `DocumentationService`, `patchManagedRegion`, `DocUpdater` |
+| `ports/` | Type-only contracts (logger, cache, crypto, security, config, ai) |
+
+## Entry points (`exports`)
+
+`.` (full barrel) · `./ai` · `./errors` · `./ports` · `./crypto/web` · `./security/web` · `./cache/web` — the `web` subpaths are browser-safe (no `node:` imports) for the Next.js bundle.
+
+## Usage
+
+```ts
+import { createDefaultFactory, PROVIDER_CATALOG } from "@gitpagedocs/tools/ai";
+import { EncryptedCredentialVault } from "@gitpagedocs/tools/security/web";
+```
+
+## Tests
+
+Unit + integration + E2E live in `tools/tests/**` (Vitest); self-tests in `tools/smoke/**`. Run from the repo root: `npx vitest run` and `npm run smoke:all`.

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@gitpagedocs/tools",
+  "version": "1.1.44",
+  "type": "module",
+  "description": "Shared business-logic core for Git Page Docs (consumed by frontend, cli and mcp). Ships TypeScript source; consume via tsx or a TS-aware bundler.",
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "exports": {
+    ".": "./src/index.ts",
+    "./ai": "./src/ai/index.ts",
+    "./errors": "./src/errors/index.ts",
+    "./ports": "./src/ports/index.ts",
+    "./crypto/web": "./src/crypto/web.ts",
+    "./security/web": "./src/security/web.ts",
+    "./cache/web": "./src/cache/web-storage-cache.ts"
+  },
+  "files": [
+    "src",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Vidigal-code/git-page-docs.git",
+    "directory": "tools"
+  },
+  "author": "Vidigal-code",
+  "license": "ISC",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit -p tsconfig.json"
+  }
+}

package/src/ai/bootstrap.ts

@@ -0,0 +1,50 @@
+import type { AIProvider, ProviderRegistration } from "../ports/ai";
+import { PROVIDER_CATALOG, type ProviderFamily, type ProviderSpec } from "./catalog";
+import { InMemoryProviderRegistry } from "./registry";
+import { RegistryProviderFactory } from "./factory";
+import { CatalogModelRegistry } from "./model-registry";
+import type { FetchLike } from "./http/streaming";
+import { OpenAiCompatibleProvider } from "./providers/openai-compatible-provider";
+import { AnthropicProvider } from "./providers/anthropic-provider";
+import { GeminiProvider } from "./providers/gemini-provider";
+import { OllamaProvider } from "./providers/ollama-provider";
+import { CohereProvider } from "./providers/cohere-provider";
+
+/** Maps a provider family to its adapter constructor (small Factory table). */
+type AdapterCtor = new (spec: ProviderSpec, fetchImpl?: FetchLike) => AIProvider;
+
+const FAMILY_ADAPTERS: Record<ProviderFamily, AdapterCtor> = {
+  "openai-compatible": OpenAiCompatibleProvider,
+  anthropic: AnthropicProvider,
+  gemini: GeminiProvider,
+  ollama: OllamaProvider,
+  cohere: CohereProvider,
+};
+
+function toRegistration(spec: ProviderSpec, fetchImpl?: FetchLike): ProviderRegistration {
+  const Adapter = FAMILY_ADAPTERS[spec.family];
+  return {
+    id: spec.id,
+    label: spec.label,
+    defaultModel: spec.defaultModel,
+    capabilities: spec.capabilities,
+    create: () => new Adapter(spec, fetchImpl),
+  };
+}
+
+/** Registry pre-populated with every catalog provider. */
+export function createDefaultRegistry(fetchImpl?: FetchLike): InMemoryProviderRegistry {
+  const registry = new InMemoryProviderRegistry();
+  for (const spec of Object.values(PROVIDER_CATALOG)) {
+    registry.register(toRegistration(spec, fetchImpl));
+  }
+  return registry;
+}
+
+export function createDefaultFactory(fetchImpl?: FetchLike): RegistryProviderFactory {
+  return new RegistryProviderFactory(createDefaultRegistry(fetchImpl));
+}
+
+export function createModelRegistry(): CatalogModelRegistry {
+  return new CatalogModelRegistry();
+}

package/src/ai/catalog.ts

@@ -0,0 +1,188 @@
+import type { AiProviderId, ModelDescriptor, ProviderCapabilities } from "../ports/ai";
+
+/**
+ * Single source of truth for AI providers. Adding a provider = adding a catalog
+ * entry; the registry/factory are data-driven, so there is no switch to grow.
+ */
+export type ProviderFamily =
+  | "openai-compatible"
+  | "anthropic"
+  | "gemini"
+  | "ollama"
+  | "cohere";
+
+export type AuthStyle = "bearer" | "x-api-key" | "query-key" | "api-key-header" | "none";
+
+export interface ProviderSpec {
+  readonly id: AiProviderId;
+  readonly label: string;
+  readonly family: ProviderFamily;
+  readonly defaultModel: string;
+  /** Default API base URL (without the chat path). */
+  readonly baseUrl: string;
+  /** Provider needs a user-supplied baseUrl (Azure deployment, local Ollama). */
+  readonly requiresBaseUrl?: boolean;
+  readonly auth: AuthStyle;
+  readonly capabilities: ProviderCapabilities;
+  readonly models: readonly ModelDescriptor[];
+}
+
+const TEXT: ProviderCapabilities = { streaming: true, vision: false, audio: false };
+const VISION: ProviderCapabilities = { streaming: true, vision: true, audio: false };
+const VISION_AUDIO: ProviderCapabilities = { streaming: true, vision: true, audio: true };
+
+function models(...ids: string[]): ModelDescriptor[] {
+  return ids.map((id) => ({ id }));
+}
+
+export const PROVIDER_CATALOG: Readonly<Record<AiProviderId, ProviderSpec>> = {
+  openai: {
+    id: "openai",
+    label: "OpenAI",
+    family: "openai-compatible",
+    defaultModel: "gpt-4o-mini",
+    baseUrl: "https://api.openai.com/v1",
+    auth: "bearer",
+    capabilities: VISION,
+    models: models("gpt-4o", "gpt-4o-mini", "o3-mini", "o1"),
+  },
+  anthropic: {
+    id: "anthropic",
+    label: "Anthropic",
+    family: "anthropic",
+    // Latest Claude API model IDs.
+    defaultModel: "claude-sonnet-4-6",
+    baseUrl: "https://api.anthropic.com/v1",
+    auth: "x-api-key",
+    capabilities: VISION,
+    models: models("claude-opus-4-8", "claude-sonnet-4-6", "claude-haiku-4-5-20251001"),
+  },
+  gemini: {
+    id: "gemini",
+    label: "Google Gemini",
+    family: "gemini",
+    defaultModel: "gemini-2.0-flash",
+    baseUrl: "https://generativelanguage.googleapis.com/v1beta/models",
+    auth: "query-key",
+    capabilities: VISION_AUDIO,
+    models: models("gemini-2.0-flash", "gemini-1.5-pro", "gemini-1.5-flash"),
+  },
+  openrouter: {
+    id: "openrouter",
+    label: "OpenRouter",
+    family: "openai-compatible",
+    defaultModel: "openai/gpt-4o-mini",
+    baseUrl: "https://openrouter.ai/api/v1",
+    auth: "bearer",
+    capabilities: VISION,
+    models: models("openai/gpt-4o-mini", "anthropic/claude-sonnet-4-6", "google/gemini-2.0-flash-exp"),
+  },
+  ollama: {
+    id: "ollama",
+    label: "Ollama (local)",
+    family: "ollama",
+    defaultModel: "llama3",
+    baseUrl: "http://localhost:11434",
+    requiresBaseUrl: false,
+    auth: "none",
+    capabilities: VISION,
+    models: models("llama3", "llama3.1", "mistral", "qwen2.5"),
+  },
+  "azure-openai": {
+    id: "azure-openai",
+    label: "Azure OpenAI",
+    family: "openai-compatible",
+    defaultModel: "gpt-4o-mini",
+    baseUrl: "",
+    requiresBaseUrl: true,
+    auth: "api-key-header",
+    capabilities: VISION,
+    models: models("gpt-4o", "gpt-4o-mini"),
+  },
+  mistral: {
+    id: "mistral",
+    label: "Mistral",
+    family: "openai-compatible",
+    defaultModel: "mistral-large-latest",
+    baseUrl: "https://api.mistral.ai/v1",
+    auth: "bearer",
+    capabilities: TEXT,
+    models: models("mistral-large-latest", "mistral-small-latest", "open-mistral-nemo"),
+  },
+  deepseek: {
+    id: "deepseek",
+    label: "DeepSeek",
+    family: "openai-compatible",
+    defaultModel: "deepseek-chat",
+    baseUrl: "https://api.deepseek.com/v1",
+    auth: "bearer",
+    capabilities: TEXT,
+    models: models("deepseek-chat", "deepseek-reasoner"),
+  },
+  cohere: {
+    id: "cohere",
+    label: "Cohere",
+    family: "cohere",
+    defaultModel: "command-r-plus",
+    baseUrl: "https://api.cohere.com/v2",
+    auth: "bearer",
+    capabilities: TEXT,
+    models: models("command-r-plus", "command-r"),
+  },
+  groq: {
+    id: "groq",
+    label: "Groq",
+    family: "openai-compatible",
+    defaultModel: "llama-3.3-70b-versatile",
+    baseUrl: "https://api.groq.com/openai/v1",
+    auth: "bearer",
+    capabilities: TEXT,
+    models: models("llama-3.3-70b-versatile", "llama-3.1-8b-instant", "mixtral-8x7b-32768"),
+  },
+  xai: {
+    id: "xai",
+    label: "xAI Grok",
+    family: "openai-compatible",
+    defaultModel: "grok-2-latest",
+    baseUrl: "https://api.x.ai/v1",
+    auth: "bearer",
+    capabilities: VISION,
+    models: models("grok-2-latest", "grok-2-vision-latest"),
+  },
+  together: {
+    id: "together",
+    label: "Together AI",
+    family: "openai-compatible",
+    defaultModel: "meta-llama/Llama-3.3-70B-Instruct-Turbo",
+    baseUrl: "https://api.together.xyz/v1",
+    auth: "bearer",
+    capabilities: TEXT,
+    models: models("meta-llama/Llama-3.3-70B-Instruct-Turbo", "mistralai/Mixtral-8x7B-Instruct-v0.1"),
+  },
+  fireworks: {
+    id: "fireworks",
+    label: "Fireworks AI",
+    family: "openai-compatible",
+    defaultModel: "accounts/fireworks/models/llama-v3p3-70b-instruct",
+    baseUrl: "https://api.fireworks.ai/inference/v1",
+    auth: "bearer",
+    capabilities: TEXT,
+    models: models("accounts/fireworks/models/llama-v3p3-70b-instruct"),
+  },
+  perplexity: {
+    id: "perplexity",
+    label: "Perplexity",
+    family: "openai-compatible",
+    defaultModel: "sonar",
+    baseUrl: "https://api.perplexity.ai",
+    auth: "bearer",
+    capabilities: TEXT,
+    models: models("sonar", "sonar-pro", "sonar-reasoning"),
+  },
+};
+
+export const ALL_PROVIDER_IDS = Object.keys(PROVIDER_CATALOG) as AiProviderId[];
+
+export function getProviderSpec(id: AiProviderId): ProviderSpec {
+  return PROVIDER_CATALOG[id];
+}

package/src/ai/factory.ts

@@ -0,0 +1,14 @@
+import type { AIProvider, AiProviderId, ProviderFactory } from "../ports/ai";
+import type { InMemoryProviderRegistry } from "./registry";
+import { ProviderError } from "../errors/app-error";
+
+/** Creates provider strategies from the registry (Factory pattern). */
+export class RegistryProviderFactory implements ProviderFactory {
+  constructor(private readonly registry: InMemoryProviderRegistry) {}
+
+  create(id: AiProviderId): AIProvider {
+    const registration = this.registry.get(id);
+    if (!registration) throw new ProviderError(`Unknown AI provider: ${id}`, { details: { provider: id } });
+    return registration.create();
+  }
+}

package/src/ai/http/streaming.ts

@@ -0,0 +1,60 @@
+import { ProviderError } from "../../errors/app-error";
+
+/** Injected fetch for testability; defaults to the platform global. */
+export type FetchLike = typeof fetch;
+
+export function resolveFetch(custom?: FetchLike): FetchLike {
+  const f = custom ?? (globalThis.fetch as FetchLike | undefined);
+  if (!f) throw new ProviderError("No fetch implementation available in this runtime.");
+  return f;
+}
+
+/** Yield the payload of each `data:` line from an SSE response body. */
+export async function* readSseData(body: ReadableStream<Uint8Array>): AsyncGenerator<string> {
+  const reader = body.getReader();
+  const decoder = new TextDecoder("utf-8");
+  let buffer = "";
+  for (;;) {
+    const { value, done } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: true });
+    const lines = buffer.split("\n");
+    buffer = lines.pop() ?? "";
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed.startsWith("data:")) {
+        yield trimmed.slice(5).trim();
+      }
+    }
+  }
+  const tail = buffer.trim();
+  if (tail.startsWith("data:")) yield tail.slice(5).trim();
+}
+
+/** Yield each complete JSON line from an NDJSON response body (e.g. Ollama). */
+export async function* readJsonLines(body: ReadableStream<Uint8Array>): AsyncGenerator<string> {
+  const reader = body.getReader();
+  const decoder = new TextDecoder("utf-8");
+  let buffer = "";
+  for (;;) {
+    const { value, done } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: true });
+    const lines = buffer.split("\n");
+    buffer = lines.pop() ?? "";
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed) yield trimmed;
+    }
+  }
+  const tail = buffer.trim();
+  if (tail) yield tail;
+}
+
+export async function ensureOk(response: Response, providerLabel: string): Promise<Response> {
+  if (response.ok && response.body) return response;
+  const detail = await response.text().catch(() => "");
+  throw new ProviderError(`${providerLabel} request failed: ${response.status} ${response.statusText} ${detail}`, {
+    details: { status: response.status },
+  });
+}

package/src/ai/index.ts

@@ -0,0 +1,27 @@
+// Shared AI system. Registry-driven (Strategy + Factory + Registry), consumed
+// by the frontend, CLI and MCP. Adding a provider = a catalog entry.
+export {
+  PROVIDER_CATALOG,
+  ALL_PROVIDER_IDS,
+  getProviderSpec,
+} from "./catalog";
+export type { ProviderFamily, ProviderSpec, AuthStyle } from "./catalog";
+export { InMemoryProviderRegistry } from "./registry";
+export { RegistryProviderFactory } from "./factory";
+export { CatalogModelRegistry } from "./model-registry";
+export {
+  createDefaultRegistry,
+  createDefaultFactory,
+  createModelRegistry,
+} from "./bootstrap";
+export type { FetchLike } from "./http/streaming";
+export { OpenAiCompatibleProvider } from "./providers/openai-compatible-provider";
+export { AnthropicProvider } from "./providers/anthropic-provider";
+export { GeminiProvider } from "./providers/gemini-provider";
+export { OllamaProvider } from "./providers/ollama-provider";
+export { CohereProvider } from "./providers/cohere-provider";
+export {
+  legacyProviderToCatalogId,
+  parseLegacyProviderAndModel,
+} from "./legacy-adapter";
+export type { ParsedLegacyProvider } from "./legacy-adapter";

package/src/ai/legacy-adapter.ts

@@ -0,0 +1,33 @@
+import type { AiProviderId } from "../ports/ai";
+import { PROVIDER_CATALOG } from "./catalog";
+
+/**
+ * Bridges the legacy frontend/CLI provider ids ("claude", and the
+ * "provider:model" string form) to the shared catalog. Lets existing consumers
+ * adopt tools/src/ai without changing their stored config strings.
+ */
+const LEGACY_ALIASES: Readonly<Record<string, AiProviderId>> = {
+  openai: "openai",
+  claude: "anthropic",
+  anthropic: "anthropic",
+  gemini: "gemini",
+  ollama: "ollama",
+};
+
+export function legacyProviderToCatalogId(legacy: string | undefined): AiProviderId {
+  const key = (legacy ?? "").trim().toLowerCase();
+  return LEGACY_ALIASES[key] ?? "openai";
+}
+
+export interface ParsedLegacyProvider {
+  readonly providerId: AiProviderId;
+  readonly model: string;
+}
+
+/** Parse a legacy "provider:model" string (e.g. "claude:claude-3-5-sonnet"). */
+export function parseLegacyProviderAndModel(value: string | undefined): ParsedLegacyProvider {
+  const [rawProvider, rawModel] = (value ?? "").split(":");
+  const providerId = legacyProviderToCatalogId(rawProvider);
+  const model = (rawModel ?? "").trim() || PROVIDER_CATALOG[providerId].defaultModel;
+  return { providerId, model };
+}

package/src/ai/model-registry.ts

@@ -0,0 +1,13 @@
+import type { AiProviderId, ModelDescriptor, ModelRegistry } from "../ports/ai";
+import { PROVIDER_CATALOG } from "./catalog";
+
+/** Model registry backed by the static provider catalog. */
+export class CatalogModelRegistry implements ModelRegistry {
+  list(providerId: AiProviderId): readonly ModelDescriptor[] {
+    return PROVIDER_CATALOG[providerId]?.models ?? [];
+  }
+
+  defaultModel(providerId: AiProviderId): string | undefined {
+    return PROVIDER_CATALOG[providerId]?.defaultModel;
+  }
+}

package/src/ai/providers/anthropic-provider.ts

@@ -0,0 +1,83 @@
+import type {
+  AIProvider,
+  AiMessage,
+  AiProviderId,
+  GenerateRequest,
+  GenerateResponse,
+  ProviderCapabilities,
+  ProviderConfig,
+  StreamResponse,
+} from "../../ports/ai";
+import type { ProviderSpec } from "../catalog";
+import { type FetchLike, ensureOk, readSseData, resolveFetch } from "../http/streaming";
+import { buildAuthHeaders, collect, resolveBaseUrl } from "./shared";
+
+/** Anthropic Messages API adapter (content_block_delta streaming). */
+export class AnthropicProvider implements AIProvider {
+  readonly id: AiProviderId;
+  readonly capabilities: ProviderCapabilities;
+
+  constructor(
+    private readonly spec: ProviderSpec,
+    private readonly fetchImpl?: FetchLike,
+  ) {
+    this.id = spec.id;
+    this.capabilities = spec.capabilities;
+  }
+
+  private mapMessage(msg: AiMessage): unknown {
+    const images = (msg.attachments ?? []).filter((a) => a.kind === "image");
+    if (images.length === 0) return { role: msg.role, content: msg.content };
+    const content: unknown[] = [];
+    if (msg.content) content.push({ type: "text", text: msg.content });
+    for (const img of images) {
+      content.push({
+        type: "image",
+        source: { type: "base64", media_type: img.mimeType, data: img.data },
+      });
+    }
+    return { role: msg.role, content };
+  }
+
+  async *stream(request: GenerateRequest, config: ProviderConfig): AsyncGenerator<string> {
+    const fetchImpl = resolveFetch(this.fetchImpl);
+    const base = resolveBaseUrl(this.spec, config);
+    const chatMessages = request.messages.filter((m) => m.role !== "system").map((m) => this.mapMessage(m));
+    const joinedSystem = request.messages
+      .filter((m) => m.role === "system")
+      .map((m) => m.content)
+      .join("\n");
+    const system = request.system ?? (joinedSystem || undefined);
+
+    const response = await fetchImpl(`${base}/messages`, {
+      method: "POST",
+      headers: buildAuthHeaders(this.spec, config),
+      body: JSON.stringify({
+        model: config.model || this.spec.defaultModel,
+        max_tokens: request.maxTokens ?? 4000,
+        temperature: request.temperature,
+        system,
+        messages: chatMessages,
+        stream: true,
+      }),
+      signal: request.signal,
+    });
+    const ok = await ensureOk(response, this.spec.label);
+    for await (const data of readSseData(ok.body as ReadableStream<Uint8Array>)) {
+      if (!data || data === "[DONE]") continue;
+      try {
+        const parsed = JSON.parse(data) as { type?: string; delta?: { text?: string } };
+        if (parsed.type === "content_block_delta" && parsed.delta?.text) {
+          yield parsed.delta.text;
+        }
+      } catch {
+        /* ignore partial frames */
+      }
+    }
+  }
+
+  async generate(request: GenerateRequest, config: ProviderConfig): Promise<GenerateResponse> {
+    const text = await collect(this.stream(request, config) as StreamResponse);
+    return { text, model: config.model || this.spec.defaultModel };
+  }
+}

package/src/ai/providers/cohere-provider.ts

@@ -0,0 +1,66 @@
+import type {
+  AIProvider,
+  AiProviderId,
+  GenerateRequest,
+  GenerateResponse,
+  ProviderCapabilities,
+  ProviderConfig,
+  StreamResponse,
+} from "../../ports/ai";
+import type { ProviderSpec } from "../catalog";
+import { type FetchLike, ensureOk, readSseData, resolveFetch } from "../http/streaming";
+import { buildAuthHeaders, collect, resolveBaseUrl } from "./shared";
+
+/** Cohere Chat v2 adapter (SSE content-delta streaming). */
+export class CohereProvider implements AIProvider {
+  readonly id: AiProviderId;
+  readonly capabilities: ProviderCapabilities;
+
+  constructor(
+    private readonly spec: ProviderSpec,
+    private readonly fetchImpl?: FetchLike,
+  ) {
+    this.id = spec.id;
+    this.capabilities = spec.capabilities;
+  }
+
+  async *stream(request: GenerateRequest, config: ProviderConfig): AsyncGenerator<string> {
+    const fetchImpl = resolveFetch(this.fetchImpl);
+    const base = resolveBaseUrl(this.spec, config);
+    const messages: Array<{ role: string; content: string }> = [];
+    if (request.system) messages.push({ role: "system", content: request.system });
+    for (const m of request.messages) messages.push({ role: m.role, content: m.content });
+
+    const response = await fetchImpl(`${base}/chat`, {
+      method: "POST",
+      headers: buildAuthHeaders(this.spec, config),
+      body: JSON.stringify({
+        model: config.model || this.spec.defaultModel,
+        messages,
+        temperature: request.temperature,
+        max_tokens: request.maxTokens,
+        stream: true,
+      }),
+      signal: request.signal,
+    });
+    const ok = await ensureOk(response, this.spec.label);
+    for await (const data of readSseData(ok.body as ReadableStream<Uint8Array>)) {
+      if (!data) continue;
+      try {
+        const parsed = JSON.parse(data) as {
+          type?: string;
+          delta?: { message?: { content?: { text?: string } } };
+        };
+        const text = parsed.delta?.message?.content?.text;
+        if (parsed.type === "content-delta" && text) yield text;
+      } catch {
+        /* ignore partial frames */
+      }
+    }
+  }
+
+  async generate(request: GenerateRequest, config: ProviderConfig): Promise<GenerateResponse> {
+    const text = await collect(this.stream(request, config) as StreamResponse);
+    return { text, model: config.model || this.spec.defaultModel };
+  }
+}