@zgltyq/pi-provider-claude 1.0.0

package/LICENSE

@@ -0,0 +1,23 @@
+MIT License
+
+Copyright (c) 2026 Leechael
+
+Based on @benvargas/pi-claude-code-use (MIT License, Copyright (c) Ben Vargas).
+
+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,92 @@
+# @zgltyq/pi-provider-claude
+
+Claude (Anthropic **OAuth / subscription**) compatibility layer for
+[pi-coding-agent](https://pi.dev). Keeps **all** your extension tools usable
+under the Claude subscription.
+
+It is a self-contained fork of the tool-handling half of
+[`@benvargas/pi-claude-code-use`](https://www.npmjs.com/package/@benvargas/pi-claude-code-use)
+(MIT) — credit to Ben Vargas for the original approach.
+
+## Problem
+
+Anthropic's OAuth (subscription) request path appears to fingerprint tool names.
+Tools that are **not** part of the Claude Code core set and are **not** prefixed
+`mcp__` can be classified as *extra usage*. The upstream extension defends against
+this by **dropping every unknown flat-named tool** before the request is sent —
+which silently hides legitimate extension tools from Claude:
+
+`ask_user_question`, `todo`, `subagent`, `ast_grep_search`, `lsp_diagnostics`,
+`ctx_*`, `web_search`, `ralph_*`, `preview_export`, … all disappear, even though
+they work fine for non-Anthropic models.
+
+## What this does
+
+Instead of dropping unknown flat tools, it **renames them in place on the wire**
+to `mcp__pi__<name>`:
+
+- ✅ `mcp__*` shape passes Anthropic's classifier → **no extra-usage charge**
+- ✅ the tool stays **visible to Claude** → it can actually call it
+- ✅ on the way back, calls to `mcp__pi__*` are rewritten to the original flat
+  name **before Pi executes them**, so the real tool (and its closure-bound
+  state) runs unchanged
+
+Untouched: native Anthropic tools (objects with a `type` field, e.g.
+`web_search`), anything already `mcp__`-prefixed, and the Claude Code core tools.
+The extension only activates for **Anthropic + OAuth** — API-key auth and
+non-Anthropic providers pass through completely unchanged.
+
+It also applies the upstream system-prompt rewrite (`pi itself` → `the cli
+itself`, etc.) on the OAuth path.
+
+## Why it's lightweight
+
+The tool's full JSON schema already rides inside the outbound payload, so the fix
+is a pure rename — **no jiti capture, no tool re-registration, no typebox**. The
+only import is a TypeScript type (erased at runtime), so the extension has **zero
+runtime dependencies**.
+
+## Install
+
+```bash
+pi install npm:@zgltyq/pi-provider-claude
+```
+
+Then remove the upstream one so they don't both transform the payload:
+
+```bash
+pi remove npm:@benvargas/pi-claude-code-use
+```
+
+Restart Pi (or `/reload`) and continue using the normal `anthropic` provider with
+your OAuth login.
+
+## Verify
+
+```bash
+PI_CLAUDE_PROVIDER_DEBUG_LOG=/tmp/claude-provider.log pi
+# send one message, then quit
+```
+
+In `/tmp/claude-provider.log`, the `"after"` payload's `tools[]` should show your
+extension tools as `mcp__pi__<name>` and **nothing dropped**.
+
+## Environment variables
+
+| Variable | Effect |
+|---|---|
+| `PI_CLAUDE_PROVIDER_DEBUG_LOG=/path` | Append `before`/`after` payloads for debugging. |
+| `PI_CLAUDE_PROVIDER_DISABLE=1` | Pass all tools through with flat names (no renaming). Debug escape hatch. |
+
+## How it differs from `@benvargas/pi-claude-code-use`
+
+| | upstream | this fork |
+|---|---|---|
+| Unknown flat tools | **dropped** | **renamed** `mcp__pi__<name>` (kept) |
+| Alias scheme | per-tool config + jiti capture + re-registration | generic in-place rename (deterministic prefix) |
+| Runtime deps | `@mariozechner/jiti` | none |
+| Scope | tool filtering + companion aliases + system-prompt rewrite | tool renaming + system-prompt rewrite |
+
+## License
+
+MIT. Based on `@benvargas/pi-claude-code-use` (MIT).

package/index.ts

@@ -0,0 +1,283 @@
+/**
+ * @zgltyq/pi-provider-claude
+ * ────────────────────────────────────────────────────────────────────────────
+ * Claude (Anthropic OAuth / subscription) compatibility layer for pi-coding-agent.
+ * Self-contained fork of the tool-handling half of `@benvargas/pi-claude-code-use`
+ * (MIT). Credit to Ben Vargas for the original approach.
+ *
+ * WHY THIS EXISTS
+ *   Anthropic's OAuth (subscription) request path appears to fingerprint tool
+ *   names: tools that are neither part of the Claude Code core set nor prefixed
+ *   `mcp__` can be classified as "extra usage". The upstream extension defends
+ *   against this by DROPPING every unknown flat-named tool — which silently
+ *   hides legitimate extension tools (ask_user_question, todo, subagent,
+ *   ast_grep_search, ctx_*, web_search, …) from Claude.
+ *
+ * WHAT THIS DOES DIFFERENTLY (the "map all my tools" fix)
+ *   Instead of dropping unknown flat tools, it RENAMES them in place on the
+ *   wire to `mcp__pi__<name>` so they pass the classifier (subscription-safe)
+ *   AND remain visible to Claude. On the way back, tool calls to `mcp__pi__*`
+ *   are rewritten to their original flat name before Pi executes them, so the
+ *   real tool (and its closure-bound state) runs unchanged.
+ *
+ * DESIGN NOTES
+ *   - The tool's full JSON schema already rides inside the outbound payload,
+ *     so we just rename — NO jiti capture, NO tool re-registration, NO typebox.
+ *     The only import is a TYPE (erased at runtime), so this extension has zero
+ *     runtime dependencies and minimal chance of a load failure.
+ *   - Native Anthropic tools (objects with a `type` field, e.g. web_search) and
+ *     anything already `mcp__`-prefixed are passed through untouched. Core
+ *     Claude Code tools are passed through untouched.
+ *   - Only ACTIVATES for Anthropic + OAuth. API-key and non-Anthropic providers
+ *     are left completely unchanged.
+ *
+ * ENV (optional)
+ *   PI_CLAUDE_PROVIDER_DEBUG_LOG=/path  → append before/after payloads
+ *   PI_CLAUDE_PROVIDER_DISABLE=1        → pass everything through flat (debug)
+ */
+
+import { appendFileSync } from "node:fs";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+// Prefix used to disguise flat tools as MCP tools. Kept short so
+// `mcp__pi__<name>` stays well under Anthropic's 64-char tool-name limit.
+const ALIAS_PREFIX = "mcp__pi__";
+
+// Core Claude Code tool names that always pass through (lowercased).
+// Mirrors Pi core's `claudeCodeTools` in packages/ai/src/providers/anthropic.ts.
+const CORE_TOOL_NAMES = new Set([
+	"read",
+	"write",
+	"edit",
+	"bash",
+	"grep",
+	"glob",
+	"askuserquestion",
+	"enterplanmode",
+	"exitplanmode",
+	"killshell",
+	"notebookedit",
+	"skill",
+	"task",
+	"taskoutput",
+	"todowrite",
+	"webfetch",
+	"websearch",
+]);
+
+const lower = (s: string): string => s.toLowerCase();
+const isPlainObject = (v: unknown): v is Record<string, unknown> =>
+	typeof v === "object" && v !== null && !Array.isArray(v);
+
+// ─── System prompt rewrite (parity with upstream) ────────────────────────────
+// Keep Pi's identity out of the system prompt on the OAuth path.
+function rewritePromptText(text: string): string {
+	return text
+		.replaceAll("pi itself", "the cli itself")
+		.replaceAll("pi .md files", "cli .md files")
+		.replaceAll("pi packages", "cli packages");
+}
+
+function rewriteSystemField(system: unknown): unknown {
+	if (typeof system === "string") return rewritePromptText(system);
+	if (!Array.isArray(system)) return system;
+	return system.map((block) => {
+		if (
+			!isPlainObject(block) ||
+			block.type !== "text" ||
+			typeof block.text !== "string"
+		)
+			return block;
+		const rewritten = rewritePromptText(block.text);
+		return rewritten === block.text ? block : { ...block, text: rewritten };
+	});
+}
+
+// True for tools that must NOT be renamed: native typed tools, core tools,
+// already-mcp__ tools, or nameless entries.
+function shouldRename(tool: Record<string, unknown>): boolean {
+	if (typeof tool.type === "string" && tool.type.trim().length > 0)
+		return false; // native (web_search, …)
+	const name = typeof tool.name === "string" ? tool.name : "";
+	if (!name) return false;
+	const lc = lower(name);
+	if (CORE_TOOL_NAMES.has(lc)) return false;
+	if (lc.startsWith("mcp__")) return false;
+	return true;
+}
+
+// Transform tools[]; returns the surviving tools plus the flat→alias map of
+// exactly what was renamed (so tool_choice / message history stay consistent).
+function transformTools(tools: unknown[]): {
+	tools: unknown[];
+	renamed: Map<string, string>;
+} {
+	const renamed = new Map<string, string>(); // lower(flat) → alias
+	const emitted = new Set<string>();
+	const result: unknown[] = [];
+
+	for (const tool of tools) {
+		if (!isPlainObject(tool)) continue;
+
+		if (!shouldRename(tool)) {
+			const key =
+				typeof tool.name === "string"
+					? lower(tool.name)
+					: `__native_${result.length}`;
+			if (emitted.has(key)) continue;
+			emitted.add(key);
+			result.push(tool);
+			continue;
+		}
+
+		const name = tool.name as string;
+		const alias = ALIAS_PREFIX + name;
+		renamed.set(lower(name), alias);
+		if (emitted.has(lower(alias))) continue;
+		emitted.add(lower(alias));
+		result.push({ ...tool, name: alias }); // preserves schema + cache_control
+	}
+
+	return { tools: result, renamed };
+}
+
+// Rewrite tool_use block names in message history to match the renamed tools.
+function remapMessages(
+	messages: unknown[],
+	renamed: Map<string, string>,
+): unknown[] {
+	if (renamed.size === 0) return messages;
+	let changed = false;
+	const next = messages.map((msg) => {
+		if (!isPlainObject(msg) || !Array.isArray(msg.content)) return msg;
+		let blockChanged = false;
+		const content = msg.content.map((block) => {
+			if (
+				!isPlainObject(block) ||
+				block.type !== "tool_use" ||
+				typeof block.name !== "string"
+			)
+				return block;
+			const alias = renamed.get(lower(block.name));
+			if (!alias || alias === block.name) return block;
+			blockChanged = true;
+			return { ...block, name: alias };
+		});
+		if (!blockChanged) return msg;
+		changed = true;
+		return { ...msg, content };
+	});
+	return changed ? next : messages;
+}
+
+function remapToolChoice(
+	toolChoice: Record<string, unknown>,
+	renamed: Map<string, string>,
+): Record<string, unknown> {
+	if (toolChoice.type !== "tool" || typeof toolChoice.name !== "string")
+		return toolChoice;
+	const alias = renamed.get(lower(toolChoice.name));
+	return alias ? { ...toolChoice, name: alias } : toolChoice;
+}
+
+function transformPayload(
+	raw: Record<string, unknown>,
+	disable: boolean,
+): Record<string, unknown> {
+	const payload = JSON.parse(JSON.stringify(raw)) as Record<string, unknown>;
+
+	// 1. System prompt rewrite always applies.
+	if (payload.system !== undefined)
+		payload.system = rewriteSystemField(payload.system);
+
+	if (disable) return payload;
+
+	// 2. Rename unknown flat tools → mcp__pi__<name>.
+	if (Array.isArray(payload.tools)) {
+		const { tools, renamed } = transformTools(payload.tools as unknown[]);
+		payload.tools = tools;
+
+		// 3. Keep tool_choice consistent.
+		if (isPlainObject(payload.tool_choice)) {
+			payload.tool_choice = remapToolChoice(payload.tool_choice, renamed);
+		}
+
+		// 4. Keep historical tool_use names consistent with the renamed tools.
+		if (Array.isArray(payload.messages)) {
+			payload.messages = remapMessages(payload.messages, renamed);
+		}
+	}
+
+	return payload;
+}
+
+// ─── Reverse mapping on execution ────────────────────────────────────────────
+// Rewrite mcp__pi__<name> tool calls back to <name> in the finalized assistant
+// message, BEFORE Pi resolves which tool to run. Only touches our own prefix,
+// so foreign mcp__ tools (other extensions) are untouched.
+function unaliasToolCalls(message: unknown): unknown {
+	if (
+		!isPlainObject(message) ||
+		message.role !== "assistant" ||
+		!Array.isArray(message.content)
+	)
+		return undefined;
+	let changed = false;
+	const content = message.content.map((block) => {
+		if (
+			!isPlainObject(block) ||
+			block.type !== "toolCall" ||
+			typeof block.name !== "string"
+		)
+			return block;
+		if (!block.name.startsWith(ALIAS_PREFIX)) return block;
+		changed = true;
+		return { ...block, name: block.name.slice(ALIAS_PREFIX.length) };
+	});
+	return changed ? { ...message, content } : undefined;
+}
+
+// ─── Debug logging (optional) ─────────────────────────────────────────────────
+const debugLogPath = process.env.PI_CLAUDE_PROVIDER_DEBUG_LOG;
+function writeDebugLog(payload: unknown): void {
+	if (!debugLogPath) return;
+	try {
+		appendFileSync(
+			debugLogPath,
+			`${new Date().toISOString()}\n${JSON.stringify(payload, null, 2)}\n---\n`,
+			"utf-8",
+		);
+	} catch {
+		/* logging must never break a request */
+	}
+}
+
+export default function piProviderClaude(pi: ExtensionAPI): void {
+	// mcp__pi__* → flat, before the agent loop resolves the tool.
+	pi.on("message_end", async (event, _ctx) => {
+		const rewritten = unaliasToolCalls(event.message);
+		if (!rewritten) return undefined;
+		return { message: rewritten as typeof event.message };
+	});
+
+	pi.on("before_provider_request", (event, ctx) => {
+		const model = ctx.model;
+		if (
+			!model ||
+			model.provider !== "anthropic" ||
+			!ctx.modelRegistry.isUsingOAuth(model)
+		) {
+			return undefined; // only Anthropic OAuth
+		}
+		if (!isPlainObject(event.payload)) return undefined;
+
+		writeDebugLog({ stage: "before", payload: event.payload });
+		const disable = process.env.PI_CLAUDE_PROVIDER_DISABLE === "1";
+		const transformed = transformPayload(
+			event.payload as Record<string, unknown>,
+			disable,
+		);
+		writeDebugLog({ stage: "after", payload: transformed });
+		return transformed;
+	});
+}

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@zgltyq/pi-provider-claude",
+  "version": "1.0.0",
+  "description": "Claude (Anthropic OAuth/subscription) compatibility layer for pi-coding-agent — keeps ALL extension tools usable under the Claude subscription by mapping unknown flat tool names to mcp__pi__<name> on the wire instead of dropping them. Self-contained fork of the tool half of @benvargas/pi-claude-code-use.",
+  "author": "Leechael",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ZGltYQ/pi-provider-claude"
+  },
+  "homepage": "https://github.com/ZGltYQ/pi-provider-claude#readme",
+  "bugs": {
+    "url": "https://github.com/ZGltYQ/pi-provider-claude/issues"
+  },
+  "keywords": [
+    "pi-package",
+    "pi-extension",
+    "pi-provider",
+    "pi",
+    "pi-coding-agent",
+    "pi-mono",
+    "coding-agent",
+    "anthropic",
+    "claude",
+    "claude-code",
+    "oauth",
+    "subscription",
+    "tools",
+    "fork"
+  ],
+  "type": "module",
+  "files": [
+    "index.ts",
+    "package.json",
+    "README.md",
+    "LICENSE"
+  ],
+  "pi": {
+    "extensions": [
+      "./index.ts"
+    ]
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": ">=0.74.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}