cozyclay 3.1.2 → 3.1.4

package/bin/agent/agent-stream.mjs

@@ -0,0 +1,86 @@
+// The provider call behind every model request of the agent runner (agent-runner.mjs). pi-agent-core 1.x's Agent does
+// not retry a failed request (the removed AgentHarness did), so one request is retried here, in place:
+//   - a transient failure, by pi-ai's own isRetryableAssistantError (429, 5xx, overload, dropped connections), up to
+//     RETRY_POLICY.maxRetries times with pi-ai's backoff;
+//   - an expired Codex sign-in (401), once per turn, after a forced credential refresh (refreshAuth, the runner's).
+// An attempt is retried only while nothing of it reached the Agent: its events are held until its first content event,
+// so the transcript and the panel only ever see the attempt that answered. A retried request carries the same context,
+// so no failed assistant message is stored and no completed tool runs again.
+
+const RETRY_POLICY = Object.freeze({ maxRetries: 2, baseDelayMs: 1000 });
+
+const CONTENT_EVENT = /^(text|thinking|toolcall)_/;
+const EMPTY_USAGE = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } };
+
+/** Resolves after `ms`, or as soon as `signal` aborts. */
+function pause(ms, signal) {
+	return new Promise((resolve) => {
+		if (signal?.aborted) { resolve(); return; }
+		const timer = setTimeout(done, ms);
+		function done() { clearTimeout(timer); signal?.removeEventListener("abort", done); resolve(); }
+		signal?.addEventListener("abort", done, { once: true });
+	});
+}
+
+/** An assistant message for a request that never produced one (pi-ai throws when a request has no credential). */
+function failedMessage(model, error, signal) {
+	return {
+		role: "assistant", content: [], api: model.api, provider: model.provider, model: model.id, usage: EMPTY_USAGE,
+		stopReason: signal?.aborted ? "aborted" : "error",
+		errorMessage: error instanceof Error ? error.message : String(error),
+		timestamp: Date.now(),
+	};
+}
+
+/**
+ * The Agent's streamFn. `ai` is @earendil-works/pi-ai, `models` the registry the request runs on. `refreshAuth(model,
+ * message)` decides whether a failed attempt earns a credential refresh and one more try (it refreshes before answering
+ * true); `onAttempt(message)` sees every attempt's final message, failed ones included.
+ */
+export function createRetryingStream({ ai, models, refreshAuth = async () => false, onAttempt = () => {} }) {
+	return (model, context, options = {}) => {
+		const { signal } = options;
+		const out = ai.createAssistantMessageEventStream();
+		const shouldRetry = async (message, retries) => {
+			if (retries >= RETRY_POLICY.maxRetries || signal?.aborted) return false;
+			if (ai.isRetryableAssistantError(message)) {
+				await pause(ai.retryDelayMs(RETRY_POLICY, retries + 1), signal);
+				return !signal?.aborted;
+			}
+			return refreshAuth(model, message);
+		};
+		const finish = (message, held = []) => {
+			for (const early of held) out.push(early);
+			const failed = message.stopReason === "error" || message.stopReason === "aborted";
+			out.push(failed ? { type: "error", reason: message.stopReason, error: message } : { type: "done", reason: message.stopReason, message });
+			out.end();
+		};
+		void (async () => {
+			for (let retries = 0; ; retries += 1) {
+				// The Agent asks for the next request even after a cancelled tool: an aborted run makes no further model call.
+				if (signal?.aborted) { finish(failedMessage(model, new Error("Request was aborted"), signal)); return; }
+				const held = [];
+				let forwarding = false;
+				let message;
+				try {
+					const response = await models.streamSimple(model, context, options);
+					for await (const event of response) {
+						if (event.type === "done" || event.type === "error") break;
+						if (forwarding) { out.push(event); continue; }
+						held.push(event);
+						if (CONTENT_EVENT.test(event.type)) { forwarding = true; for (const early of held.splice(0)) out.push(early); }
+					}
+					message = await response.result();
+				} catch (error) {
+					message = failedMessage(model, error, signal);
+				}
+				onAttempt(message);
+				if (!forwarding && message.stopReason === "error" && await shouldRetry(message, retries)) continue;
+				// An abort that landed during a backoff ends the request as aborted, like any other cancellation.
+				finish(message.stopReason === "error" && signal?.aborted ? { ...message, stopReason: "aborted" } : message, held);
+				return;
+			}
+		})();
+		return out;
+	};
+}

package/bin/agent/anthropic-subscription-events.mjs

@@ -0,0 +1,120 @@
+// SDK stream-event → pi assistant-message event translation for the subscription lane, plus the
+// output message scaffolding. The lane receives Anthropic's raw SSE protocol re-exported by the
+// SDK (`stream_event` messages), so this mirrors what pi-ai's anthropic-messages api does with
+// the same events.
+
+/** The SDK names host tools mcp__cozyclay-tools__<name>; pi knows them by the bare name. */
+const CUSTOM_TOOLS_MCP_PREFIX = "mcp__cozyclay-tools__";
+
+const asRecord = (value) => (value !== null && typeof value === "object" && !Array.isArray(value) ? value : {});
+
+export function mapStopReason(reason) {
+	if (reason === "tool_use") return "toolUse";
+	if (reason === "max_tokens") return "length";
+	return "stop";
+}
+
+function mapSdkToolNameToPi(name) {
+	return typeof name === "string" && name.startsWith(CUSTOM_TOOLS_MCP_PREFIX) ? name.slice(CUSTOM_TOOLS_MCP_PREFIX.length) : name;
+}
+export function updateUsage(model, output, usage, { reset = false } = {}) {
+	if (!usage) return;
+	if (reset) {
+		output.usage.input = 0;
+		output.usage.output = 0;
+		output.usage.cacheRead = 0;
+		output.usage.cacheWrite = 0;
+	}
+	if (usage.input_tokens != null) output.usage.input = usage.input_tokens;
+	if (usage.output_tokens != null) output.usage.output = usage.output_tokens;
+	if (usage.cache_read_input_tokens != null) output.usage.cacheRead = usage.cache_read_input_tokens;
+	if (usage.cache_creation_input_tokens != null) output.usage.cacheWrite = usage.cache_creation_input_tokens;
+	output.usage.totalTokens = output.usage.input + output.usage.output + output.usage.cacheRead + output.usage.cacheWrite;
+}
+
+/** SDK raw stream_event (the Anthropic SSE protocol, re-exported) → pi assistant-message events. */
+export function applyStreamEvent(state, event, parseStreamingJson) {
+	const { output, blocks, stream } = state;
+	const openBlock = (block, kind) => {
+		blocks.push(block);
+		output.content.push(block);
+		stream.push({ type: `${kind}_start`, contentIndex: output.content.length - 1, partial: output });
+	};
+	if (event.type === "message_start") {
+		output.responseId ??= event.message?.id || undefined;
+		updateUsage(state.model, output, event.message?.usage, { reset: true });
+		return;
+	}
+	if (event.type === "content_block_start") {
+		const block = event.content_block;
+		if (block?.type === "text") openBlock({ type: "text", text: "", index: event.index }, "text");
+		else if (block?.type === "thinking") openBlock({ type: "thinking", thinking: "", thinkingSignature: "", index: event.index }, "thinking");
+		else if (block?.type === "tool_use") {
+			openBlock({
+				type: "toolCall",
+				id: block.id,
+				name: mapSdkToolNameToPi(block.name),
+				arguments: asRecord(block.input),
+				partialJson: "",
+				index: event.index,
+			}, "toolcall");
+		}
+		return;
+	}
+	if (event.type === "content_block_delta") {
+		const contentIndex = blocks.findIndex((candidate) => candidate.index === event.index);
+		const block = blocks[contentIndex];
+		const delta = event.delta;
+		if (delta?.type === "text_delta" && block?.type === "text") {
+			block.text += delta.text;
+			stream.push({ type: "text_delta", contentIndex, delta: delta.text, partial: output });
+		} else if (delta?.type === "thinking_delta" && block?.type === "thinking") {
+			block.thinking += delta.thinking;
+			stream.push({ type: "thinking_delta", contentIndex, delta: delta.thinking, partial: output });
+		} else if (delta?.type === "signature_delta" && block?.type === "thinking") {
+			block.thinkingSignature += delta.signature;
+		} else if (delta?.type === "input_json_delta" && block?.type === "toolCall") {
+			block.partialJson = `${block.partialJson ?? ""}${delta.partial_json}`;
+			block.arguments = parseStreamingJson(block.partialJson);
+			stream.push({ type: "toolcall_delta", contentIndex, delta: delta.partial_json, partial: output });
+		}
+		return;
+	}
+	if (event.type === "content_block_stop") {
+		const contentIndex = blocks.findIndex((candidate) => candidate.index === event.index);
+		const block = blocks[contentIndex];
+		if (block?.type === "text") stream.push({ type: "text_end", contentIndex, content: block.text, partial: output });
+		else if (block?.type === "thinking") stream.push({ type: "thinking_end", contentIndex, content: block.thinking, partial: output });
+		else if (block?.type === "toolCall") {
+			block.arguments = parseStreamingJson(block.partialJson);
+			delete block.partialJson;
+			stream.push({ type: "toolcall_end", contentIndex, toolCall: block, partial: output });
+		}
+		if (block) delete block.index;
+		return;
+	}
+	if (event.type === "message_delta") {
+		if (event.delta?.stop_reason) {
+			output.rawStopReason = event.delta.stop_reason;
+			output.stopReason = mapStopReason(event.delta.stop_reason);
+		}
+		updateUsage(state.model, output, event.usage);
+	}
+}
+
+export function emptyOutput(model) {
+	return {
+		role: "assistant",
+		content: [],
+		api: model.api,
+		provider: model.provider,
+		model: model.id,
+		usage: {
+			contextUsage: null,
+			input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0,
+			cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+		},
+		stopReason: "stop",
+		timestamp: Date.now(),
+	};
+}

package/bin/agent/anthropic-subscription-prompt.mjs

@@ -0,0 +1,116 @@
+// The anthropic-subscription lane is one-shot: the SDK query gets no live conversation, so pi's
+// message history is replayed into a single user message as labelled text, followed by an
+// instruction to answer only the final user message. Tool calls stay host-side — a historical
+// tool call or result is described, never re-executed by Claude Code.
+const IMAGE_MEDIA_TYPES = ["image/jpeg", "image/png", "image/gif", "image/webp"];
+
+const isRecord = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+
+function appendEntry(blocks, entry) {
+	if (typeof entry === "string") {
+		if (entry.length > 0) blocks.push({ type: "text", text: entry });
+		return entry.trim().length > 0;
+	}
+	if (!isRecord(entry)) {
+		blocks.push({ type: "text", text: "[unsupported content block omitted]" });
+		return false;
+	}
+	if (entry.type === "text" && typeof entry.text === "string") {
+		blocks.push({ type: "text", text: entry.text });
+		return entry.text.trim().length > 0;
+	}
+	if (entry.type === "image" && typeof entry.data === "string" && IMAGE_MEDIA_TYPES.includes(entry.mimeType)) {
+		blocks.push({ type: "image", source: { type: "base64", media_type: entry.mimeType, data: entry.data } });
+		return true;
+	}
+	if (entry.type === "image") {
+		blocks.push({ type: "text", text: `[image block omitted: unsupported media type ${entry.mimeType ?? "unknown"}]` });
+		return false;
+	}
+	blocks.push({ type: "text", text: `[unsupported content block omitted: ${entry.type}]` });
+	return false;
+}
+
+/** pi content (string or block array) → SDK content blocks appended to `blocks`; true when anything visible landed. */
+function appendSdkContentBlocks(blocks, content) {
+	if (typeof content === "string") return appendEntry(blocks, content);
+	if (!Array.isArray(content)) return false;
+	let visible = false;
+	for (const entry of content) visible = appendEntry(blocks, entry) || visible;
+	return visible;
+}
+
+function contentToText(content) {
+	if (typeof content === "string") return content;
+	if (!Array.isArray(content)) return "";
+	return content
+		.map((block) => {
+			if (block.type === "text") return block.text;
+			if (block.type === "thinking") return block.thinking;
+			if (block.type === "toolCall") return `Historical tool call (non-executable): ${block.name} args=${JSON.stringify(block.arguments)}`;
+			return `[${block.type}]`;
+		})
+		.filter(Boolean)
+		.join("\n");
+}
+
+const CONVERSATION_HISTORY_CLOSER = "\n</conversation_history>";
+export const RESPOND_TO_USER_INSTRUCTION = 'The above is the conversation history so far, provided as context. Respond as the assistant to the user message below only. Never emit "USER:" or "ASSISTANT:" labels or continue the transcript.';
+/** A replay that ends with tool results (a fallback mid-turn) has no new user message; the last entries are the model's own tool outputs, not user input. */
+export const CONTINUE_TURN_INSTRUCTION = 'The above is the conversation history so far, provided as context. There is no new user message: the last entries are results of tool calls you made in your current turn, not anything the user sent. Continue that turn as the assistant. Never emit "USER:" or "ASSISTANT:" labels or continue the transcript.';
+
+/**
+ * pi's context.messages → one SDK user message of content blocks. History is labelled text with a
+ * closing tag, then the instruction, then the final user message's own blocks (images included).
+ */
+export function buildPromptBlocks(context) {
+	const blocks = [];
+	const pushText = (text) => blocks.push({ type: "text", text });
+	// the system messages carry the prompt and tools, which reach the SDK through its own options
+	const messages = (context.messages ?? []).filter((message) => message.role !== "system");
+	const finalMessage = messages.at(-1);
+	const finalUserMessage = finalMessage?.role === "user" ? finalMessage : undefined;
+	const history = finalUserMessage ? messages.slice(0, -1) : messages;
+	const continuesTurn = !finalUserMessage && history.at(-1)?.role === "toolResult";
+	if (history.length > 0) {
+		pushText("<conversation_history>\n");
+		let hasPreviousTurn = false;
+		const pushPrefix = (label) => {
+			pushText(`${hasPreviousTurn ? "\n\n" : ""}${label}\n`);
+			hasPreviousTurn = true;
+		};
+		for (const message of history) {
+			if (message.role === "user") {
+				pushPrefix("USER:");
+				if (!appendSdkContentBlocks(blocks, message.content)) pushText("(see attached image)");
+				continue;
+			}
+			if (message.role === "assistant") {
+				pushPrefix("ASSISTANT:");
+				const text = contentToText(message.content);
+				if (text.length > 0) pushText(text);
+				continue;
+			}
+			if (message.role === "toolResult") {
+				pushPrefix(`TOOL RESULT (historical ${message.toolName}, id=${message.toolCallId}):`);
+				if (!appendSdkContentBlocks(blocks, message.content)) pushText("(see attached image)");
+			}
+		}
+		pushText(CONVERSATION_HISTORY_CLOSER);
+	}
+	pushText(continuesTurn ? CONTINUE_TURN_INSTRUCTION : RESPOND_TO_USER_INSTRUCTION);
+	if (finalUserMessage && !appendSdkContentBlocks(blocks, finalUserMessage.content)) pushText("(see attached image)");
+	return blocks;
+}
+
+/** The SDK's stream-json prompt shape: one user message, delivered as an async iterable. */
+export function buildPromptStream(promptBlocks) {
+	return (async function* () {
+		yield {
+			type: "user",
+			message: { role: "user", content: promptBlocks },
+			parent_tool_use_id: null,
+			session_id: "prompt",
+		};
+	})();
+}

package/bin/agent/anthropic-subscription-stream.mjs

@@ -0,0 +1,251 @@
+// The subscription lane's stream body: spawns the official Claude Code binary through the Claude
+// Agent SDK's `query()`, hands the OAuth access token over as CLAUDE_CODE_OAUTH_TOKEN, replays
+// pi's message history into a single prompt (anthropic-subscription-prompt.mjs), and translates
+// the SDK's stream events back into pi assistant-message events (anthropic-subscription-events.mjs).
+// Tools stay host-side: built-in tools off, host tools on an SDK MCP server that always denies, so
+// every tool call returns to CozyClay's harness and the result comes back in the next prompt.
+
+import { resolveClaudeCodeExecutable } from "./claude-code-executable.mjs";
+import { buildPromptBlocks, buildPromptStream } from "./anthropic-subscription-prompt.mjs";
+import { applyStreamEvent, emptyOutput, mapStopReason, updateUsage } from "./anthropic-subscription-events.mjs";
+const TOOL_EXECUTION_DENIED_MESSAGE = "Not an error: this is the normal host handoff, so ignore the 'hook error' label. " +
+	"CozyClay runs this tool on the host and returns its result as the next user message. " +
+	"Wait for that result, and do not mention this message to the user.";
+
+// Environment the SDK subprocess must not inherit: a stored Anthropic key or gateway would make
+// Claude Code spend it instead of the subscription token we inject.
+function childEnvironment(parent, accessToken) {
+	const {
+		ANTHROPIC_API_KEY: _apiKey, ANTHROPIC_AUTH_TOKEN: _authToken, ANTHROPIC_BASE_URL: _baseUrl,
+		ANTHROPIC_CUSTOM_HEADERS: _customHeaders, CLAUDE_CODE_OAUTH_TOKEN: _oauthToken,
+		CLAUDE_CODE_USE_BEDROCK: _bedrock, CLAUDE_CODE_USE_FOUNDRY: _foundry,
+		CLAUDE_CODE_USE_GATEWAY: _gateway, CLAUDE_CODE_USE_VERTEX: _vertex,
+		...environment
+	} = parent;
+	for (const name of Object.keys(environment)) {
+		if (/^CLAUDE_CODE_OAUTH_TOKEN_\d+$/.test(name)) delete environment[name];
+	}
+	return {
+		...environment,
+		CLAUDE_CODE_OAUTH_TOKEN: accessToken,
+		// Claude Code's per-turn budget reminder rewrites the prompt every turn; CozyClay's harness
+		// owns context budgeting. Native auto-compact stays off: pi owns the transcript.
+		CLAUDE_CODE_TOTAL_TOKENS_REMINDER: "off",
+		DISABLE_COMPACT: "1",
+	};
+}
+
+// pi thinking level → SDK effort. Adaptive-thinking models take { type: "adaptive" } plus an
+// effort grade; the rest take a raw token budget.
+const DEFAULT_THINKING_BUDGETS = { minimal: 2048, low: 8192, medium: 16384, high: 31999, max: 63999 };
+const EFFORT_LEVELS = new Set(["low", "medium", "high", "xhigh", "max"]);
+function applyThinking(queryOptions, model, reasoning) {
+	if (!reasoning || reasoning === "off") return;
+	const adaptive = model.compat?.forceAdaptiveThinking === true;
+	if (adaptive) {
+		const mapped = model.thinkingLevelMap?.[reasoning];
+		const effort = EFFORT_LEVELS.has(mapped) ? mapped
+			: reasoning === "minimal" || reasoning === "low" ? "low"
+			: reasoning === "medium" ? "medium"
+			: reasoning === "high" ? "high"
+			: "max";
+		queryOptions.thinking = { type: "adaptive", display: "summarized" };
+		queryOptions.effort = effort;
+		return;
+	}
+	const level = reasoning === "xhigh" ? "high" : reasoning;
+	const budget = DEFAULT_THINKING_BUDGETS[level];
+	if (budget) queryOptions.maxThinkingTokens = budget;
+}
+
+/** JSON Schema (pi's TypeBox parameters) → the Zod raw shape the SDK's `tool()` wants. */
+async function jsonSchemaToZodShape(schema) {
+	const { z } = await import("zod");
+	const convert = (node) => {
+		const s = node ?? {};
+		let converted;
+		if (s.const !== undefined) converted = s.const === null ? z.null() : z.literal(s.const);
+		else if (Array.isArray(s.enum) && s.enum.length === 1) converted = z.literal(s.enum[0]);
+		else if (Array.isArray(s.enum) && s.enum.length > 1) {
+			const [first, second, ...rest] = s.enum.map((value) => z.literal(value));
+			converted = z.union([first, second, ...rest]);
+		}
+		if (converted === undefined) {
+			const variants = s.anyOf ?? s.oneOf;
+			if (Array.isArray(variants) && variants.length > 0) {
+				const [first, second, ...rest] = variants.map(convert);
+				converted = variants.length === 1 ? first : z.union([first, second, ...rest]);
+			} else {
+				const type = Array.isArray(s.type) ? s.type[0] : s.type;
+				if (type === "string") converted = z.string();
+				else if (type === "number") converted = z.number();
+				else if (type === "integer") converted = z.number().int();
+				else if (type === "boolean") converted = z.boolean();
+				else if (type === "null") converted = z.null();
+				else if (type === "array") converted = z.array(s.items ? convert(s.items) : z.unknown());
+				else if (type === "object") converted = z.object(shape(s));
+				else converted = z.unknown();
+			}
+		}
+		return typeof s.description === "string" ? converted.describe(s.description) : converted;
+	};
+	const shape = (objectSchema) => {
+		const properties = objectSchema?.properties ?? {};
+		const required = new Set(objectSchema?.required ?? []);
+		const result = {};
+		for (const [key, value] of Object.entries(properties)) {
+			const converted = convert(value);
+			result[key] = required.has(key) ? converted : converted.optional();
+		}
+		return result;
+	};
+	return shape(schema ?? {});
+}
+
+/** CozyClay's pi tools → an SDK MCP server. The handler never runs: it is the deny backstop. */
+async function buildCustomToolServers(sdk, piTools) {
+	if (!piTools?.length) return undefined;
+	const tools = [];
+	for (const piTool of piTools) {
+		const schema = await jsonSchemaToZodShape(piTool.parameters);
+		tools.push(sdk.tool(
+			piTool.name,
+			typeof piTool.description === "string" ? piTool.description : "",
+			schema,
+			async () => ({ content: [{ type: "text", text: TOOL_EXECUTION_DENIED_MESSAGE }], isError: true }),
+		));
+	}
+	return { "cozyclay-tools": sdk.createSdkMcpServer({ name: "cozyclay-tools", version: "1.0.0", tools }) };
+}
+
+/** The provider's api. pi's harness calls `streamSimple`; options.apiKey is the OAuth access
+ * token pi resolved (and refreshed) for this request, options.signal aborts, options.reasoning
+ * is the pi thinking level. */
+export function createSubscriptionStream({ loadSdk, resolveExecutable = resolveClaudeCodeExecutable, env = process.env, cwd = process.cwd() } = {}) {
+	const sdkPromise = () => (loadSdk ?? (() => import("@anthropic-ai/claude-agent-sdk")))();
+	return function streamAnthropicSubscription(model, context, options = {}) {
+		return (async () => {
+			// pi hands providers a TranscriptContext: the prompt and the tools live in its system messages.
+			const { createAssistantMessageEventStream, getCurrentSystemPrompt, getCurrentTools, parseStreamingJson } = await import("@earendil-works/pi-ai");
+			const stream = createAssistantMessageEventStream();
+			void (async () => {
+				const output = emptyOutput(model);
+				const blocks = [];
+				let sdkQuery;
+				let closed = false;
+				let wasAborted = false;
+				let started = false;
+				let sawStreamEvent = false;
+				const closeQuery = () => {
+					if (closed || !sdkQuery) return;
+					closed = true;
+					sdkQuery.close();
+				};
+				const onAbort = () => {
+					wasAborted = true;
+					if (!sdkQuery) return;
+					void sdkQuery.interrupt().catch(() => {}).finally(closeQuery);
+				};
+				if (options.signal?.aborted) onAbort();
+				else options.signal?.addEventListener("abort", onAbort, { once: true });
+				try {
+					const accessToken = options.apiKey;
+					if (typeof accessToken !== "string" || !accessToken) {
+						throw new Error("No Anthropic subscription credential resolved; sign in with Claude from the agent panel first.");
+					}
+					const sdk = await sdkPromise();
+					const executable = resolveExecutable({ env });
+					const piTools = getCurrentTools(context.messages);
+					const mcpServers = await buildCustomToolServers(sdk, piTools);
+					const queryOptions = {
+						cwd,
+						model: model.id,
+						// No Claude Code built-in tools; host tools come from the MCP server and every
+						// execution is denied, so the tool call always returns to CozyClay's harness.
+						tools: [],
+						permissionMode: "dontAsk",
+						includePartialMessages: true,
+						canUseTool: async () => ({ behavior: "deny", message: TOOL_EXECUTION_DENIED_MESSAGE }),
+						hooks: {
+							PreToolUse: [{
+								matcher: ".*",
+								hooks: [async () => ({
+									continue: false,
+									hookSpecificOutput: {
+										hookEventName: "PreToolUse",
+										permissionDecision: "deny",
+										permissionDecisionReason: TOOL_EXECUTION_DENIED_MESSAGE,
+									},
+								})],
+							}],
+						},
+						systemPrompt: {
+							type: "preset",
+							preset: "claude_code",
+							append: getCurrentSystemPrompt(context.messages).trim() || undefined,
+						},
+						env: childEnvironment(env, accessToken),
+						pathToClaudeCodeExecutable: executable,
+						settingSources: [],
+						extraArgs: { "strict-mcp-config": null },
+					};
+					if (mcpServers) queryOptions.mcpServers = mcpServers;
+					applyThinking(queryOptions, model, options.reasoning);
+					const promptBlocks = buildPromptBlocks(context);
+					sdkQuery = sdk.query({ prompt: buildPromptStream(promptBlocks), options: queryOptions });
+					if (wasAborted) onAbort();
+					for await (const message of sdkQuery) {
+						if (!started) {
+							stream.push({ type: "start", partial: output });
+							started = true;
+						}
+						if (message.type === "stream_event") {
+							sawStreamEvent = true;
+							applyStreamEvent({ model, output, blocks, stream }, message.event, parseStreamingJson);
+						} else if (message.type === "assistant") {
+							output.responseId ??= message.message?.id || undefined;
+							// SDK assistant snapshots carry placeholder output counts; only a query that
+							// streamed nothing may adopt them.
+							if (!sawStreamEvent) updateUsage(model, output, message.message?.usage, { reset: true });
+						} else if (message.type === "result") {
+							if (message.subtype !== "success") {
+								throw new Error(`Claude Code turn failed (${message.subtype ?? "unknown"})${message.error ? `: ${message.error}` : ""}`);
+							}
+							if (message.usage) updateUsage(model, output, message.usage);
+							if (message.stop_reason != null && output.stopReason !== "toolUse") {
+								output.stopReason = mapStopReason(message.stop_reason);
+							}
+							if (!sawStreamEvent && typeof message.result === "string" && message.result) {
+								output.content.push({ type: "text", text: message.result });
+							}
+						}
+					}
+					for (const block of output.content) {
+						delete block.index;
+						delete block.partialJson;
+					}
+					if (wasAborted || options.signal?.aborted) {
+						output.stopReason = "aborted";
+						output.errorMessage = "Operation aborted";
+						stream.push({ type: "error", reason: "aborted", error: output });
+					} else {
+						stream.push({ type: "done", reason: output.stopReason, message: output });
+					}
+				} catch (error) {
+					for (const block of output.content) {
+						delete block.index;
+						delete block.partialJson;
+					}
+					output.stopReason = wasAborted || options.signal?.aborted ? "aborted" : "error";
+					output.errorMessage = error instanceof Error ? error.message : String(error);
+					stream.push({ type: "error", reason: output.stopReason, error: output });
+				} finally {
+					closeQuery();
+					stream.end();
+				}
+			})();
+			return stream;
+		})();
+	};
+}
+

package/bin/agent/anthropic-subscription.mjs

@@ -0,0 +1,73 @@
+// The Anthropic subscription lane (#claude-subscription): Claude Pro/Max OAuth sign-in, with the
+// actual API calls made by the official Claude Code binary through the Claude Agent SDK.
+//
+// Why the indirection: Anthropic ties a subscription OAuth token to Claude Code. A third-party
+// client calling api.anthropic.com with it gets refused and risks the account; a request the
+// official binary sends is the sanctioned path. So this provider's `api.stream` never touches the
+// Anthropic API itself — the stream implementation lives in anthropic-subscription-stream.mjs.
+//
+// Auth itself is pi's machinery: the provider reuses pi-ai's bundled Anthropic OAuth flow
+// (login / refresh / toAuth), so login, the five-minute refresh window and auth.json storage work
+// exactly like any other pi provider. `toAuth` yields `{ apiKey: <access token> }`, which pi's
+// ModelsImpl passes to `stream` as `options.apiKey` — that is the token the stream injects.
+
+import { createSubscriptionStream } from "./anthropic-subscription-stream.mjs";
+
+export const SUBSCRIPTION_PROVIDER_ID = "anthropic-subscription";
+// named like the ChatGPT lane ("ChatGPT (OpenAI Codex)"): the subscription product first
+export const SUBSCRIPTION_PROVIDER_NAME = "Claude (Anthropic)";
+
+/**
+ * The provider. Claude's catalogue is pi-ai's own anthropic list with the provider id rebound, so
+ * costs, context windows and thinking levels stay in sync with the API-key lane; auth is pi-ai's
+ * bundled Anthropic OAuth flow untouched.
+ */
+export async function anthropicSubscriptionProvider() {
+	const [{ anthropicProvider }, { createProvider }] = await Promise.all([
+		import("@earendil-works/pi-ai/providers/anthropic"),
+		import("@earendil-works/pi-ai"),
+	]);
+	const base = anthropicProvider();
+	const streamImpl = createSubscriptionStream();
+	const models = base.getModels().map((model) => ({
+		...model,
+		provider: SUBSCRIPTION_PROVIDER_ID,
+		compat: model.compat
+			? {
+				...model.compat,
+				allowedFallbackModels: model.compat.allowedFallbackModels?.map((fallback) => ({ ...fallback, provider: SUBSCRIPTION_PROVIDER_ID })),
+			}
+		: model.compat,
+	}));
+	return createProvider({
+		id: SUBSCRIPTION_PROVIDER_ID,
+		name: SUBSCRIPTION_PROVIDER_NAME,
+		auth: {
+			oauth: {
+				name: SUBSCRIPTION_PROVIDER_NAME,
+				// same convention as the ChatGPT lane's "Sign in with ChatGPT (Plus/Pro)"
+				loginLabel: "Sign in with Claude (Pro/Max)",
+				isSubscription: true,
+				login: (interaction) => base.auth.oauth.login(interaction),
+				refresh: (credential, signal) => base.auth.oauth.refresh(credential, signal),
+				toAuth: (credential) => base.auth.oauth.toAuth(credential),
+			},
+		},
+		models,
+		api: { stream: streamImpl, streamSimple: streamImpl },
+	});
+}
+
+/**
+ * Both Anthropic lanes of the agent registry. The subscription lane is the provider above; the
+ * API-key lane is pi-ai's anthropic provider minus the OAuth login it also advertises: spending a
+ * subscription token against the API directly is the refused path, so the panel's only Claude
+ * sign-in stays the subscription lane, whose requests run through the official Claude Code binary.
+ */
+export async function anthropicLaneProvider(id) {
+	if (id === SUBSCRIPTION_PROVIDER_ID) return anthropicSubscriptionProvider();
+	const { anthropicProvider } = await import("@earendil-works/pi-ai/providers/anthropic");
+	const provider = anthropicProvider();
+	if (provider.auth?.oauth) provider.auth = { ...provider.auth, oauth: undefined };
+	return provider;
+}