@victor-software-house/pi-openai-proxy 0.1.1 → 0.2.1

package/README.md

@@ -135,21 +135,46 @@ openrouter/anthropic/claude-sonnet-4-20250514
 
 ## Configuration
 
-The proxy reuses pi's existing configuration:
+### What comes from pi
 
-- **API keys**: `~/.pi/agent/auth.json` (managed by `pi /login`)
-- **Custom models**: `~/.pi/agent/models.json`
+The proxy reads two files from pi's configuration directory (`~/.pi/agent/`):
 
-### Environment Variables
-
-| Variable | Default | Description |
+| File | Managed by | What the proxy uses |
 |---|---|---|
-| `PI_PROXY_HOST` | `127.0.0.1` | Bind address |
-| `PI_PROXY_PORT` | `4141` | Listen port |
-| `PI_PROXY_AUTH_TOKEN` | (disabled) | Bearer token for proxy authentication |
-| `PI_PROXY_REMOTE_IMAGES` | `false` | Enable remote image URL fetching |
-| `PI_PROXY_MAX_BODY_SIZE` | `52428800` (50 MB) | Maximum request body size in bytes |
-| `PI_PROXY_UPSTREAM_TIMEOUT_MS` | `120000` (120s) | Upstream request timeout in milliseconds |
+| `auth.json` | `pi /login` | API keys for each provider (Anthropic, OpenAI, Google, etc.) |
+| `models.json` | pi built-in + user edits | Model definitions, capabilities, and pricing |
+
+The proxy does **not** read pi's `settings.json` (installed packages, enabled extensions) or session-level model filters (`--models` flag). All models with configured credentials are exposed through the proxy, regardless of pi session scope.
+
+### What the proxy adds
+
+Proxy-specific settings are configured via environment variables or the `/proxy config` panel (when installed as a pi package):
+
+| Setting | Env variable | Default | Description |
+|---|---|---|---|
+| Bind address | `PI_PROXY_HOST` | `127.0.0.1` | Network interface (`127.0.0.1` = local only, `0.0.0.0` = all) |
+| Port | `PI_PROXY_PORT` | `4141` | HTTP listen port |
+| Auth token | `PI_PROXY_AUTH_TOKEN` | (disabled) | Bearer token for proxy authentication |
+| Remote images | `PI_PROXY_REMOTE_IMAGES` | `false` | Allow remote image URL fetching |
+| Max body size | `PI_PROXY_MAX_BODY_SIZE` | `52428800` (50 MB) | Maximum request body size in bytes |
+| Upstream timeout | `PI_PROXY_UPSTREAM_TIMEOUT_MS` | `120000` (120s) | Upstream request timeout in milliseconds |
+
+When used as a pi package, these settings are persisted in `~/.pi/agent/proxy-config.json` and applied when the extension spawns the proxy.
+
+### Discovering available models
+
+List all models the proxy can reach (models with configured credentials):
+
+```bash
+curl http://localhost:4141/v1/models | jq '.data[].id'
+```
+
+Each model includes extended metadata under `x_pi`:
+
+```bash
+curl http://localhost:4141/v1/models/anthropic%2Fclaude-sonnet-4-20250514 | jq '.x_pi'
+# { "api": "anthropic", "reasoning": true, "input": ["text", "image"], ... }
+```
 
 ### Per-request API key override
 
@@ -174,23 +199,38 @@ curl http://localhost:4141/v1/models \
   -H "Authorization: Bearer my-secret-token"
 ```
 
+### API compatibility
+
+The proxy implements a subset of the [OpenAI Chat Completions API](https://platform.openai.com/docs/api-reference/chat/create). Request and response shapes match the OpenAI specification for supported fields. Unsupported fields are rejected with `422` and an OpenAI-style error body naming the offending parameter.
+
+There is no OpenAPI/Swagger spec for the proxy itself. Use the [OpenAI API reference](https://platform.openai.com/docs/api-reference/chat/create) as the primary documentation, noting the supported subset listed in this README.
+
 ## Pi Integration
 
-Install as a pi package to get the `/proxy` command and `--proxy` flag inside pi sessions:
+Install as a pi package to get the `/proxy` command family and `--proxy` flag:
 
 ```bash
 pi install npm:@victor-software-house/pi-openai-proxy
 ```
 
-### Start the proxy from inside pi
+### Command family
 
 ```
-/proxy start     Start the proxy server
-/proxy stop      Stop the proxy server
-/proxy status    Show proxy status (default)
-/proxy           Show proxy status
+/proxy               Open the settings panel
+/proxy start         Start the proxy server
+/proxy stop          Stop the proxy server (session-managed only)
+/proxy status        Show proxy status
+/proxy config        Open the settings panel
+/proxy show          Summarize current configuration
+/proxy path          Show config file location
+/proxy reset         Restore default settings
+/proxy help          Show usage
 ```
 
+### Settings panel
+
+`/proxy` (or `/proxy config`) opens an interactive settings panel where you can configure the bind address, port, auth token, remote images, body size limit, and upstream timeout. Changes are saved to `~/.pi/agent/proxy-config.json` immediately. Restart the proxy to apply changes.
+
 ### Auto-start with pi
 
 ```bash

package/extensions/proxy.ts

@@ -1,32 +1,162 @@
 /**
- * Pi extension: /proxy command and --proxy flag.
+ * Pi extension: /proxy command family with config panel.
  *
- * Manages the pi-openai-proxy server from inside a pi session.
+ * Command family:
+ *   /proxy            Open settings panel
+ *   /proxy start      Start the proxy server
+ *   /proxy stop       Stop the proxy server (session-managed only)
+ *   /proxy status     Show proxy status
+ *   /proxy config     Open settings panel (alias)
+ *   /proxy show       Summarize current config
+ *   /proxy path       Show config file location
+ *   /proxy reset      Restore default settings
+ *   /proxy help       Usage line
  *
- * - /proxy          Show status
- * - /proxy start    Start the proxy server
- * - /proxy stop     Stop the proxy server (session-managed only)
- * - /proxy status   Show status
- * - --proxy         Auto-start on session start
+ * Flag:
+ *   --proxy           Auto-start on session start
  */
 
-import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
+import {
+	getSettingsListTheme,
+	type ExtensionAPI,
+	type ExtensionCommandContext,
+	type ExtensionContext,
+} from "@mariozechner/pi-coding-agent";
+import { Container, SettingsList, Text, type SettingItem } from "@mariozechner/pi-tui";
 import { spawn, type ChildProcess } from "node:child_process";
-import { resolve, dirname } from "node:path";
+import {
+	existsSync,
+	mkdirSync,
+	readFileSync,
+	renameSync,
+	unlinkSync,
+	writeFileSync,
+} from "node:fs";
+import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 
-export default function proxyExtension(pi: ExtensionAPI) {
-	let proxyProcess: ChildProcess | undefined;
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+interface ProxyConfig {
+	host: string;
+	port: number;
+	authToken: string;
+	remoteImages: boolean;
+	maxBodySizeMb: number;
+	upstreamTimeoutSec: number;
+}
+
+interface RuntimeStatus {
+	reachable: boolean;
+	models: number;
+	managed: boolean;
+}
+
+// ---------------------------------------------------------------------------
+// Defaults and normalization
+// ---------------------------------------------------------------------------
+
+const DEFAULT_CONFIG: ProxyConfig = {
+	host: "127.0.0.1",
+	port: 4141,
+	authToken: "",
+	remoteImages: false,
+	maxBodySizeMb: 50,
+	upstreamTimeoutSec: 120,
+};
+
+function toObject(value: unknown): Record<string, unknown> {
+	if (value === null || value === undefined || typeof value !== "object" || Array.isArray(value)) {
+		return {};
+	}
+	return value as Record<string, unknown>;
+}
+
+function clampInt(raw: unknown, min: number, max: number, fallback: number): number {
+	if (typeof raw !== "number" || !Number.isFinite(raw)) return fallback;
+	return Math.max(min, Math.min(max, Math.round(raw)));
+}
+
+function normalizeConfig(raw: unknown): ProxyConfig {
+	const v = toObject(raw);
+	return {
+		host: typeof v["host"] === "string" && v["host"].length > 0 ? (v["host"] as string) : DEFAULT_CONFIG.host,
+		port: clampInt(v["port"], 1, 65535, DEFAULT_CONFIG.port),
+		authToken: typeof v["authToken"] === "string" ? (v["authToken"] as string) : DEFAULT_CONFIG.authToken,
+		remoteImages: typeof v["remoteImages"] === "boolean" ? (v["remoteImages"] as boolean) : DEFAULT_CONFIG.remoteImages,
+		maxBodySizeMb: clampInt(v["maxBodySizeMb"], 1, 500, DEFAULT_CONFIG.maxBodySizeMb),
+		upstreamTimeoutSec: clampInt(v["upstreamTimeoutSec"], 5, 600, DEFAULT_CONFIG.upstreamTimeoutSec),
+	};
+}
+
+// ---------------------------------------------------------------------------
+// Config persistence
+// ---------------------------------------------------------------------------
+
+function getConfigPath(): string {
+	const piDir = process.env["PI_CODING_AGENT_DIR"] ?? resolve(process.env["HOME"] ?? "~", ".pi", "agent");
+	return resolve(piDir, "proxy-config.json");
+}
+
+function loadConfig(): ProxyConfig {
+	const p = getConfigPath();
+	if (!existsSync(p)) return { ...DEFAULT_CONFIG };
+	try {
+		return normalizeConfig(JSON.parse(readFileSync(p, "utf-8")));
+	} catch {
+		return { ...DEFAULT_CONFIG };
+	}
+}
+
+function saveConfig(config: ProxyConfig): void {
+	const p = getConfigPath();
+	const normalized = normalizeConfig(config);
+	const tmp = `${p}.tmp`;
+	try {
+		mkdirSync(dirname(p), { recursive: true });
+		writeFileSync(tmp, `${JSON.stringify(normalized, null, "\t")}\n`, "utf-8");
+		renameSync(tmp, p);
+	} catch {
+		if (existsSync(tmp)) unlinkSync(tmp);
+	}
+}
+
+// ---------------------------------------------------------------------------
+// Config -> env vars
+// ---------------------------------------------------------------------------
 
-	const host = process.env["PI_PROXY_HOST"] ?? "127.0.0.1";
-	const port = process.env["PI_PROXY_PORT"] ?? "4141";
-	const proxyUrl = `http://${host}:${port}`;
+function configToEnv(config: ProxyConfig): Record<string, string> {
+	const env: Record<string, string> = {};
+	env["PI_PROXY_HOST"] = config.host;
+	env["PI_PROXY_PORT"] = String(config.port);
+	if (config.authToken.length > 0) {
+		env["PI_PROXY_AUTH_TOKEN"] = config.authToken;
+	}
+	env["PI_PROXY_REMOTE_IMAGES"] = String(config.remoteImages);
+	env["PI_PROXY_MAX_BODY_SIZE"] = String(config.maxBodySizeMb * 1024 * 1024);
+	env["PI_PROXY_UPSTREAM_TIMEOUT_MS"] = String(config.upstreamTimeoutSec * 1000);
+	return env;
+}
+
+// ---------------------------------------------------------------------------
+// Extension
+// ---------------------------------------------------------------------------
+
+export default function proxyExtension(pi: ExtensionAPI): void {
+	let proxyProcess: ChildProcess | undefined;
+	let config = loadConfig();
 
 	const extensionDir = dirname(fileURLToPath(import.meta.url));
 	const packageRoot = resolve(extensionDir, "..");
 	const proxyEntry = resolve(packageRoot, "dist", "index.mjs");
 
-	// --- Flag: --proxy ---
+	function proxyUrl(): string {
+		return `http://${config.host}:${String(config.port)}`;
+	}
+
+	// --- Flag ---
 
 	pi.registerFlag("proxy", {
 		description: "Start the OpenAI proxy on session start",
@@ -37,6 +167,7 @@ export default function proxyExtension(pi: ExtensionAPI) {
 	// --- Lifecycle ---
 
 	pi.on("session_start", async (_event, ctx) => {
+		config = loadConfig();
 		if (pi.getFlag("--proxy")) {
 			await startProxy(ctx);
 		} else {
@@ -48,60 +179,84 @@ export default function proxyExtension(pi: ExtensionAPI) {
 		killProxy();
 	});
 
-	// --- Command: /proxy ---
+	// --- Command family ---
+
+	const SUBCOMMANDS = ["start", "stop", "status", "config", "show", "path", "reset", "help"];
+	const USAGE = "/proxy [start|stop|status|config|show|path|reset|help]";
 
 	pi.registerCommand("proxy", {
-		description: "Manage the OpenAI-compatible proxy (start/stop/status)",
+		description: "Manage the OpenAI-compatible proxy",
 		getArgumentCompletions: (prefix) => {
-			const subs = [
-				{ value: "start", label: "Start the proxy server" },
-				{ value: "stop", label: "Stop the proxy server" },
-				{ value: "status", label: "Show proxy status" },
-			];
-			if (prefix.length === 0) return subs;
-			return subs.filter((s) => s.value.startsWith(prefix));
+			const trimmed = prefix.trimStart();
+			const matches = SUBCOMMANDS.filter((s) => s.startsWith(trimmed));
+			return matches.length > 0 ? matches.map((value) => ({ value, label: value })) : null;
 		},
 		handler: async (args, ctx) => {
 			const sub = args.trim().split(/\s+/)[0] ?? "";
 
 			switch (sub) {
-				case "":
-				case "status":
-					await showStatus(ctx);
-					break;
 				case "start":
 					await startProxy(ctx);
-					break;
+					return;
 				case "stop":
 					await stopProxy(ctx);
+					return;
+				case "status":
+					await showStatus(ctx);
+					return;
+				case "show":
+					await showConfig(ctx);
+					return;
+				case "path":
+					ctx.ui.notify(getConfigPath(), "info");
+					return;
+				case "reset":
+					config = { ...DEFAULT_CONFIG };
+					saveConfig(config);
+					ctx.ui.notify("Proxy settings reset to defaults", "info");
+					return;
+				case "help":
+					ctx.ui.notify(USAGE, "info");
+					return;
+				case "":
+				case "config":
 					break;
 				default:
-					ctx.ui.notify("/proxy [start|stop|status]", "info");
+					ctx.ui.notify(USAGE, "warning");
+					return;
 			}
+
+			// Default: open settings panel
+			if (!ctx.hasUI) {
+				ctx.ui.notify("/proxy requires interactive mode. Use /proxy show instead.", "warning");
+				return;
+			}
+			await openSettingsPanel(ctx);
 		},
 	});
 
-	// --- Proxy management ---
+	// --- Proxy process management ---
 
-	async function probe(): Promise<{ reachable: boolean; models: number }> {
+	async function probe(): Promise<RuntimeStatus> {
+		const managed = proxyProcess !== undefined;
 		try {
-			const res = await fetch(`${proxyUrl}/v1/models`, {
+			const res = await fetch(`${proxyUrl()}/v1/models`, {
 				signal: AbortSignal.timeout(2000),
 			});
 			if (res.ok) {
 				const body = (await res.json()) as { data?: unknown[] };
-				return { reachable: true, models: body.data?.length ?? 0 };
+				return { reachable: true, models: body.data?.length ?? 0, managed };
 			}
 		} catch {
 			// not reachable
 		}
-		return { reachable: false, models: 0 };
+		return { reachable: false, models: 0, managed };
 	}
 
 	async function refreshStatus(ctx: ExtensionContext): Promise<void> {
 		const status = await probe();
 		if (status.reachable) {
-			ctx.ui.setStatus("proxy", `proxy: ${proxyUrl} (${String(status.models)} models)`);
+			ctx.ui.setStatus("proxy", `proxy: ${proxyUrl()} (${String(status.models)} models)`);
 		} else if (proxyProcess !== undefined) {
 			ctx.ui.setStatus("proxy", "proxy: starting...");
 		} else {
@@ -110,10 +265,11 @@ export default function proxyExtension(pi: ExtensionAPI) {
 	}
 
 	async function startProxy(ctx: ExtensionContext): Promise<void> {
+		config = loadConfig();
 		const status = await probe();
 		if (status.reachable) {
 			ctx.ui.notify(
-				`Proxy already running at ${proxyUrl} (${String(status.models)} models)`,
+				`Proxy already running at ${proxyUrl()} (${String(status.models)} models)`,
 				"info",
 			);
 			await refreshStatus(ctx);
@@ -128,10 +284,12 @@ export default function proxyExtension(pi: ExtensionAPI) {
 		ctx.ui.setStatus("proxy", "proxy: starting...");
 
 		try {
+			const proxyEnv = { ...process.env, ...configToEnv(config) };
+
 			proxyProcess = spawn("bun", ["run", proxyEntry], {
 				stdio: ["ignore", "pipe", "pipe"],
 				detached: false,
-				env: { ...process.env },
+				env: proxyEnv,
 			});
 
 			proxyProcess.on("exit", (code) => {
@@ -148,15 +306,14 @@ export default function proxyExtension(pi: ExtensionAPI) {
 				ctx.ui.setStatus("proxy", undefined);
 			});
 
-			// Wait for the server to become reachable
 			const ready = await waitForReady(3000);
 			if (ready.reachable) {
 				ctx.ui.notify(
-					`Proxy started at ${proxyUrl} (${String(ready.models)} models)`,
+					`Proxy started at ${proxyUrl()} (${String(ready.models)} models)`,
 					"info",
 				);
 			} else {
-				ctx.ui.notify(`Proxy spawned but not yet reachable at ${proxyUrl}`, "warning");
+				ctx.ui.notify(`Proxy spawned but not yet reachable at ${proxyUrl()}`, "warning");
 			}
 			await refreshStatus(ctx);
 		} catch (err: unknown) {
@@ -177,7 +334,7 @@ export default function proxyExtension(pi: ExtensionAPI) {
 		const status = await probe();
 		if (status.reachable) {
 			ctx.ui.notify(
-				`Proxy at ${proxyUrl} is running externally (not managed by this session)`,
+				`Proxy at ${proxyUrl()} is running externally (not managed by this session)`,
 				"info",
 			);
 		} else {
@@ -187,11 +344,11 @@ export default function proxyExtension(pi: ExtensionAPI) {
 
 	async function showStatus(ctx: ExtensionContext): Promise<void> {
 		const status = await probe();
-		const managed = proxyProcess !== undefined ? " (managed)" : " (external)";
+		const tag = status.managed ? " (managed)" : " (external)";
 
 		if (status.reachable) {
 			ctx.ui.notify(
-				`${proxyUrl}${managed} -- ${String(status.models)} models available`,
+				`${proxyUrl()}${tag} -- ${String(status.models)} models available`,
 				"info",
 			);
 		} else {
@@ -200,6 +357,20 @@ export default function proxyExtension(pi: ExtensionAPI) {
 		await refreshStatus(ctx);
 	}
 
+	async function showConfig(ctx: ExtensionContext): Promise<void> {
+		config = loadConfig();
+		const lines = [
+			`host: ${config.host}`,
+			`port: ${String(config.port)}`,
+			`auth: ${config.authToken.length > 0 ? "enabled" : "disabled"}`,
+			`remote images: ${String(config.remoteImages)}`,
+			`max body: ${String(config.maxBodySizeMb)} MB`,
+			`upstream timeout: ${String(config.upstreamTimeoutSec)}s`,
+		];
+		ctx.ui.notify(lines.join(" | "), "info");
+		await refreshStatus(ctx);
+	}
+
 	function killProxy(): void {
 		if (proxyProcess !== undefined) {
 			proxyProcess.kill("SIGTERM");
@@ -207,9 +378,7 @@ export default function proxyExtension(pi: ExtensionAPI) {
 		}
 	}
 
-	async function waitForReady(
-		timeoutMs: number,
-	): Promise<{ reachable: boolean; models: number }> {
+	async function waitForReady(timeoutMs: number): Promise<RuntimeStatus> {
 		const start = Date.now();
 		const interval = 300;
 		while (Date.now() - start < timeoutMs) {
@@ -217,6 +386,157 @@ export default function proxyExtension(pi: ExtensionAPI) {
 			if (status.reachable) return status;
 			await new Promise((r) => setTimeout(r, interval));
 		}
-		return { reachable: false, models: 0 };
+		return { reachable: false, models: 0, managed: proxyProcess !== undefined };
+	}
+
+	// --- Settings panel ---
+
+	function buildSettingItems(): SettingItem[] {
+		return [
+			{
+				id: "host",
+				label: "Bind address",
+				description: "Network interface to listen on (127.0.0.1 = local only, 0.0.0.0 = all)",
+				currentValue: config.host,
+				values: ["127.0.0.1", "0.0.0.0"],
+			},
+			{
+				id: "port",
+				label: "Port",
+				description: "HTTP port for the proxy",
+				currentValue: String(config.port),
+				values: ["4141", "8080", "3000", "9090"],
+			},
+			{
+				id: "authToken",
+				label: "Proxy auth",
+				description: "Require bearer token for all requests",
+				currentValue: config.authToken.length > 0 ? "enabled" : "disabled",
+				values: ["disabled", "enabled"],
+			},
+			{
+				id: "remoteImages",
+				label: "Remote images",
+				description: "Allow remote image URL fetching (security risk if exposed)",
+				currentValue: config.remoteImages ? "on" : "off",
+				values: ["off", "on"],
+			},
+			{
+				id: "maxBodySizeMb",
+				label: "Max body size",
+				description: "Maximum request body in MB",
+				currentValue: `${String(config.maxBodySizeMb)} MB`,
+				values: ["10 MB", "50 MB", "100 MB", "200 MB"],
+			},
+			{
+				id: "upstreamTimeoutSec",
+				label: "Upstream timeout",
+				description: "Max seconds to wait for upstream provider response",
+				currentValue: `${String(config.upstreamTimeoutSec)}s`,
+				values: ["30s", "60s", "120s", "300s"],
+			},
+		];
+	}
+
+	function applySetting(id: string, value: string): void {
+		switch (id) {
+			case "host":
+				config = { ...config, host: value };
+				break;
+			case "port":
+				config = { ...config, port: clampInt(Number.parseInt(value, 10), 1, 65535, config.port) };
+				break;
+			case "authToken":
+				// Toggle: "enabled" keeps current token or sets placeholder; "disabled" clears
+				if (value === "disabled") {
+					config = { ...config, authToken: "" };
+				} else if (config.authToken.length === 0) {
+					// Generate a random token on first enable
+					const bytes = new Uint8Array(16);
+					crypto.getRandomValues(bytes);
+					const token = Array.from(bytes)
+						.map((b) => b.toString(16).padStart(2, "0"))
+						.join("");
+					config = { ...config, authToken: token };
+				}
+				break;
+			case "remoteImages":
+				config = { ...config, remoteImages: value === "on" };
+				break;
+			case "maxBodySizeMb": {
+				const mb = Number.parseInt(value, 10);
+				if (Number.isFinite(mb) && mb > 0) config = { ...config, maxBodySizeMb: mb };
+				break;
+			}
+			case "upstreamTimeoutSec": {
+				const sec = Number.parseInt(value, 10);
+				if (Number.isFinite(sec) && sec > 0) config = { ...config, upstreamTimeoutSec: sec };
+				break;
+			}
+		}
+		saveConfig(config);
+		config = loadConfig(); // read back normalized
+	}
+
+	async function openSettingsPanel(ctx: ExtensionCommandContext): Promise<void> {
+		config = loadConfig();
+
+		await ctx.ui.custom<void>(
+			(tui, theme, _kb, done) => {
+				function build(): { container: Container; settingsList: SettingsList } {
+					const container = new Container();
+					container.addChild(new Text(theme.fg("accent", theme.bold("Proxy Settings")), 1, 0));
+					container.addChild(new Text(theme.fg("dim", getConfigPath()), 1, 0));
+
+					const settingsList = new SettingsList(
+						buildSettingItems(),
+						10,
+						getSettingsListTheme(),
+						(id, newValue) => {
+							applySetting(id, newValue);
+							current = build();
+							tui.requestRender();
+						},
+						() => done(undefined),
+						{ enableSearch: true },
+					);
+
+					container.addChild(settingsList);
+					container.addChild(
+						new Text(
+							theme.fg("dim", "Esc: close | Arrow keys: navigate | Space: toggle | Restart proxy to apply"),
+							1,
+							0,
+						),
+					);
+
+					return { container, settingsList };
+				}
+
+				let current = build();
+
+				return {
+					render(width: number): string[] {
+						return current.container.render(width);
+					},
+					invalidate(): void {
+						current.container.invalidate();
+					},
+					handleInput(data: string): void {
+						current.settingsList.handleInput?.(data);
+						tui.requestRender();
+					},
+				};
+			},
+			{
+				overlay: true,
+				overlayOptions: {
+					anchor: "center",
+					width: 80,
+					maxHeight: "85%",
+					margin: 1,
+				},
+			},
+		);
 	}
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@victor-software-house/pi-openai-proxy",
-	"version": "0.1.1",
+	"version": "0.2.1",
 	"description": "Local OpenAI-compatible HTTP proxy built on pi's SDK",
 	"license": "MIT",
 	"author": "Victor Software House",