hob-bot 1.0.4 → 1.1.0

package/vendor/claude-bridge/src/log-paths.ts

@@ -0,0 +1,19 @@
+/**
+ * The bridge's debug and diagnostics logs live in pi's agent dir, so a layout
+ * that sets PI_CODING_AGENT_DIR keeps them beside pi's other state instead of a
+ * fixed ~/.pi/agent. The debug log alone stays overridable, because the test
+ * harness and the probes redirect it to a throwaway path.
+ *
+ * Paths resolve per call rather than at import time, so tests can swap the
+ * environment mid-process and see the new paths immediately.
+ */
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import { join } from "path";
+
+export function debugLogPath(): string {
+	return process.env.CLAUDE_BRIDGE_DEBUG_PATH || join(getAgentDir(), "claude-bridge.log");
+}
+
+export function diagLogPath(): string {
+	return join(getAgentDir(), "claude-bridge-diag.log");
+}

package/vendor/claude-bridge/src/mcp-server.ts

@@ -0,0 +1,169 @@
+// In-process MCP server that exposes pi tools to Claude Code.
+//
+// Pi declares tool parameters as TypeBox objects, which are already JSON
+// Schema at runtime — the same thing MCP puts on the wire. This serves them
+// verbatim instead of going through the SDK's `createSdkMcpServer`, which only
+// accepts Zod and therefore forces a JSON Schema → Zod → JSON Schema round
+// trip. That round trip is lossy below the top level: nested objects collapse
+// to open records and `anyOf`/`const` vanish, so Claude saw only the first
+// level of any tool with a nested schema — including the builtin `edit`.
+// The one exception is a top-level combinator, flattened below because Claude
+// Code drops a tool whose schema has one.
+//
+// Handlers go on the underlying protocol server rather than through
+// `McpServer.registerTool`, which is the Zod-only path. Skipping registerTool
+// also skips its argument validation, which is what we want: pi validates and
+// executes tools itself, and the arguments MCP sees are discarded. A rejection
+// there would only prevent the handler from running, stranding the call.
+//
+// This rests on the Agent SDK treating what we hand it as an opaque JSON-RPC
+// endpoint: `connectSdkMcpServer` in sdk.mjs calls `instance.connect(transport)`
+// and nothing else, so none of McpServer's higher-level machinery is required.
+// The `McpServer` wrapper is kept only because the SDK's `mcpServers` option is
+// typed against that class. If this breaks after an SDK update, check whether
+// the SDK began inspecting the instance — reading registered tools, or expecting
+// tools/list_changed notifications we never send.
+
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import type { McpResult } from "./extract-tool-results.js";
+
+// Claude Code stamps every tools/call with the id of the tool_use block it came
+// from. That is the only reliable way to pair a call with its result: call order
+// is not guaranteed to match the order the tool_use blocks were emitted, so
+// counting calls mispairs results as soon as the two diverge.
+//
+// This is a Claude Code extension, not part of the MCP spec — CC sets it in
+// `src/services/mcp/client.ts` (see reference-code/claude-code-rip). If CC ever
+// stops sending it, every tool call fails with the error below rather than
+// silently pairing results to the wrong call, which is the intended tradeoff.
+const TOOL_USE_ID_META = "claudecode/toolUseId";
+
+export interface McpToolDef {
+	name: string;
+	description: string;
+	inputSchema: unknown;
+	handler: (toolCallId: string) => Promise<McpResult>;
+}
+
+// MCP requires an object schema. Pi types tool parameters as any TypeBox schema,
+// so a scalar or array one typechecks but cannot go on the wire — that is a bug
+// in the tool, and reporting it at startup names the culprit. Degrading it to
+// "takes no arguments" instead would surface much later as Claude calling the
+// tool with no arguments and pi's own validation rejecting them.
+function assertObjectSchema(tool: McpToolDef): void {
+	const schema = tool.inputSchema as Record<string, unknown> | undefined;
+	if (!schema || schema.type !== "object") {
+		throw new Error(`${tool.name}: MCP tool parameters must be an object schema, got ${JSON.stringify(schema)}`);
+	}
+}
+
+// Claude Code drops an MCP tool outright when its input schema has a top-level
+// anyOf/oneOf/allOf ("its input schema uses top-level anyOf, which the Anthropic
+// API does not accept"; CC's own normalizer for this is gated off for our
+// server). The tool is still in our served-name map, so a call Claude makes to it
+// anyway is forwarded to pi and runs there while CC answers "No such tool
+// available" and retries under a fresh id — the tool runs twice, or the retry's
+// handler waits forever. Advertise a flat object instead, built the way CC's
+// normalizer does: root properties win over branch ones, root `required` stays,
+// and allOf requirements join it (anyOf/oneOf ones hold only for one branch).
+// Like CC, branch `$ref`s into the root's `$defs`/`definitions` are followed,
+// and the lost constraint is restated as a note for the tool description, so
+// Claude's first call is likely to pass pi's validation against the full schema.
+const ROOT_COMBINATORS = ["anyOf", "oneOf", "allOf"] as const;
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function resolveLocalRef(branch: unknown, root: Record<string, unknown>): unknown {
+	if (!isRecord(branch) || typeof branch.$ref !== "string") return branch;
+	const match = /^#\/(\$defs|definitions)\/([^/]+)$/.exec(branch.$ref);
+	const defs = match && root[match[1]];
+	const target = match && isRecord(defs) ? defs[match[2]] : undefined;
+	return isRecord(target) ? target : branch;
+}
+
+// A branch is named by its required keys, else by all of its keys.
+function branchGroup(branch: unknown): string | null {
+	if (!isRecord(branch)) return null;
+	const { required, properties } = branch;
+	if (Array.isArray(required) && required.length > 0 && required.every((key) => typeof key === "string")) return required.join(", ");
+	const keys = isRecord(properties) ? Object.keys(properties) : [];
+	return keys.length > 0 ? keys.join(", ") : null;
+}
+
+// CC's wording, so the tool reads the same as one CC normalized itself.
+function combinatorNote(combinators: readonly string[], branchesOf: (key: string) => unknown[]): string {
+	if (!combinators.includes("anyOf") && !combinators.includes("oneOf")) {
+		return "Input constraint: all listed parameters apply together (flattened from a JSON Schema allOf).";
+	}
+	const key = combinators.includes("oneOf") ? "oneOf" : "anyOf";
+	const rule = key === "oneOf" ? "Provide parameters for exactly one of" : "Provide parameters for at least one of";
+	const groups = [...new Set(branchesOf(key).map(branchGroup).filter((group) => group !== null))];
+	if (groups.length === 0) return `Input constraint: ${rule} the documented parameter groups (flattened from a JSON Schema ${key}).`;
+	return `Input constraint: ${rule}: ${groups.map((group) => `(${group})`).join(" or ")}.`;
+}
+
+function flattenRootCombinators(schema: Record<string, unknown>): { schema: Record<string, unknown>; note?: string } {
+	const combinators = ROOT_COMBINATORS.filter((key) => key in schema);
+	if (combinators.length === 0) return { schema };
+
+	const { anyOf: _anyOf, oneOf: _oneOf, allOf: _allOf, ...rest } = schema;
+	const branchesOf = (key: string) => {
+		const branches = schema[key];
+		return Array.isArray(branches) ? branches.map((branch) => resolveLocalRef(branch, schema)) : [];
+	};
+	const properties: Record<string, unknown> = {};
+	const required: string[] = [];
+	const addProperties = (source: unknown) => {
+		if (!isRecord(source) || !isRecord(source.properties)) return;
+		for (const [key, value] of Object.entries(source.properties)) if (!(key in properties)) properties[key] = value;
+	};
+	const addRequired = (source: unknown) => {
+		if (!isRecord(source) || !Array.isArray(source.required)) return;
+		for (const key of source.required) if (typeof key === "string" && !required.includes(key)) required.push(key);
+	};
+
+	addProperties(schema);
+	for (const key of combinators) for (const branch of branchesOf(key)) addProperties(branch);
+	addRequired(schema);
+	for (const branch of branchesOf("allOf")) addRequired(branch);
+
+	const flat: Record<string, unknown> = { ...rest, type: "object", properties };
+	if (required.length > 0) flat.required = required;
+	else delete flat.required;
+	return { schema: flat, note: combinatorNote(combinators, branchesOf) };
+}
+
+export function createToolServer(name: string, tools: McpToolDef[]) {
+	const server = new McpServer({ name, version: "1.0.0" }, { capabilities: { tools: {} } });
+	const byName = new Map(tools.map((tool) => [tool.name, tool]));
+	for (const tool of tools) assertObjectSchema(tool);
+
+	server.server.setRequestHandler(ListToolsRequestSchema, () => ({
+		tools: tools.map((tool) => {
+			const { schema, note } = flattenRootCombinators(tool.inputSchema as Record<string, unknown>);
+			return {
+				name: tool.name,
+				description: [note, tool.description].filter(Boolean).join("\n\n"),
+				inputSchema: schema,
+			};
+		}),
+	}));
+
+	server.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+		const tool = byName.get(request.params.name);
+		if (!tool) throw new Error(`Unknown tool: ${request.params.name}`);
+		const toolCallId = request.params._meta?.[TOOL_USE_ID_META];
+		if (typeof toolCallId !== "string") {
+			throw new Error(`${tool.name}: tools/call is missing _meta["${TOOL_USE_ID_META}"] — cannot pair the result with its tool call`);
+		}
+		// Narrowed deliberately: McpResult also carries `toolCallId`, which is our
+		// own bookkeeping for pairing and not part of MCP's CallToolResult.
+		const { content, isError } = await tool.handler(toolCallId);
+		return { content, isError };
+	});
+
+	return { type: "sdk" as const, name, instance: server };
+}

package/vendor/claude-bridge/src/models.ts

@@ -0,0 +1,164 @@
+// Model selection + display-order policy for the model picker. The picker is
+// driven by pi-ai's anthropic catalog: models appear (and disappear) with it,
+// no per-model code here. Extracted from index.ts so tests can import without
+// activating the extension.
+// `resolveModel` resolves family shortcuts (opus/sonnet/fable) to the newest
+// matching id regardless of sort order; sort order only drives picker display.
+
+const TWO_HUNDRED_K_CONTEXT = 200_000;
+const ONE_M_CONTEXT = 1_000_000;
+
+// pi-ai ships dated snapshot ids (claude-opus-4-5-20251101, ...) alongside the
+// bare ids. They are never exposed - and must not steal first-partial-match
+// shortcuts like "opus-4-5" from the bare id.
+function isDatedAlias(id: string): boolean {
+	return /-20\d{6}$/.test(id);
+}
+
+// Family tiers for display order: flagship families first; unknown families
+// sink below all known ones.
+const FAMILY_ORDER = ["fable", "opus", "sonnet", "haiku"];
+
+// Project pi-ai's model entries down to the fields pi's registerProvider expects,
+// newest generation first. Context-dependent display labels are applied after
+// plan/long-context config is known.
+// Version rank of a claude id, e.g. claude-opus-4-7 → ["opus", 4, 7]. Shared by
+// the display sort and resolveModel's newest-first partial tiebreak.
+function versionRank(id: string): { family: string; tuple: [number, number] } {
+	const [, family, major, minor] = id.split("-");
+	return { family, tuple: [Number(major) || 0, Number(minor) || 0] };
+}
+
+export function buildModels<T extends { id: string; [key: string]: any }>(piAiModels: T[]) {
+	return piAiModels
+		.filter((m) => typeof m.id === "string" && !isDatedAlias(m.id))
+		.sort((a, b) => {
+			const fa = FAMILY_ORDER.indexOf(versionRank(a.id).family);
+			const fb = FAMILY_ORDER.indexOf(versionRank(b.id).family);
+			const ta = fa === -1 ? FAMILY_ORDER.length : fa;
+			const tb = fb === -1 ? FAMILY_ORDER.length : fb;
+			if (ta !== tb) return ta - tb;
+			const ra = versionRank(a.id).tuple;
+			const rb = versionRank(b.id).tuple;
+			if (ra[0] !== rb[0]) return rb[0] - ra[0];
+			if (ra[1] !== rb[1]) return rb[1] - ra[1];
+			return a.id.localeCompare(b.id);
+		})
+		// Forward thinkingLevelMap so pi-ai's per-model overrides (e.g. opus-4-8
+		// mapping xhigh→xhigh and max→max) are visible to the effort lookup.
+		.map(({ id, name, reasoning, input, contextWindow, maxTokens, thinkingLevelMap }) => ({
+			id,
+			name,
+			reasoning, input, contextWindow, maxTokens,
+			thinkingLevelMap,
+			cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+		}));
+}
+
+export type LongContextSettings = {
+	plan: "pro" | "max";
+	longContextExtraUsage: boolean;
+	// Model ids whose declared 1M context Claude Code turned out not to serve;
+	// forces bare id at 200K without a code change.
+	forceTwoHundredK?: string[];
+};
+
+export type ClaudeCodeRuntimeModel = {
+	cliModelId: string;
+	contextWindow: number;
+};
+
+// Measured Claude Agent SDK behavior - see diag/CONTEXT-SIZE.md:
+// - The `[1m]` suffix is the only reliable way to request 1M context through
+//   the SDK; bare ids serve 200K.
+// - An unentitled `[1m]` id is rejected outright (400/429), failing every turn
+//   — worse than serving 200K, so the default is bare id at 200K and only
+//   measured-good ids get `[1m]`.
+// - The registered contextWindow must match the window the bridge actually
+//   requests, or pi's status bar and compaction threshold misreport.
+// [1m] ids verified to serve 1M on every plan (sonnet-5-5 measured on Pro with
+// and without Extra Usage; opus-5-5 on Max per its run notes). A new model
+// serves 200K until someone measures it (diag/context-size.mjs) and adds it
+// here. Known exception unrelated to long context: fable-5 is not included
+// with Pro account without Extra Usage.
+const MEASURED_ONE_M = new Set([
+	"claude-fable-5",
+	"claude-fable-5-1",
+	"claude-opus-5-5",
+	"claude-opus-5",
+	"claude-opus-4-8",
+	"claude-opus-4-7",
+  "claude-sonnet-5",
+	"claude-sonnet-5-5",
+	"claude-haiku-5-5",
+]);
+
+// Measured exceptions: pi-ai declares 1M and the [1m] id works, but only when
+// the plan allows it.
+const PLAN_GATED_ONE_M: Record<string, (settings: LongContextSettings) => boolean> = {
+	// [1m] measured 1M on Max plan / extra usage; 429 on Pro without it.
+	"claude-opus-4-6": (settings) => settings.plan === "max" || settings.longContextExtraUsage,
+	// [1m] measured 1M with extra usage only.
+	"claude-sonnet-4-6": (settings) => settings.longContextExtraUsage,
+};
+
+export function resolveClaudeCodeRuntimeModel(
+	model: { id: string },
+	settings: LongContextSettings,
+): ClaudeCodeRuntimeModel {
+	const modelId = model.id;
+	if (settings.forceTwoHundredK?.includes(modelId)) {
+		return { cliModelId: modelId, contextWindow: TWO_HUNDRED_K_CONTEXT };
+	}
+	if (MEASURED_ONE_M.has(modelId)) {
+		return { cliModelId: `${modelId}[1m]`, contextWindow: ONE_M_CONTEXT };
+	}
+	const planGate = PLAN_GATED_ONE_M[modelId];
+	if (planGate) {
+		const useOneM = planGate(settings);
+		return {
+			cliModelId: useOneM ? `${modelId}[1m]` : modelId,
+			contextWindow: useOneM ? ONE_M_CONTEXT : TWO_HUNDRED_K_CONTEXT,
+		};
+	}
+	// No measured row: bare id at 200K, the safe default (see diag/CONTEXT-SIZE.md).
+	return { cliModelId: modelId, contextWindow: TWO_HUNDRED_K_CONTEXT };
+}
+
+export function claudeCodeModelId(model: { id: string }, settings: LongContextSettings): string {
+	return resolveClaudeCodeRuntimeModel(model, settings).cliModelId;
+}
+
+export function resolveModel<T extends { id: string }>(models: T[], input: string): T | undefined {
+	const lower = input.toLowerCase();
+	// Exact first, then partial (mirrors pi's tryMatchModel ordering), so a
+	// longer newer id containing the input (claude-fable-5-1 vs "claude-fable-5")
+	// cannot shadow the exact match.
+	return models.find((m) => m.id === lower)
+		?? newestPartialMatch(models.filter((m) => m.id.includes(lower)));
+}
+
+// Newest match by version rank — independent of registration order.
+function newestPartialMatch<T extends { id: string }>(candidates: T[]): T | undefined {
+	if (candidates.length === 0) return undefined;
+	return candidates.reduce((best, m) => {
+		const [vb, vbest] = [versionRank(m.id).tuple, versionRank(best.id).tuple];
+		const newer = vb[0] !== vbest[0] ? vb[0] > vbest[0] : vb[1] > vbest[1];
+		return newer ? m : best;
+	});
+}
+
+// Produce the model metadata registered with pi. The registered contextWindow must
+// match the window the bridge actually requests from Claude Code, or pi's status
+// bar and auto-compaction threshold will misreport. The runtime policy is based
+// on measured SDK behavior - see diag/CONTEXT-SIZE.md
+export function applyLongContext<T extends { id: string; name: string; contextWindow?: number | null }>(
+	models: T[],
+	settings: LongContextSettings,
+): T[] {
+	return models.map((m) => {
+		const { contextWindow } = resolveClaudeCodeRuntimeModel(m, settings);
+		const name = contextWindow > TWO_HUNDRED_K_CONTEXT && !/\b1M\b/i.test(m.name) ? `${m.name} 1M` : m.name;
+		return contextWindow === m.contextWindow && name === m.name ? m : { ...m, contextWindow, name };
+	});
+}