pi-rozalia 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Maciej Borzecki
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,78 @@
+# pi-rozalia
+
+An extension for the [Pi coding agent](https://github.com/microsoft/pi-coding-agent) that connects to a [Rozalia AI](https://ai.zygoon.pl) server via the OpenAI-compatible Chat Completions API.
+
+## Prerequisites
+
+1. **Pi Coding Agent** installed.
+2. A **Rozalia AI server** running and accessible.
+
+## Installation
+
+```bash
+pi install npm:pi-rozalia
+```
+
+## Configuration
+
+### Interactive setup (recommended)
+
+Use Pi's built-in `/login` command to configure your server and API key:
+
+```bash
+pi
+/login
+→ pick "Rozalia"
+→ enter server URL (default: https://ai.zygoon.pl/v1)
+→ enter API key (optional)
+```
+
+The server URL and API key are stored in `~/.pi/agent/auth.json` and reused on subsequent logins.
+
+### Environment variables (alternative)
+
+| Variable | Description | Default |
+|----------|-------------|---------|
+| `ROZALIA_BASE_URL` | Rozalia AI server base URL | `https://ai.zygoon.pl/v1` |
+| `ROZALIA_API_KEY` | API key for authentication | *(none)* |
+
+```bash
+export ROZALIA_API_KEY="your-api-key"
+```
+
+### Custom server
+
+Point to any OpenAI-compatible server:
+
+```bash
+ROZALIA_BASE_URL="https://my-server.example.com/v1" \
+ROZALIA_API_KEY="my-key" \
+pi
+```
+
+## Usage
+
+1. **Launch Pi** — the provider loads automatically on startup.
+
+   ```bash
+   pi
+   ```
+
+2. **Select a Model** — use `/model` or `Ctrl+P` to pick from the discovered models.
+
+## How It Works
+
+On startup, the extension fetches the model list from the server's `/v1/models` endpoint and registers each model with Pi. If discovery fails, a single fallback model is registered so you can still try to connect.
+
+The `/login` flow stores your server URL and API key in Pi's credential store (`~/.pi/agent/auth.json`). On subsequent logins the stored URL is pre-filled, so you only need to re-enter it if your server changes.
+
+## TODO
+
+- [ ] Multi-server support — register each configured server as its own provider with a derived name (e.g. `rozalia-localhost-1234`), so models from different servers are unambiguous in the picker
+- [ ] Model discovery health check — skip servers that fail to respond rather than showing fallback models
+- [ ] `ROZALIA_TIMEOUT` env var — configure model discovery timeout (currently hardcoded to 5s)
+- [ ] Support for `ROZALIA_MODELS` env var — allow overriding the discovered model list with a static list
+
+## License
+
+[MIT](LICENSE) — © 2026 Maciej Borzecki

package/index.ts

@@ -0,0 +1,344 @@
+/**
+ * Rozalia AI Provider Extension
+ *
+ * Registers an OpenAI-compatible provider for the Pi coding agent,
+ * connecting to a Rozalia AI server.
+ *
+ * Configuration (in order of precedence):
+ *   1. /login → OAuth flow (stores baseUrl + apiKey in ~/.pi/agent/auth.json)
+ *   2. ROZALIA_BASE_URL  env var (default: https://ai.zygoon.pl/v1)
+ *   3. ROZALIA_API_KEY   env var
+ *
+ * Usage:
+ *   # Quick: set env vars
+ *   export ROZALIA_API_KEY="your-api-key"
+ *   pi
+ *
+ *   # Full: use /login to configure server URL + API key interactively
+ *   pi
+ *   /login
+ *   → pick "rozalia"
+ *   → enter server URL (default: https://ai.zygoon.pl/v1)
+ *   → enter API key
+ *
+ *   # Point to a custom server
+ *   ROZALIA_BASE_URL="https://my-server.example.com/v1" \
+ *   ROZALIA_API_KEY="my-key" \
+ *   pi
+ */
+
+import type { ExtensionAPI, OAuthCredentials, OAuthLoginCallbacks, ProviderModelConfig } from "@earendil-works/pi-coding-agent";
+import * as fs from "node:fs";
+
+// ---------------------------------------------------------------------------
+// Credential payload (stored in OAuth refresh field)
+// ---------------------------------------------------------------------------
+
+interface CredsPayload {
+  baseUrl: string;
+  apiKey: string;
+}
+
+function encodeCreds(payload: CredsPayload): OAuthCredentials {
+  return {
+    refresh: JSON.stringify(payload),
+    access: payload.apiKey,
+    expires: Date.now() + 24 * 60 * 60 * 1000,
+  };
+}
+
+function decodeCreds(creds: OAuthCredentials): CredsPayload {
+  try {
+    const parsed = JSON.parse(creds.refresh ?? "");
+    return {
+      baseUrl: typeof parsed.baseUrl === "string" ? parsed.baseUrl : "",
+      apiKey: typeof parsed.apiKey === "string" ? parsed.apiKey : (creds.access ?? ""),
+    };
+  } catch {
+    return { baseUrl: "", apiKey: creds.access ?? "" };
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Configuration fallback (env vars)
+// ---------------------------------------------------------------------------
+
+const DEFAULT_BASE_URL = "https://ai.zygoon.pl/v1";
+
+function getEnvBaseUrl(): string {
+  return process.env.ROZALIA_BASE_URL ?? DEFAULT_BASE_URL;
+}
+
+function getEnvApiKey(): string | undefined {
+  return process.env.ROZALIA_API_KEY;
+}
+
+// ---------------------------------------------------------------------------
+// Model discovery
+// ---------------------------------------------------------------------------
+
+async function fetchModels(
+  baseUrl: string,
+  apiKey: string | undefined,
+  signal: AbortSignal,
+): Promise<ProviderModelConfig[]> {
+  const url = new URL("/v1/models", baseUrl);
+
+  const headers: Record<string, string> = { "Content-Type": "application/json" };
+  if (apiKey) {
+    headers["Authorization"] = `Bearer ${apiKey}`;
+  }
+
+  // Use a manual timeout via AbortController for Node.js compatibility
+  // (AbortSignal.timeout / AbortSignal.any may not be available on older versions)
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), 5_000);
+  try {
+    const response = await fetch(url.toString(), { signal: controller.signal, headers });
+
+    if (!response.ok) {
+      const text = await response.text().catch(() => "");
+      throw new Error(`Model discovery failed (${response.status}): ${text.slice(0, 200)}`);
+    }
+
+    const data = (await response.json()) as {
+      data?: Array<Record<string, unknown>>;
+      models?: Array<Record<string, unknown>>;
+    };
+
+    const entries = data.data ?? data.models ?? [];
+    if (!Array.isArray(entries)) {
+      throw new Error("Unexpected /v1/models response format");
+    }
+
+    return entries.map((entry) => mapModel(entry));
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+function mapModel(entry: Record<string, unknown>): ProviderModelConfig {
+  const id =
+    (entry.id as string) ??
+    (entry.modelId as string) ??
+    (entry.model_id as string) ??
+    (entry.root as string) ??
+    "unknown";
+
+  const name =
+    (entry.name as string) ??
+    (entry.displayName as string) ??
+    (entry.display_name as string) ??
+    id;
+
+  // context_length may be nested inside a custom provider object (e.g. rozalia.context_length)
+  const customObj = entry.rozalia as Record<string, unknown> | undefined;
+  const contextWindow =
+    (entry.context_window as number) ??
+    (entry.context as number) ??
+    (entry.max_context_length as number) ??
+    (entry.maxContextLength as number) ??
+    (customObj?.context_length as number) ??
+    128_000;
+
+  const maxTokens =
+    (entry.max_tokens as number) ??
+    (entry.maxTokens as number) ??
+    (entry.max_completion_tokens as number) ??
+    8_192;
+
+  return {
+    id,
+    name,
+    reasoning: false,
+    input: ["text"],
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    contextWindow,
+    maxTokens,
+  };
+}
+
+function getFallbackModels(): ProviderModelConfig[] {
+  return [
+    {
+      id: "unknown",
+      name: "Rozalia Model (discovery failed)",
+      reasoning: false,
+      input: ["text"],
+      cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+      contextWindow: 128_000,
+      maxTokens: 8_192,
+    },
+  ];
+}
+
+// ---------------------------------------------------------------------------
+// Provider registration helper
+// ---------------------------------------------------------------------------
+
+async function registerRozaliaProvider(
+  pi: ExtensionAPI,
+  creds: CredsPayload,
+  oauthBlock: {
+    name: string;
+    login: (callbacks: OAuthLoginCallbacks) => Promise<OAuthCredentials>;
+    refreshToken: (creds: OAuthCredentials, signal: AbortSignal) => Promise<OAuthCredentials>;
+    getApiKey: (creds: OAuthCredentials) => string;
+  },
+): Promise<void> {
+  const { baseUrl, apiKey } = creds;
+  if (!baseUrl) return;
+
+  let models: ProviderModelConfig[];
+  try {
+    const controller = new AbortController();
+    models = await fetchModels(baseUrl, apiKey, controller.signal);
+    if (models.length === 0) {
+      models = getFallbackModels();
+    }
+  } catch {
+    models = getFallbackModels();
+  }
+
+  const config: Record<string, unknown> = {
+    name: "Rozalia",
+    baseUrl,
+    api: "openai-completions",
+    models,
+    oauth: oauthBlock,
+  };
+
+  if (apiKey) {
+    config.apiKey = apiKey;
+  }
+
+  pi.registerProvider("rozalia", config);
+}
+
+// ---------------------------------------------------------------------------
+// OAuth login / refresh
+// ---------------------------------------------------------------------------
+
+/**
+ * Create a login flow that captures `pi` in the closure so it can
+ * call registerRozaliaProvider before returning the credential.
+ */
+function createLoginFlow(
+  defaultUrl: string,
+  defaultApiKey: string | undefined,
+): (pi: ExtensionAPI, callbacks: OAuthLoginCallbacks) => Promise<OAuthCredentials> {
+  return async (pi: ExtensionAPI, callbacks: OAuthLoginCallbacks) => {
+    const inputUrl = await callbacks.onPrompt({
+      message: `Enter Rozalia server URL (press Enter for ${defaultUrl}):`,
+    });
+    const trimmedUrl = inputUrl.trim();
+    const baseUrl = trimmedUrl ? trimmedUrl : defaultUrl;
+
+    const inputKey = await callbacks.onPrompt({
+      message: `Enter API key (optional — press Enter to skip):`,
+    });
+    const apiKey = inputKey.trim() || defaultApiKey || "";
+
+    const creds: CredsPayload = { baseUrl, apiKey };
+
+    // Verify connectivity and fetch models
+    try {
+      const controller = new AbortController();
+      await fetchModels(baseUrl, apiKey, controller.signal);
+    } catch {
+      // Still register — models will be discovered later or show fallback
+    }
+
+    // Actually register the provider so models appear immediately
+    const oauthBlock = buildOauthBlock(defaultUrl, defaultApiKey);
+    await registerRozaliaProvider(pi, creds, oauthBlock);
+
+    return encodeCreds(creds);
+  };
+}
+
+// ---------------------------------------------------------------------------
+// OAuth block factory (shared between /login and startup)
+// ---------------------------------------------------------------------------
+
+function buildOauthBlock(
+  defaultUrl: string,
+  defaultApiKey: string | undefined,
+) {
+  return {
+    name: "Rozalia",
+    login: createLoginFlow(defaultUrl, defaultApiKey),
+    refreshToken: async (creds: OAuthCredentials, _signal: AbortSignal) => {
+      const payload = decodeCreds(creds);
+      try {
+        const ctrl = new AbortController();
+        await fetchModels(payload.baseUrl, payload.apiKey, ctrl.signal);
+      } catch {
+        // network blip
+      }
+      return creds;
+    },
+    getApiKey: (creds: OAuthCredentials) => decodeCreds(creds).apiKey || "",
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Extension entry point
+// ---------------------------------------------------------------------------
+
+export default async function (pi: ExtensionAPI) {
+  const envBaseUrl = getEnvBaseUrl();
+  const envApiKey = getEnvApiKey();
+
+  // Try to restore saved credentials from auth.json.
+  // Handles both our custom OAuth format ({ refresh, access }) and
+  // Pi's built-in api_key format ({ type: "api_key", key }).
+  let storedCreds: CredsPayload | null = null;
+  try {
+    const authPath = `${process.env.HOME ?? "/"}/.pi/agent/auth.json`;
+    const raw = fs.readFileSync(authPath, "utf-8");
+    const auth = JSON.parse(raw) as Record<string, unknown>;
+    const cred = auth["rozalia"] as Record<string, unknown> | undefined;
+    if (cred) {
+      // Built-in api_key format
+      if (cred.type === "api_key" && typeof cred.key === "string" && cred.key) {
+        storedCreds = { baseUrl: envBaseUrl, apiKey: cred.key };
+      }
+      // Custom OAuth format
+      else {
+        const parsed = decodeCreds(cred as OAuthCredentials);
+        if (parsed.baseUrl) storedCreds = parsed;
+      }
+    }
+  } catch {
+    // No saved credential — will use env vars or prompt
+  }
+
+  const oauthBlock = buildOauthBlock(envBaseUrl, envApiKey);
+
+  // Initial stub registration so "Rozalia" appears in /login selector
+  pi.registerProvider("rozalia", {
+    name: "Rozalia",
+    baseUrl: envBaseUrl,
+    api: "openai-completions",
+    models: [],
+    oauth: oauthBlock,
+  });
+
+  // Best-effort: if env vars OR saved credentials provide a key,
+  // register eagerly so models appear without waiting for /login.
+  let credsToUse: CredsPayload | null = null;
+  if (envApiKey) {
+    credsToUse = { baseUrl: envBaseUrl, apiKey: envApiKey };
+  } else if (storedCreds?.apiKey) {
+    credsToUse = storedCreds;
+  }
+
+  if (credsToUse) {
+    try {
+      await registerRozaliaProvider(pi, credsToUse, oauthBlock);
+    } catch {
+      // ignore — will retry on next call
+    }
+  }
+}

package/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "pi-rozalia",
+  "version": "0.1.0",
+  "description": "OpenAI-compatible provider extension for the Pi coding agent — connects to Rozalia AI",
+  "keywords": [
+    "pi-package",
+    "rozalia",
+    "ai",
+    "openai",
+    "provider"
+  ],
+  "license": "MIT",
+  "type": "module",
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-ai": "*"
+  }
+}