@huseynsnmz/pi-suite 0.2.2 → 0.2.3

package/packages/subscription/src/mcp.ts

@@ -0,0 +1,78 @@
+// The little of MCP that Claude Code needs to see pi's tools: the Agent SDK hands this object a
+// transport and passes JSON-RPC through it. The MCP SDK would bring a web server and more to do this.
+import type { Tool } from "@earendil-works/pi-ai";
+
+export interface ToolResult {
+	content: unknown[];
+	isError?: boolean;
+}
+
+interface Transport {
+	onmessage?: (message: JsonRpc) => void;
+	start(): Promise<void>;
+	send(message: unknown): Promise<void>;
+	close(): Promise<void>;
+}
+
+interface JsonRpc {
+	id?: string | number;
+	method?: string;
+	params?: { protocolVersion?: string; _meta?: Record<string, unknown> };
+}
+
+const METHOD_NOT_FOUND = -32601;
+const INTERNAL_ERROR = -32603;
+
+export class ToolServer {
+	readonly #tools: unknown[];
+	readonly #call: (toolUseId: string | undefined) => Promise<ToolResult>;
+	#transport: Transport | undefined;
+
+	constructor(name: string, tools: readonly Tool[], call: (toolUseId: string | undefined) => Promise<ToolResult>) {
+		this.name = name;
+		this.#call = call;
+		this.#tools = tools.map((tool) => ({
+			name: tool.name,
+			description: tool.description,
+			inputSchema: { type: "object", ...(JSON.parse(JSON.stringify(tool.parameters ?? {})) as object) },
+		}));
+	}
+
+	readonly name: string;
+
+	async connect(transport: Transport): Promise<void> {
+		this.#transport = transport;
+		transport.onmessage = (message) => void this.#handle(message);
+		await transport.start();
+	}
+
+	async close(): Promise<void> {
+		await this.#transport?.close();
+	}
+
+	async #handle(message: JsonRpc): Promise<void> {
+		// A notification has no id and wants no answer.
+		if (message.id === undefined) return;
+		const answer = await this.#answer(message);
+		await this.#transport?.send({ jsonrpc: "2.0", id: message.id, ...answer }).catch(() => undefined);
+	}
+
+	async #answer(message: JsonRpc): Promise<{ result: unknown } | { error: { code: number; message: string } }> {
+		switch (message.method) {
+			case "initialize":
+				return { result: { protocolVersion: message.params?.protocolVersion, capabilities: { tools: {} }, serverInfo: { name: this.name, version: "1.0.0" } } };
+			case "ping":
+				return { result: {} };
+			case "tools/list":
+				return { result: { tools: this.#tools } };
+			case "tools/call":
+				try {
+					return { result: await this.#call(message.params?._meta?.["claudecode/toolUseId"] as string | undefined) };
+				} catch (error) {
+					return { error: { code: INTERNAL_ERROR, message: (error as Error).message } };
+				}
+			default:
+				return { error: { code: METHOD_NOT_FOUND, message: `Unknown method ${message.method}` } };
+		}
+	}
+}

package/packages/subscription/src/models.ts

@@ -0,0 +1,65 @@
+import type { Api, Model } from "@earendil-works/pi-ai";
+import type { ProviderModelConfig } from "@earendil-works/pi-coding-agent";
+import { CATALOG } from "./catalog.ts";
+
+type ProviderChatModelConfig = Extract<ProviderModelConfig, { reasoning: boolean }>;
+type CatalogModel = Pick<Model<Api>, "id" | "name" | "reasoning" | "input" | "cost" | "contextWindow" | "maxTokens" | "thinkingLevelMap">;
+
+/**
+ * Chat models offered through Claude Code. Limits, prices and thinking levels come from pi's
+ * Anthropic catalog: a snapshot at load (so `--model` works at startup), refreshed from pi's live
+ * registry once a session starts (see index.ts). Dated aliases are skipped; Claude Code resolves
+ * the undated ids itself.
+ */
+export function claudeModels(source: readonly CatalogModel[] = CATALOG as unknown as CatalogModel[]): ProviderChatModelConfig[] {
+	return source
+		.filter((m) => !/-\d{8}$/.test(m.id))
+		.map((m) => ({
+			id: m.id,
+			name: `${m.name} (Claude subscription)`,
+			reasoning: m.reasoning,
+			input: m.input,
+			cost: m.cost,
+			contextWindow: m.contextWindow,
+			maxTokens: m.maxTokens,
+			...(m.thinkingLevelMap ? { thinkingLevelMap: m.thinkingLevelMap } : {}),
+			// No promptCache: Claude Code already writes one-hour cache entries, and pi's cache
+			// warmer (a one-token replay of an earlier request) cannot be expressed through it.
+		}));
+}
+
+/** pi's Anthropic models that can back this provider. */
+export function anthropicChatModels(models: readonly (CatalogModel & { provider: string; type?: string })[]): CatalogModel[] {
+	return models.filter((m) => m.provider === "anthropic" && (m.type === undefined || m.type === "chat"));
+}
+
+export type ThinkingOption = { type: "adaptive"; display: "summarized" } | { type: "disabled" } | { type: "enabled"; budgetTokens: number; display: "summarized" };
+
+const EFFORTS = new Set(["low", "medium", "high", "xhigh", "max"]);
+
+/**
+ * Map a pi thinking level to Agent SDK thinking options. pi resolves the level through the
+ * model's thinkingLevelMap before it reaches the provider, so the value is already the
+ * provider-native effort when the model declares one.
+ */
+export function thinkingOptions(
+	level: string | undefined,
+	hasLevelMap: boolean,
+): { thinking: ThinkingOption; effort?: "low" | "medium" | "high" | "xhigh" | "max" } {
+	if (!level || level === "off") return { thinking: { type: "disabled" } };
+	if (hasLevelMap) {
+		const effort = EFFORTS.has(level) ? (level as any) : level === "minimal" ? "low" : "medium";
+		return { thinking: { type: "adaptive", display: "summarized" }, effort };
+	}
+	// Budget-based models (e.g. Haiku 4.5).
+	const budgets: Record<string, number> = { minimal: 1024, low: 2048, medium: 8192, high: 16384, xhigh: 32000, max: 48000 };
+	return { thinking: { type: "enabled", budgetTokens: budgets[level] ?? 8192, display: "summarized" } };
+}
+
+/** A budget counts toward the output cap, so the cap grows to fit it, as in pi's Anthropic provider, up to what the model allows. */
+export function fitThinking(thinking: ThinkingOption, maxTokens: number, modelMax: number): { thinking: ThinkingOption; maxOutputTokens: number } {
+	if (thinking.type !== "enabled") return { thinking, maxOutputTokens: maxTokens };
+	const maxOutputTokens = Math.min(maxTokens + thinking.budgetTokens, modelMax);
+	const budgetTokens = maxOutputTokens > thinking.budgetTokens ? thinking.budgetTokens : Math.max(1024, maxOutputTokens - 1024);
+	return { thinking: { ...thinking, budgetTokens }, maxOutputTokens };
+}

package/packages/subscription/src/prompt.ts

@@ -0,0 +1,57 @@
+import type { BeforeAgentStartEvent } from "@earendil-works/pi-coding-agent";
+
+export type PromptMode = "claude" | "pi";
+type PromptOptions = BeforeAgentStartEvent["systemPromptOptions"];
+export interface DocPaths {
+	readme: string;
+	docs: string;
+	examples: string;
+}
+
+/**
+ * pi's prompt prefix rewritten for Claude. pi drops its own tools, rules and docs sections when a
+ * custom prefix is set, so this renders them itself: every selected tool and every guideline pi or
+ * another extension contributed. Context files, skills and the working directory stay pi's.
+ */
+export function claudePreamble(o: PromptOptions, docs: DocPaths): string {
+	const tools = o.selectedTools.filter((name) => o.toolSnippets[name]).map((name) => `- ${name}: ${o.toolSnippets[name]}`);
+	const guidelines = new Set<string>();
+	const searchTools = ["grep", "find", "ls"].some((t) => o.selectedTools.includes(t));
+	if (o.selectedTools.includes("bash") && !searchTools) guidelines.add("Use bash for file discovery and search (ls, rg, find).");
+	for (const name of o.selectedTools) for (const g of o.toolGuidelines[name] ?? []) guidelines.add(g.trim());
+	for (const g of o.promptGuidelines) guidelines.add(g.trim());
+	guidelines.delete("");
+
+	return `You are Claude, working as a coding agent in pi, a terminal coding harness. You help the user by reading files, running commands, and editing code in their project.
+
+Tools:
+${tools.length > 0 ? tools.join("\n") : "(none)"}
+Other tools may be available; their definitions describe them.
+
+How to work:
+- Understand before you change: read the relevant code and search the project before editing. Don't guess file contents or APIs.
+- Make independent tool calls in parallel, such as reading several files at once. Sequence only calls that depend on each other.
+- Change existing files with targeted edits rather than rewrites. Create files only when the task needs them.
+- Stay within the request: no unrequested features, refactors, or comments.
+- Verify: run the project's tests, type checker, or the program itself when they exist, and fix what fails. If you can't verify, say so.
+- Report faithfully: never claim that something passed, ran, or exists unless you saw it.
+- If the request is ambiguous in a way that changes the result, ask. Otherwise state your assumption and proceed.
+- Be concise. Lead with the outcome and show file paths clearly.${guidelines.size > 0 ? `\n\nGuidelines:\n${[...guidelines].map((g) => `- ${g}`).join("\n")}` : ""}
+
+Questions about pi itself (extensions, skills, settings, its SDK): read ${docs.readme}, the docs in ${docs.docs} and the examples in ${docs.examples} first.`;
+}
+
+/**
+ * before_agent_start: give Claude models the Claude prefix. A user's own SYSTEM.md (customPrompt)
+ * always wins, and other providers keep pi's default prompt.
+ */
+export function applyClaudePrompt(
+	event: { systemPromptOptions: PromptOptions },
+	model: { provider: string } | undefined,
+	mode: PromptMode,
+	docs: DocPaths = { readme: "README.md", docs: "docs", examples: "examples" },
+): void {
+	if (mode !== "claude" || model?.provider !== "claude-sdk") return;
+	if (event.systemPromptOptions.customPrompt) return;
+	event.systemPromptOptions.customPrompt = claudePreamble(event.systemPromptOptions, docs);
+}