@tejasa97/pi-orcarouter-provider 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 tejasa97
+
+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,68 @@
+# @tejasa97/pi-orcarouter-provider
+
+Pi provider package for [OrcaRouter](https://orcarouter.ai) — an OpenAI-compatible API gateway with 200+ models, including the free **GLM 5.3 Flash (Free)** tier (`z-ai/glm-5.3-flash-free`).
+
+Auth is an API key stored by `/login` in `~/.pi/agent/auth.json`, with `ORCAROUTER_API_KEY` as a fallback. Model discovery uses `GET /v1/models` when a key is available, falling back to a small static catalog.
+
+## Install
+
+```sh
+pi install git:github.com/tejasa97/pi-orcarouter-provider
+```
+
+For local development:
+
+```sh
+pi install ./pi-orcarouter-provider
+```
+
+## Usage
+
+1. Create an API key in the [OrcaRouter console](https://www.orcarouter.ai/console)
+2. In Pi: `/login` → **OrcaRouter** → paste your API key
+3. `/model` → pick a model such as `orcarouter/z-ai/glm-5.3-flash-free`
+
+Or skip `/login` by exporting the key in the shell that starts Pi:
+
+```sh
+export ORCAROUTER_API_KEY="sk-orca-..."
+pi
+```
+
+Optional base URL override:
+
+```sh
+export ORCAROUTER_BASE_URL="https://api.orcarouter.ai/v1"
+```
+
+## Models
+
+Models are fetched dynamically from `GET https://api.orcarouter.ai/v1/models` when a key is configured. Chat-completions models are selected from the catalog:
+
+- entries listing `"openai"` in `supported_endpoint_types`, plus
+- free-tier stubs with a null endpoint list (e.g. `z-ai/glm-5.3-flash-free`, `deepseek/deepseek-v4-flash-free`), excluding obvious non-chat offerings (image/video/tts/embeddings by id).
+
+The static fallback includes:
+
+| Model | Reasoning | Input | Context | Max output |
+| ----- | --------- | ----- | ------- | ---------- |
+| `z-ai/glm-5.3-flash-free` | always-on | text + image | 1M | 128K |
+| `z-ai/glm-5.3-flash` | always-on | text + image | 1M | 128K |
+| `z-ai/glm-5.3` | always-on | text | 1M | 128K |
+| `deepseek/deepseek-v4-flash-free` | yes | text | 164K | 32K |
+| `tencent/hy3-free` | yes | text | 128K | 32K |
+
+## GLM-5 notes
+
+Verified against the live endpoint:
+
+- Thinking is always on; `reasoning_effort` accepts `low` / `medium` / `high` / `max`. Pi's `off` maps to `low`, `max` maps to `max`.
+- The `developer` role is rejected upstream, so the provider uses `system`.
+- Token limits are sent as `max_completion_tokens`.
+- Costs come from the catalog's per-million price fields; the free tiers are $0 (flat per-request fee).
+
+## Tests
+
+```sh
+npm test
+```

package/extensions/orcarouter/index.ts

@@ -0,0 +1,53 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { getAgentDir, type ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { ENV_API_KEY, resolveBaseUrl, resolveModels } from "./models.ts";
+import { createOrcaRouterProvider } from "./provider.ts";
+
+/**
+ * Read a stored OrcaRouter API key from <agentDir>/auth.json, as written by
+ * /login. The provider's fetchModels() receives the credential from pi, but
+ * the extension factory runs before any credential is handed to us, so we
+ * read the store directly to enable dynamic discovery at startup.
+ */
+function readStoredApiKey(agentDir = getAgentDir()): string | undefined {
+	try {
+		const raw: unknown = JSON.parse(readFileSync(join(agentDir, "auth.json"), "utf-8"));
+		if (typeof raw !== "object" || raw === null) return undefined;
+		const entry = (raw as Record<string, unknown>).orcarouter;
+		if (
+			typeof entry === "object" &&
+			entry !== null &&
+			(entry as { type?: unknown }).type === "api_key"
+		) {
+			const key = (entry as { key?: unknown }).key;
+			if (typeof key === "string" && key.trim()) return key.trim();
+		}
+		return undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+export default async function orcaRouterProvider(pi: ExtensionAPI): Promise<void> {
+	const baseUrl = resolveBaseUrl();
+	const apiKey = process.env[ENV_API_KEY]?.trim() ?? readStoredApiKey();
+	const models = await resolveModels(apiKey, { baseUrl });
+	pi.registerProvider(createOrcaRouterProvider(process.env, models));
+}
+
+export {
+	PROVIDER_ID,
+	PROVIDER_NAME,
+	ENV_API_KEY,
+	ENV_BASE_URL,
+	DEFAULT_BASE_URL,
+	STATIC_MODEL_IDS,
+	buildStaticModels,
+	buildModelsFromRemote,
+	fetchRemoteModels,
+	isChatModel,
+	resolveModels,
+	resolveBaseUrl,
+} from "./models.ts";
+export { createOrcaRouterProvider } from "./provider.ts";

package/extensions/orcarouter/models.ts

@@ -0,0 +1,398 @@
+import type { Model } from "@earendil-works/pi-ai";
+
+export const PROVIDER_ID = "orcarouter";
+export const PROVIDER_NAME = "OrcaRouter";
+export const ENV_API_KEY = "ORCAROUTER_API_KEY";
+export const ENV_BASE_URL = "ORCAROUTER_BASE_URL";
+export const DEFAULT_BASE_URL = "https://api.orcarouter.ai/v1";
+export const MODELS_ENDPOINT = "/models";
+export const MODELS_FETCH_TIMEOUT_MS = 5_000;
+
+export type OrcaRouterApi = "openai-completions";
+export type OrcaRouterModel = Model<OrcaRouterApi>;
+
+/**
+ * Raw entry shape from GET /v1/models (OpenRouter-style catalog).
+ *
+ * Chat-capable entries list "openai" in supported_endpoint_types. OrcaRouter
+ * also ships stub entries with supported_endpoint_types: null — notably the
+ * free tiers (z-ai/glm-5.3-flash-free, deepseek/deepseek-v4-flash-free, …)
+ * — which are still served through /v1/chat/completions. Those are included
+ * when their id looks like a chat model and they carry token or flat $0
+ * pricing; non-chat offerings (image, video, dubbing, embeddings) are
+ * excluded by id.
+ */
+export interface RemoteModelEntry {
+	id?: unknown;
+	object?: unknown;
+	owned_by?: unknown;
+	supported_endpoint_types?: unknown;
+	name?: unknown;
+	context_length?: unknown;
+	max_completion_tokens?: unknown;
+	architecture?: {
+		input_modalities?: unknown;
+		output_modalities?: unknown;
+	} | null;
+	top_provider?: {
+		context_length?: unknown;
+		max_completion_tokens?: unknown;
+	} | null;
+	pricing?: {
+		prompt?: unknown;
+		completion?: unknown;
+		prompt_per_million?: unknown;
+		completion_per_million?: unknown;
+		input_cache_read?: unknown;
+		request?: unknown;
+	} | null;
+}
+
+const ZERO_COST = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+
+/** Model ids that are clearly not chat-completions models. */
+const NON_CHAT_ID = /(image|video|kling|dub|tts|speech|sora|whisper|embed|dall|flux|veo|seedance|stable|diffusion|audio|voice|music|rerank)/i;
+
+/**
+ * GLM-5.x always thinks: thinking.type only accepts enabled upstream and
+ * reasoning_effort "none" is rejected, so "off" maps to the lowest effort.
+ * Effort values are low / medium / high / max.
+ */
+const GLM5_THINKING_LEVEL_MAP = {
+	off: "low",
+	minimal: "low",
+	low: "low",
+	medium: "medium",
+	high: "high",
+	xhigh: "max",
+	max: "max",
+} as const satisfies NonNullable<Model<"openai-completions">["thinkingLevelMap"]>;
+
+/** Default map for other reasoning families: thinking cannot be turned off. */
+const DEFAULT_REASONING_LEVEL_MAP = {
+	off: null,
+	minimal: null,
+	low: "low",
+	medium: "medium",
+	high: "high",
+	xhigh: "high",
+	max: null,
+} as const satisfies NonNullable<Model<"openai-completions">["thinkingLevelMap"]>;
+
+/**
+ * Shared compat for OrcaRouter models: standard OpenAI chat-completions
+ * semantics, "system" role (the "developer" role is rejected upstream), and
+ * max_completion_tokens (max_tokens also works, but this is the documented
+ * field). reasoning_effort is forwarded only for reasoning models.
+ */
+function buildCompat(reasoning: boolean): NonNullable<Model<"openai-completions">["compat"]> {
+	return {
+		supportsStore: false,
+		supportsDeveloperRole: false,
+		supportsReasoningEffort: reasoning,
+		maxTokensField: "max_completion_tokens",
+	};
+}
+
+function isGlm5(id: string): boolean {
+	return /glm-5(\.|$)/.test(id);
+}
+
+function isReasoningModel(id: string): boolean {
+	const lower = id.toLowerCase();
+	return (
+		lower.includes("glm-5") ||
+		lower.includes("glm-4.5") ||
+		lower.includes("glm-4.6") ||
+		lower.includes("glm-4.7") ||
+		lower.includes("kimi") ||
+		lower.includes("deepseek") ||
+		lower.includes("qwq") ||
+		lower.includes("minimax") ||
+		lower.includes("hy3") ||
+		lower.includes("hunyuan") ||
+		lower.includes("thinking") ||
+		lower.includes("reasoner") ||
+		lower.includes("reasoning") ||
+		lower.includes("fusion") ||
+		lower.includes("gpt-5") ||
+		lower.includes("gpt-6") ||
+		lower.includes("gpt-oss") ||
+		/(^|[^0-9])o[1-9]([^0-9]|$)/.test(lower) ||
+		lower.includes("gemini-2.5") ||
+		lower.includes("gemini-3") ||
+		lower.includes("grok-3") ||
+		lower.includes("grok-4")
+	);
+}
+
+function defaultContextWindow(id: string): number {
+	if (id.includes("glm-5")) return 1_000_000;
+	if (id.includes("glm-4")) return 200_000;
+	if (id.includes("gpt-5") || id.includes("gpt-6")) return 272_000;
+	if (id.includes("claude")) return 200_000;
+	if (id.includes("gemini-3") || id.includes("gemini-2.5-pro")) return 1_000_000;
+	if (id.includes("gemini")) return 1_000_000;
+	if (id.includes("kimi")) return 256_000;
+	if (id.includes("deepseek")) return 164_000;
+	if (id.includes("gpt-oss")) return 131_072;
+	return 128_000;
+}
+
+function defaultMaxTokens(id: string): number {
+	if (id.includes("glm-5")) return 128_000;
+	if (id.includes("glm-4")) return 131_072;
+	if (id.includes("gpt-5") || id.includes("gpt-6")) return 128_000;
+	return 32_768;
+}
+
+/** "Z.ai: GLM 5.3 Flash (Free)" -> "GLM 5.3 Flash (Free)"; fallback to prettified id. */
+function formatModelName(entryName: string | undefined, id: string): string {
+	if (entryName && entryName.trim()) return entryName.trim();
+	return id
+		.split(/[-_/]+/)
+		.filter(Boolean)
+		.map((part) => (/^\d/.test(part) ? part : part.charAt(0).toUpperCase() + part.slice(1)))
+		.join(" ");
+}
+
+/** Parse a per-million price string into a number; returns 0 on absent/invalid. */
+function parsePerMillion(value: unknown): number {
+	if (typeof value !== "string") return 0;
+	const n = Number.parseFloat(value);
+	return Number.isFinite(n) && n >= 0 ? n : 0;
+}
+
+/** Shift a decimal string right by `places` digits without floating-point error. */
+function shiftDecimal(value: string, places: number): number {
+	const match = /^(\d*)(?:\.(\d*))?$/.exec(value.trim());
+	if (!match) return Number.parseFloat(value) * 10 ** places;
+	const int = match[1] || "0";
+	const frac = match[2] ?? "";
+	const digits = int + frac;
+	const point = int.length + places;
+	const scaled =
+		point >= digits.length
+			? digits + "0".repeat(point - digits.length)
+			: digits.slice(0, point) + "." + digits.slice(point);
+	return Number(scaled);
+}
+
+/** Parse a per-token price string and convert to per-million. */
+function parsePerTokenAsMillion(value: unknown): number {
+	if (typeof value !== "string") return 0;
+	const n = shiftDecimal(value, 6);
+	return Number.isFinite(n) && n >= 0 ? n : 0;
+}
+
+/**
+ * Pi expects cost in USD per million tokens. OrcaRouter exposes both
+ * per-token fields and *_per_million strings; prefer the per-million form,
+ * fall back to the per-token fields. Flat per-request pricing (free tiers
+ * charge $0 per request) maps to zero token cost.
+ */
+function buildCost(pricing: RemoteModelEntry["pricing"]): NonNullable<Model<"openai-completions">["cost"]> {
+	if (!pricing) return { ...ZERO_COST };
+	const input =
+		parsePerMillion(pricing.prompt_per_million) || parsePerTokenAsMillion(pricing.prompt);
+	const output =
+		parsePerMillion(pricing.completion_per_million) || parsePerTokenAsMillion(pricing.completion);
+	const cacheRead = parsePerTokenAsMillion(pricing.input_cache_read);
+	return { input, output, cacheRead, cacheWrite: 0 };
+}
+
+function stringValue(value: unknown): string | undefined {
+	return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+
+function numberValue(value: unknown): number | undefined {
+	return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : undefined;
+}
+
+function stringArray(value: unknown): string[] {
+	return Array.isArray(value) ? value.filter((entry): entry is string => typeof entry === "string") : [];
+}
+
+/**
+ * Decide whether a raw catalog entry is a chat-completions model.
+ *
+ * - Endpoints list including "openai" is the reliable signal.
+ * - Null endpoints (free-tier stubs like z-ai/glm-5.3-flash-free) are kept
+ *   when the id looks like a chat model and pricing exists.
+ * - Non-null endpoint lists without "openai" (pure embeddings, image
+ *   generation, …) are dropped.
+ */
+export function isChatModel(entry: RemoteModelEntry): boolean {
+	const id = stringValue(entry.id);
+	if (!id) return false;
+
+	const endpoints = entry.supported_endpoint_types;
+	if (Array.isArray(endpoints)) return endpoints.includes("openai");
+	if (endpoints !== null && endpoints !== undefined) return false;
+
+	if (NON_CHAT_ID.test(id)) return false;
+	return entry.pricing !== null && entry.pricing !== undefined;
+}
+
+function buildModel(id: string, entry: RemoteModelEntry | undefined, baseUrl: string): OrcaRouterModel {
+	const reasoning = isReasoningModel(id);
+	const input: ("text" | "image")[] = ["text"];
+	const modalities = stringArray(entry?.architecture?.input_modalities);
+	if (modalities.includes("image") || id.includes("glm-5.3-flash")) input.push("image");
+
+	return {
+		id,
+		name: formatModelName(stringValue(entry?.name), id),
+		api: "openai-completions",
+		provider: PROVIDER_ID,
+		baseUrl,
+		reasoning,
+		thinkingLevelMap: {
+			...(isGlm5(id) ? GLM5_THINKING_LEVEL_MAP : DEFAULT_REASONING_LEVEL_MAP),
+		},
+		input,
+		cost: buildCost(entry?.pricing),
+		compat: buildCompat(reasoning),
+		contextWindow:
+			numberValue(entry?.context_length) ??
+			numberValue(entry?.top_provider?.context_length) ??
+			defaultContextWindow(id),
+		maxTokens:
+			numberValue(entry?.max_completion_tokens) ??
+			numberValue(entry?.top_provider?.max_completion_tokens) ??
+			defaultMaxTokens(id),
+	};
+}
+
+/**
+ * Static fallback catalog, used when no API key is configured or the
+ * /v1/models fetch fails. The free GLM 5.3 Flash tier is the headline model.
+ */
+export const STATIC_MODEL_IDS = [
+	"z-ai/glm-5.3-flash-free",
+	"z-ai/glm-5.3-flash",
+	"z-ai/glm-5.3",
+	"deepseek/deepseek-v4-flash-free",
+	"tencent/hy3-free",
+] as const;
+
+export function buildStaticModels(baseUrl: string): readonly OrcaRouterModel[] {
+	return STATIC_MODEL_IDS.map((id) =>
+		buildModel(
+			id,
+			id === "z-ai/glm-5.3-flash-free"
+				? {
+						id,
+						supported_endpoint_types: null,
+						name: "Z.ai: GLM 5.3 Flash (Free)",
+						context_length: 1_000_000,
+						max_completion_tokens: 128_000,
+						architecture: { input_modalities: ["text", "image", "video"] },
+						pricing: { request: "0.000000" },
+					}
+				: id === "z-ai/glm-5.3-flash"
+					? {
+							id,
+							supported_endpoint_types: ["openai"],
+							name: "Z.ai: GLM 5.3 Flash",
+							context_length: 1_000_000,
+							max_completion_tokens: 128_000,
+							architecture: { input_modalities: ["text", "image", "video"] },
+							pricing: {
+								prompt_per_million: "0.075000",
+								completion_per_million: "0.250000",
+								input_cache_read: "0.00000001725",
+							},
+						}
+					: undefined,
+			baseUrl,
+		),
+	);
+}
+
+export function buildModelsFromRemote(
+	entries: readonly RemoteModelEntry[],
+	baseUrl: string,
+): readonly OrcaRouterModel[] {
+	const seen = new Set<string>();
+	const models: OrcaRouterModel[] = [];
+	for (const entry of entries) {
+		const id = stringValue(entry.id);
+		if (!id || seen.has(id) || !isChatModel(entry)) continue;
+		seen.add(id);
+		models.push(buildModel(id, entry, baseUrl));
+	}
+	return models.sort((a, b) => a.id.localeCompare(b.id));
+}
+
+export interface FetchRemoteModelsOptions {
+	baseUrl?: string;
+	apiKey?: string;
+	fetch?: typeof globalThis.fetch;
+	timeoutMs?: number;
+	signal?: AbortSignal;
+}
+
+export async function fetchRemoteModels(
+	options: FetchRemoteModelsOptions = {},
+): Promise<readonly RemoteModelEntry[] | undefined> {
+	const baseUrl = options.baseUrl ?? resolveBaseUrl();
+	const apiKey = options.apiKey?.trim();
+	const fetchFn = options.fetch ?? globalThis.fetch;
+	const timeoutMs = options.timeoutMs ?? MODELS_FETCH_TIMEOUT_MS;
+
+	if (!apiKey || !fetchFn) return undefined;
+
+	const controller = new AbortController();
+	const timer = setTimeout(() => controller.abort(), timeoutMs);
+	options.signal?.addEventListener("abort", () => controller.abort(), { once: true });
+
+	try {
+		const response = await fetchFn(`${baseUrl}${MODELS_ENDPOINT}`, {
+			headers: { Authorization: `Bearer ${apiKey}` },
+			signal: controller.signal,
+		});
+
+		if (!response.ok) return undefined;
+
+		const json: unknown = await response.json();
+		const rawList: RemoteModelEntry[] = Array.isArray(json)
+			? json
+			: typeof json === "object" && json !== null && Array.isArray((json as { data?: unknown }).data)
+				? ((json as { data: RemoteModelEntry[] }).data ?? [])
+				: [];
+
+		return rawList.filter((entry) => stringValue(entry?.id));
+	} catch {
+		return undefined;
+	} finally {
+		clearTimeout(timer);
+	}
+}
+
+export interface ResolveModelsOptions extends FetchRemoteModelsOptions {}
+
+/**
+ * Full catalog from /v1/models when a key is available; static fallback
+ * otherwise. Discovery needs the catalog because free-tier stubs (null
+ * endpoints) and pricing metadata only appear there.
+ */
+export async function resolveModels(
+	apiKey: string | undefined,
+	options: ResolveModelsOptions = {},
+): Promise<readonly OrcaRouterModel[]> {
+	const baseUrl = options.baseUrl ?? resolveBaseUrl();
+	const entries = await fetchRemoteModels({ ...options, apiKey, baseUrl });
+	if (entries && entries.length > 0) return buildModelsFromRemote(entries, baseUrl);
+	return buildStaticModels(baseUrl);
+}
+
+function stripTrailingSlash(url: string): string {
+	return url.replace(/\/+$/, "");
+}
+
+export function resolveBaseUrl(env: NodeJS.ProcessEnv = process.env): string {
+	const override = env[ENV_BASE_URL]?.trim();
+	if (override) return stripTrailingSlash(override);
+	return DEFAULT_BASE_URL;
+}

package/extensions/orcarouter/provider.ts

@@ -0,0 +1,51 @@
+import {
+	createProvider,
+	envApiKeyAuth,
+	openAICompletionsApi,
+	type ApiKeyCredential,
+	type Credential,
+	type Provider,
+} from "@earendil-works/pi-ai/compat";
+import {
+	ENV_API_KEY,
+	PROVIDER_ID,
+	PROVIDER_NAME,
+	buildStaticModels,
+	resolveBaseUrl,
+	resolveModels,
+	type OrcaRouterApi,
+	type OrcaRouterModel,
+} from "./models.ts";
+
+function resolveApiKeyFromCredential(credential: Credential | undefined): string | undefined {
+	if (!credential) return undefined;
+	if (credential.type === "api_key") {
+		const key = (credential as ApiKeyCredential).key?.trim();
+		return key || undefined;
+	}
+	return undefined;
+}
+
+export function createOrcaRouterProvider(
+	env: NodeJS.ProcessEnv = process.env,
+	initialModels?: readonly OrcaRouterModel[],
+): Provider<OrcaRouterApi> {
+	const baseUrl = resolveBaseUrl(env);
+
+	return createProvider({
+		id: PROVIDER_ID,
+		name: PROVIDER_NAME,
+		baseUrl,
+		auth: {
+			apiKey: envApiKeyAuth("OrcaRouter API key", [ENV_API_KEY]),
+		},
+		models: initialModels ?? buildStaticModels(baseUrl),
+		async fetchModels({ credential, signal }) {
+			signal.throwIfAborted();
+			const apiKey =
+				resolveApiKeyFromCredential(credential) ?? env[ENV_API_KEY]?.trim();
+			return resolveModels(apiKey, { baseUrl, signal });
+		},
+		api: openAICompletionsApi(),
+	});
+}

package/package.json

@@ -0,0 +1,52 @@
+{
+	"name": "@tejasa97/pi-orcarouter-provider",
+	"version": "0.1.0",
+	"description": "Pi provider package for OrcaRouter (GLM 5.3 Flash Free, DeepSeek, Kimi, and more) — OpenAI-compatible gateway with dynamic model discovery.",
+	"type": "module",
+	"engines": {
+		"node": ">=22"
+	},
+	"scripts": {
+		"test": "node --test tests/*.test.mjs"
+	},
+	"keywords": [
+		"pi-package",
+		"pi-extension",
+		"pi-provider",
+		"pi-coding-agent",
+		"orcarouter",
+		"glm",
+		"z-ai",
+		"free",
+		"llm",
+		"pi"
+	],
+	"license": "MIT",
+	"homepage": "https://github.com/tejasa97/pi-orcarouter-provider#readme",
+	"bugs": {
+		"url": "https://github.com/tejasa97/pi-orcarouter-provider/issues"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/tejasa97/pi-orcarouter-provider.git"
+	},
+	"files": [
+		"extensions",
+		"package.json",
+		"README.md",
+		"LICENSE"
+	],
+	"pi": {
+		"extensions": [
+			"./extensions/orcarouter/index.ts"
+		]
+	},
+	"peerDependencies": {
+		"@earendil-works/pi-ai": "*",
+		"@earendil-works/pi-coding-agent": "*"
+	},
+	"devDependencies": {
+		"@earendil-works/pi-ai": "^0.84.0",
+		"@earendil-works/pi-coding-agent": "^0.84.0"
+	}
+}