pi-pizza 0.1.0

package/README.md

@@ -0,0 +1,119 @@
+# pi-pizza
+
+`pi-pizza` is a stock `pi` package that adds the Pizza startup mascot and a `pizza/auto` model provider.
+
+The package keeps `pi` itself unmodified. Install it as an extension package, then use the `pizza/auto` model to route each turn to a task-appropriate provider/model.
+
+## Features
+
+- Registers a `pizza/auto` model provider.
+- Sets `pizza/auto` as the global default model after the extension first loads.
+- Keeps explicit CLI choices intact: `pi --model ...` or `pi --provider ...` are not overwritten.
+- Shows the Pizza mascot in the startup header while keeping the stock `pi` help text.
+- Creates `~/.pi/agent/pizza.json` on first load.
+- Routes turns across six roles: planner, reader, easy builder, hard backend builder, hard frontend builder, and executor.
+- Prints routing decisions to stderr, for example:
+
+```text
+[pizza] 🍕 Routing to CodeBuilder [Easy / GENERAL]: opencode-go/deepseek-v4-pro
+```
+
+## Install
+
+From npm:
+
+```bash
+pi install npm:pi-pizza
+pi
+```
+
+From a local checkout:
+
+```bash
+git clone https://github.com/parkjangwon/pi-pizza.git
+cd pi-pizza
+npm install --ignore-scripts
+pi install .
+pi
+```
+
+For one-off local testing without installing:
+
+```bash
+pi -e .
+```
+
+## Default Model Behavior
+
+After the extension first loads, it writes these global defaults to `~/.pi/agent/settings.json`:
+
+```json
+{
+  "defaultProvider": "pizza",
+  "defaultModel": "auto"
+}
+```
+
+That means plain `pi` will use `pizza/auto` on later runs.
+
+To bypass Pizza for a single run, pass a model explicitly:
+
+```bash
+pi --model anthropic/claude-sonnet-4-5
+```
+
+## Configuration
+
+On first load, `pi-pizza` creates `~/.pi/agent/pizza.json`:
+
+```json
+{
+  "plannerModel": "",
+  "readerModel": "",
+  "builderEasyModel": "",
+  "builderHardBackendModel": "",
+  "builderHardFrontendModel": "",
+  "executorModel": ""
+}
+```
+
+Leave a field blank for auto-detection, or set a concrete `provider/model-id`.
+
+Example:
+
+```json
+{
+  "plannerModel": "deepseek/deepseek-chat",
+  "readerModel": "google/gemini-2.0-flash",
+  "builderEasyModel": "opencode-go/deepseek-v4-pro",
+  "builderHardBackendModel": "anthropic/claude-sonnet-4-5",
+  "builderHardFrontendModel": "anthropic/claude-sonnet-4-5",
+  "executorModel": "groq/llama-3.3-70b-versatile"
+}
+```
+
+Only models already known to `pi` and configured with auth can be selected automatically.
+
+## Commands
+
+- `/pizza` shows whether the extension is active and where the config lives.
+- `/pizza-models` shows the resolved concrete model for each Pizza role.
+- `/pizza-reset` asks for confirmation, then deletes `~/.pi/agent/pizza.json`.
+- `/pizza-header-reset` restores the built-in `pi` startup header for the current session.
+
+## Development
+
+```bash
+npm install --ignore-scripts
+npm run check
+```
+
+The package is loaded by the `pi` manifest in `package.json`:
+
+```json
+{
+  "pi": {
+    "extensions": ["./extensions/index.ts"]
+  }
+}
+```

package/extensions/index.ts

@@ -0,0 +1,53 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { deleteConfigFile, getConfigPath } from "../src/config.ts";
+import { registerMascot } from "../src/mascot.ts";
+import { PizzaRuntime } from "../src/runtime.ts";
+import { ensurePizzaDefaultSettings, hasExplicitModelSelection } from "../src/settings.ts";
+
+export default function (pi: ExtensionAPI): void {
+  const runtime = new PizzaRuntime();
+
+  pi.registerProvider("pizza", runtime.createProviderConfig());
+  registerMascot(pi);
+
+  pi.on("session_start", (_event, ctx) => {
+    runtime.bind(ctx.modelRegistry);
+    ensurePizzaDefaultSettings();
+    if (!hasExplicitModelSelection() && ctx.model?.provider !== "pizza") {
+      const pizzaAuto = ctx.modelRegistry.find("pizza", "auto");
+      if (pizzaAuto) {
+        void pi.setModel(pizzaAuto);
+      }
+    }
+  });
+
+  pi.registerCommand("pizza", {
+    description: "Show pi-pizza routing configuration",
+    handler: async (_args, ctx) => {
+      runtime.bind(ctx.modelRegistry);
+      ctx.ui.notify(runtime.describe(), "info");
+    },
+  });
+
+  pi.registerCommand("pizza-models", {
+    description: "Show resolved pi-pizza role models",
+    handler: async (_args, ctx) => {
+      runtime.bind(ctx.modelRegistry);
+      ctx.ui.notify(runtime.describeModels(), "info");
+    },
+  });
+
+  pi.registerCommand("pizza-reset", {
+    description: "Delete ~/.pi/agent/pizza.json after confirmation",
+    handler: async (_args, ctx) => {
+      const configPath = getConfigPath();
+      const confirmed = await ctx.ui.confirm("Delete pi-pizza config?", `Delete ${configPath}?`);
+      if (!confirmed) {
+        ctx.ui.notify("pi-pizza config deletion cancelled", "info");
+        return;
+      }
+      const deleted = deleteConfigFile();
+      ctx.ui.notify(deleted ? `Deleted ${configPath}` : `No config file found at ${configPath}`, "info");
+    },
+  });
+}

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "pi-pizza",
+  "version": "0.1.0",
+  "description": "Pizza mascot and multi-provider auto-router for pi.",
+  "type": "module",
+  "keywords": [
+    "pi-package",
+    "pi-extension",
+    "pizza",
+    "router"
+  ],
+  "license": "MIT",
+  "scripts": {
+    "check": "tsc --noEmit"
+  },
+  "pi": {
+    "extensions": [
+      "./extensions/index.ts"
+    ]
+  },
+  "dependencies": {
+    "chalk": "5.6.2"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-ai": "*",
+    "@earendil-works/pi-coding-agent": "*",
+    "typebox": "*"
+  },
+  "devDependencies": {
+    "@earendil-works/pi-ai": "0.78.0",
+    "@earendil-works/pi-coding-agent": "0.78.0",
+    "typescript": "5.9.3",
+    "typebox": "1.0.63"
+  }
+}

package/src/config.ts

@@ -0,0 +1,143 @@
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { Type } from "typebox";
+import { Compile } from "typebox/compile";
+import type { Api, Model } from "@earendil-works/pi-ai";
+import type { ModelLookup, PizzaConfigFile, PizzaResolvedConfig } from "./types.ts";
+
+const ConfigSchema = Type.Object({
+  plannerModel: Type.String(),
+  readerModel: Type.String(),
+  builderEasyModel: Type.String(),
+  builderHardBackendModel: Type.String(),
+  builderHardFrontendModel: Type.String(),
+  executorModel: Type.String(),
+});
+
+const validateConfig = Compile(ConfigSchema);
+
+const emptyConfig: PizzaConfigFile = {
+  plannerModel: "",
+  readerModel: "",
+  builderEasyModel: "",
+  builderHardBackendModel: "",
+  builderHardFrontendModel: "",
+  executorModel: "",
+};
+
+export function getConfigPath(): string {
+  return join(homedir(), ".pi", "agent", "pizza.json");
+}
+
+export function loadConfigFile(): PizzaConfigFile {
+  const configPath = getConfigPath();
+  if (!existsSync(configPath)) {
+    mkdirSync(join(homedir(), ".pi", "agent"), { recursive: true });
+    writeFileSync(configPath, `${JSON.stringify(emptyConfig, null, 2)}\n`, "utf8");
+    return emptyConfig;
+  }
+
+  const parsed: unknown = JSON.parse(readFileSync(configPath, "utf8"));
+  if (!validateConfig.Check(parsed)) {
+    return emptyConfig;
+  }
+
+  return parsed;
+}
+
+export function deleteConfigFile(): boolean {
+  const configPath = getConfigPath();
+  if (!existsSync(configPath)) {
+    return false;
+  }
+  unlinkSync(configPath);
+  return true;
+}
+
+export function resolveConfig(modelLookup: ModelLookup): PizzaResolvedConfig {
+  const available = modelLookup.getAvailable().filter((model) => model.provider !== "pizza");
+  const fallback = available[0] ?? createUnavailableModel();
+  const autoPlanner = findModel(
+    available,
+    ["deepseek", "openai", "openrouter", "groq", "minimax", "minimax-cn", "zai", "google"],
+    ["gpt-4o-mini", "llama", "flash", "deepseek-chat", "chat", "spark", "mini"],
+    fallback,
+  );
+  const autoReader = findModel(
+    available,
+    ["deepseek", "opencode-go", "opencode", "zai", "minimax", "minimax-cn", "groq", "openai", "openrouter", "google"],
+    ["gpt-4o-mini", "llama", "flash", "deepseek-chat", "chat", "lite", "spark", "mini", "gemini-2.0-flash"],
+    autoPlanner,
+  );
+  const autoHardBackend = findModel(
+    available,
+    ["deepseek", "anthropic", "openai", "openrouter", "groq", "zai", "minimax", "minimax-cn", "google"],
+    ["deepseek-coder", "coder", "r1", "reasoning", "sonnet", "claude-3-5", "grok-4", "grok-2", "gpt-4o"],
+    autoPlanner,
+  );
+  const autoHardFrontend = findModel(
+    available,
+    ["anthropic", "openai", "openrouter", "deepseek", "google"],
+    ["sonnet", "claude-3-5", "gpt-4o", "deepseek-coder", "coder", "pro", "gemini-2.0-pro"],
+    autoHardBackend,
+  );
+  const autoExecutor = findModel(
+    available,
+    ["groq", "deepseek", "openai", "openrouter", "zai", "minimax", "minimax-cn", "google"],
+    ["fast", "gpt-4o-mini", "llama", "deepseek-chat", "chat", "flash"],
+    autoPlanner,
+  );
+  const file = loadConfigFile();
+
+  return {
+    plannerModel: parseModelSpec(modelLookup, file.plannerModel, autoPlanner),
+    readerModel: parseModelSpec(modelLookup, file.readerModel, autoReader),
+    builderEasyModel: parseModelSpec(modelLookup, file.builderEasyModel, autoReader),
+    builderHardBackendModel: parseModelSpec(modelLookup, file.builderHardBackendModel, autoHardBackend),
+    builderHardFrontendModel: parseModelSpec(modelLookup, file.builderHardFrontendModel, autoHardFrontend),
+    executorModel: parseModelSpec(modelLookup, file.executorModel, autoExecutor),
+  };
+}
+
+function findModel(
+  available: readonly Model<Api>[],
+  providerPreference: readonly string[],
+  idKeywords: readonly string[],
+  fallback: Model<Api>,
+): Model<Api> {
+  for (const provider of providerPreference) {
+    const match = available.find(
+      (model) => model.provider === provider && idKeywords.some((keyword) => model.id.toLowerCase().includes(keyword)),
+    );
+    if (match) return match;
+  }
+  for (const provider of providerPreference) {
+    const match = available.find((model) => model.provider === provider);
+    if (match) return match;
+  }
+  return fallback;
+}
+
+function parseModelSpec(modelLookup: ModelLookup, modelSpec: string, fallback: Model<Api>): Model<Api> {
+  const slashIndex = modelSpec.indexOf("/");
+  if (slashIndex <= 0 || slashIndex === modelSpec.length - 1) {
+    return fallback;
+  }
+  return modelLookup.find(modelSpec.slice(0, slashIndex), modelSpec.slice(slashIndex + 1)) ?? fallback;
+}
+
+function createUnavailableModel(): Model<Api> {
+  return {
+    id: "unavailable",
+    name: "Unavailable",
+    api: "openai-completions",
+    provider: "pizza",
+    baseUrl: "https://invalid.local",
+    reasoning: false,
+    input: ["text"],
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    contextWindow: 128000,
+    maxTokens: 4096,
+  };
+}

package/src/errors.ts

@@ -0,0 +1,6 @@
+export class PizzaRuntimeError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "PizzaRuntimeError";
+  }
+}

package/src/mascot.ts

@@ -0,0 +1,49 @@
+import chalk from "chalk";
+import { VERSION, type ExtensionAPI, type Theme } from "@earendil-works/pi-coding-agent";
+
+export function registerMascot(pi: ExtensionAPI): void {
+  pi.on("session_start", (_event, ctx) => {
+    if (!ctx.hasUI) return;
+    ctx.ui.setHeader((_tui, theme) => ({
+      render: () => renderPizzaStartupLogo(VERSION, theme).split("\n"),
+      invalidate: () => {},
+    }));
+  });
+
+  pi.registerCommand("pizza-header-reset", {
+    description: "Restore the built-in pi startup header",
+    handler: async (_args, ctx) => {
+      ctx.ui.setHeader(undefined);
+      ctx.ui.notify("Built-in header restored", "info");
+    },
+  });
+}
+
+function renderPizzaStartupLogo(version: string, theme: Theme): string {
+  const mascotLines = [
+    chalk.white("  ▄███▄  "),
+    chalk.white("   ███   "),
+    chalk.hex("#D2B48C")(" ▐▛███▜▌ "),
+    chalk.hex("#D2B48C")("▝▜█████▛▘"),
+    chalk.hex("#D2B48C")("  ▘▘ ▝▝  "),
+  ];
+
+  const titleLine = `${theme.bold(theme.fg("accent", "pi"))}${theme.fg("dim", ` v${version}`)}`;
+  const compactInstructions = theme.fg(
+    "muted",
+    "escape interrupt · ctrl+c/ctrl+d clear/exit · / commands · ! bash · ctrl+o more",
+  );
+  const compactOnboarding = theme.fg("dim", "Press ctrl+o to show full startup help and loaded resources.");
+  const onboarding = theme.fg(
+    "dim",
+    "Pi can explain its own features and look up its docs. Ask it how to use or extend Pi.",
+  );
+
+  return [
+    `${mascotLines[0]}  ${titleLine}`,
+    `${mascotLines[1]}  ${compactInstructions}`,
+    `${mascotLines[2]}  ${compactOnboarding}`,
+    `${mascotLines[3]}`,
+    `${mascotLines[4]}  ${onboarding}`,
+  ].join("\n");
+}

package/src/router.ts

@@ -0,0 +1,125 @@
+import { completeSimple, type Api, type Context, type Message, type Model } from "@earendil-works/pi-ai";
+import type { ModelLookup, PizzaDecision, PizzaResolvedConfig } from "./types.ts";
+
+let lastClassifiedPrompt = "";
+let lastDecision: PizzaDecision | undefined;
+
+export async function selectModel(
+  config: PizzaResolvedConfig,
+  modelLookup: ModelLookup,
+  context: Context,
+): Promise<{ readonly model: Model<Api>; readonly label: string }> {
+  const lastMessage = context.messages[context.messages.length - 1];
+  const userPrompt = getLastUserMessageText(context.messages);
+  const isExecuting =
+    lastMessage?.role === "toolResult" ||
+    (lastMessage?.role === "assistant" && lastMessage.content.some((content) => content.type === "toolCall"));
+
+  if (isExecuting) {
+    return { model: config.executorModel, label: "CommandExecutor" };
+  }
+  if (!userPrompt) {
+    return { model: config.builderEasyModel, label: "CodeBuilder [Easy / GENERAL]" };
+  }
+
+  const decision = await classifyIntent(config.readerModel, modelLookup, userPrompt);
+  if (decision.difficulty === "EASY") {
+    return { model: config.builderEasyModel, label: `CodeBuilder [Easy / ${decision.domain}]` };
+  }
+  if (decision.domain === "FRONTEND") {
+    return { model: config.builderHardFrontendModel, label: "CodeBuilder [Hard / Frontend]" };
+  }
+  return { model: config.builderHardBackendModel, label: `CodeBuilder [Hard / ${decision.domain}]` };
+}
+
+function getLastUserMessageText(messages: readonly Message[]): string {
+  const lastUser = [...messages].reverse().find((message) => message.role === "user");
+  if (!lastUser) return "";
+  if (typeof lastUser.content === "string") return lastUser.content;
+  return lastUser.content
+    .filter((content) => content.type === "text")
+    .map((content) => content.text)
+    .join("\n");
+}
+
+async function classifyIntent(model: Model<Api>, modelLookup: ModelLookup, userPrompt: string): Promise<PizzaDecision> {
+  if (lastClassifiedPrompt === userPrompt && lastDecision) {
+    return lastDecision;
+  }
+
+	const auth = await modelLookup.getApiKeyAndHeaders(model);
+	const message = await completeSimple(
+		model,
+		{
+			messages: [{ role: "user", content: buildClassificationPrompt(userPrompt), timestamp: Date.now() }],
+		},
+		auth.ok ? buildAuthOptions(auth) : undefined,
+	);
+  const text = message.content
+    .filter((content) => content.type === "text")
+    .map((content) => content.text)
+    .join("\n");
+  const decision = parseDecision(text);
+
+  lastClassifiedPrompt = userPrompt;
+  lastDecision = decision;
+  return decision;
+}
+
+function parseDecision(text: string): PizzaDecision {
+	const jsonMatch = text.match(/\{[\s\S]*\}/);
+	if (!jsonMatch) return { difficulty: "EASY", domain: "GENERAL" };
+	let parsed: unknown;
+	try {
+		parsed = JSON.parse(jsonMatch[0]);
+	} catch (error) {
+		if (error instanceof SyntaxError) {
+			return { difficulty: "EASY", domain: "GENERAL" };
+		}
+		throw error;
+	}
+	if (!isDecisionPayload(parsed)) return { difficulty: "EASY", domain: "GENERAL" };
+	return {
+		difficulty: parsed.difficulty,
+		domain: parsed.domain,
+	};
+}
+
+function buildAuthOptions(auth: { readonly apiKey?: string; readonly headers?: Record<string, string> }): {
+	readonly apiKey?: string;
+	readonly headers?: Record<string, string>;
+} {
+	return {
+		...(auth.apiKey ? { apiKey: auth.apiKey } : {}),
+		...(auth.headers ? { headers: auth.headers } : {}),
+	};
+}
+
+function isDecisionPayload(value: unknown): value is PizzaDecision {
+  if (!value || typeof value !== "object") return false;
+  if (!("difficulty" in value) || !("domain" in value)) return false;
+  return (
+    (value.difficulty === "EASY" || value.difficulty === "HARD") &&
+    (value.domain === "FRONTEND" || value.domain === "BACKEND" || value.domain === "GENERAL")
+  );
+}
+
+function buildClassificationPrompt(userPrompt: string): string {
+  return `You are the TaskPlanner for pi-pizza, a multi-provider coding-agent router.
+Classify the user's request.
+
+Difficulty:
+- EASY: simple reads, comments, renames, small boilerplate, basic CRUD, simple commands.
+- HARD: complex reasoning, large refactors, algorithms, deep type errors, delicate UI/CSS.
+
+Domain:
+- FRONTEND: React, HTML, CSS, visual layouts, styling, component design.
+- BACKEND: databases, servers, API logic, algorithms, TypeScript config, scripts.
+- GENERAL: git, questions, docs, and non-code tasks.
+
+Return strict JSON only:
+{"difficulty":"EASY"|"HARD","domain":"FRONTEND"|"BACKEND"|"GENERAL"}
+
+User request:
+${userPrompt}`;
+}

package/src/runtime.ts

@@ -0,0 +1,161 @@
+import {
+  createAssistantMessageEventStream,
+  type Api,
+  type AssistantMessage,
+  type AssistantMessageEventStream,
+  type Context,
+  type Model,
+  type SimpleStreamOptions,
+  streamSimple,
+} from "@earendil-works/pi-ai";
+import type { ProviderConfig } from "@earendil-works/pi-coding-agent";
+import { resolveConfig } from "./config.ts";
+import { PizzaRuntimeError } from "./errors.ts";
+import { selectModel } from "./router.ts";
+import type { ModelLookup, PizzaResolvedConfig } from "./types.ts";
+
+export class PizzaRuntime {
+  private modelLookup: ModelLookup | undefined;
+  private config: PizzaResolvedConfig | undefined;
+
+  bind(modelLookup: ModelLookup): void {
+    this.modelLookup = modelLookup;
+    this.config = resolveConfig(modelLookup);
+  }
+
+  createProviderConfig(): ProviderConfig {
+    return {
+			name: "Pizza",
+			baseUrl: "https://pizza.local",
+			apiKey: "pizza-router",
+      api: "pizza-router",
+      streamSimple: (_model, context, options) => this.route(context, options),
+      models: [
+        {
+          id: "auto",
+          name: "Pizza Auto Router",
+          api: "pizza-router",
+          reasoning: true,
+          input: ["text", "image"],
+          cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+          contextWindow: 1000000,
+          maxTokens: 64000,
+        },
+      ],
+    };
+  }
+
+  describe(): string {
+    return `pi-pizza is active. Config: ~/.pi/agent/pizza.json. Select pizza/auto to route turns automatically.`;
+  }
+
+  describeModels(): string {
+    const config = this.requireConfig();
+    return [
+      formatRole("plannerModel", config.plannerModel),
+      formatRole("readerModel", config.readerModel),
+      formatRole("builderEasyModel", config.builderEasyModel),
+      formatRole("builderHardBackendModel", config.builderHardBackendModel),
+      formatRole("builderHardFrontendModel", config.builderHardFrontendModel),
+      formatRole("executorModel", config.executorModel),
+    ].join("\n");
+  }
+
+  private route(context: Context, options?: SimpleStreamOptions): AssistantMessageEventStream {
+    const stream = createAssistantMessageEventStream();
+    void this.pipeRoutedStream(stream, context, options);
+    return stream;
+  }
+
+  private async pipeRoutedStream(
+    output: AssistantMessageEventStream,
+    context: Context,
+    options: SimpleStreamOptions | undefined,
+  ): Promise<void> {
+    try {
+			const modelLookup = this.requireModelLookup();
+			const config = this.requireConfig();
+			if (!hasConcreteModels(config)) {
+				throw new PizzaRuntimeError("No authenticated non-pizza models are available for routing.");
+			}
+			const routed = await selectModel(config, modelLookup, context);
+      process.stderr.write(`[pizza] 🍕 Routing to ${routed.label}: ${routed.model.provider}/${routed.model.id}\n`);
+
+      const auth = await modelLookup.getApiKeyAndHeaders(routed.model);
+      if (!auth.ok) {
+        throw new PizzaRuntimeError(auth.error);
+      }
+
+      const input = streamSimple(routed.model, context, mergeOptions(options, auth));
+      for await (const event of input) {
+        output.push(event);
+      }
+      output.end();
+    } catch (error) {
+      output.push({ type: "error", reason: "error", error: createErrorMessage(error) });
+      output.end();
+    }
+  }
+
+  private requireModelLookup(): ModelLookup {
+    if (!this.modelLookup) {
+      throw new PizzaRuntimeError("pi-pizza has not been bound to a pi session yet.");
+    }
+    return this.modelLookup;
+  }
+
+  private requireConfig(): PizzaResolvedConfig {
+    if (!this.config) {
+      throw new PizzaRuntimeError("pi-pizza config is not loaded yet.");
+    }
+    return this.config;
+  }
+}
+
+function mergeOptions(
+  options: SimpleStreamOptions | undefined,
+  auth: { readonly apiKey?: string; readonly headers?: Record<string, string> },
+): SimpleStreamOptions {
+  return {
+    ...options,
+    ...(auth.apiKey ? { apiKey: auth.apiKey } : {}),
+    ...(auth.headers ? { headers: { ...options?.headers, ...auth.headers } } : {}),
+  };
+}
+
+function formatRole(role: string, model: Model<Api>): string {
+	return `${role}: ${model.provider}/${model.id}`;
+}
+
+function hasConcreteModels(config: PizzaResolvedConfig): boolean {
+	return [
+		config.plannerModel,
+		config.readerModel,
+		config.builderEasyModel,
+		config.builderHardBackendModel,
+		config.builderHardFrontendModel,
+		config.executorModel,
+	].some((model) => model.provider !== "pizza");
+}
+
+function createErrorMessage(error: unknown): AssistantMessage {
+  const message = error instanceof Error ? error.message : String(error);
+  return {
+    role: "assistant",
+    content: [],
+    api: "pizza-router",
+    provider: "pizza",
+    model: "auto",
+    usage: {
+      input: 0,
+      output: 0,
+      cacheRead: 0,
+      cacheWrite: 0,
+      totalTokens: 0,
+      cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+    },
+    stopReason: "error",
+    errorMessage: message,
+    timestamp: Date.now(),
+  };
+}

package/src/settings.ts

@@ -0,0 +1,38 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+
+const PIZZA_PROVIDER = "pizza";
+const PIZZA_MODEL = "auto";
+
+export function hasExplicitModelSelection(argv: readonly string[] = process.argv): boolean {
+  return argv.includes("--model") || argv.includes("--provider");
+}
+
+export function ensurePizzaDefaultSettings(): boolean {
+  const settingsPath = join(homedir(), ".pi", "agent", "settings.json");
+  const current = readSettings(settingsPath);
+  if (current["defaultProvider"] === PIZZA_PROVIDER && current["defaultModel"] === PIZZA_MODEL) {
+    return false;
+  }
+
+  const next = {
+    ...current,
+    defaultProvider: PIZZA_PROVIDER,
+    defaultModel: PIZZA_MODEL,
+  };
+  mkdirSync(dirname(settingsPath), { recursive: true });
+  writeFileSync(settingsPath, `${JSON.stringify(next, null, 2)}\n`, "utf8");
+  return true;
+}
+
+function readSettings(settingsPath: string): Record<string, unknown> {
+  if (!existsSync(settingsPath)) {
+    return {};
+  }
+  const parsed: unknown = JSON.parse(readFileSync(settingsPath, "utf8"));
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return {};
+  }
+  return Object.fromEntries(Object.entries(parsed));
+}

package/src/types.ts

@@ -0,0 +1,44 @@
+import type { Api, Model } from "@earendil-works/pi-ai";
+
+export type PizzaRole =
+  | "plannerModel"
+  | "readerModel"
+  | "builderEasyModel"
+  | "builderHardBackendModel"
+  | "builderHardFrontendModel"
+  | "executorModel";
+
+export interface PizzaConfigFile {
+  readonly plannerModel: string;
+  readonly readerModel: string;
+  readonly builderEasyModel: string;
+  readonly builderHardBackendModel: string;
+  readonly builderHardFrontendModel: string;
+  readonly executorModel: string;
+}
+
+export interface PizzaResolvedConfig {
+  readonly plannerModel: Model<Api>;
+  readonly readerModel: Model<Api>;
+  readonly builderEasyModel: Model<Api>;
+  readonly builderHardBackendModel: Model<Api>;
+  readonly builderHardFrontendModel: Model<Api>;
+  readonly executorModel: Model<Api>;
+}
+
+export type PizzaDifficulty = "EASY" | "HARD";
+export type PizzaDomain = "FRONTEND" | "BACKEND" | "GENERAL";
+
+export interface PizzaDecision {
+  readonly difficulty: PizzaDifficulty;
+  readonly domain: PizzaDomain;
+}
+
+export interface ModelLookup {
+  getAvailable(): Model<Api>[];
+  find(provider: string, modelId: string): Model<Api> | undefined;
+  getApiKeyAndHeaders(model: Model<Api>): Promise<
+    | { readonly ok: true; readonly apiKey?: string; readonly headers?: Record<string, string> }
+    | { readonly ok: false; readonly error: string }
+  >;
+}

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": ["ES2022", "DOM"],
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": true,
+    "noImplicitOverride": true,
+    "noPropertyAccessFromIndexSignature": true,
+    "noFallthroughCasesInSwitch": true,
+    "verbatimModuleSyntax": true,
+    "skipLibCheck": true,
+    "allowImportingTsExtensions": true,
+    "noEmit": true
+  },
+  "include": ["extensions/**/*.ts", "src/**/*.ts"]
+}