@pablopunk/tau 0.0.0-stage → 0.1.1

package/dist/fake-claude-connectors-DSP9UC8d.js

@@ -0,0 +1 @@
+export { t as FAKE_LINEAR, n as FAKE_NEEDS_AUTH, r as FAKE_SLACK } from "./fake-claude-connectors-sDLeP10T.js";

package/dist/fake-claude-connectors-sDLeP10T.js

@@ -0,0 +1,107 @@
+import { i as connectorServerOf, n as cliToolNameOf } from "./names-cTrEXB6w.js";
+//#region ../core/src/claude-cli/testing/fake-claude-connectors.ts
+const FAKE_LINEAR = {
+	name: "claude.ai Linear",
+	status: "connected",
+	tools: [
+		{
+			name: "list_teams",
+			readOnly: true
+		},
+		{
+			name: "get_issue",
+			readOnly: true
+		},
+		{
+			name: "save_comment",
+			readOnly: false
+		}
+	]
+};
+const FAKE_SLACK = {
+	name: "claude.ai Slack",
+	status: "connected",
+	tools: [{
+		name: "slack_search_public",
+		readOnly: true
+	}, {
+		name: "slack_send_message",
+		readOnly: false
+	}]
+};
+const FAKE_NEEDS_AUTH = {
+	name: "claude.ai Notion",
+	status: "needs-auth",
+	tools: []
+};
+const connectorCliName = (server, tool) => cliToolNameOf({
+	server: connectorServerOf(server),
+	tool
+});
+const connectorsAreOpen = (options) => !options.strictMcpConfig && !options.settings.disableClaudeAiConnectors;
+const matchesAllowed = (allowed, toolName) => allowed.endsWith("*") ? toolName.startsWith(allowed.slice(0, -1)) : allowed === toolName;
+const isAllowedByList = (allowedTools, toolName) => allowedTools.some((allowed) => matchesAllowed(allowed, toolName));
+const disabledServer = (server) => ({
+	...server,
+	status: "disabled",
+	tools: []
+});
+function createFakeMcpState(input) {
+	const switchedOff = /* @__PURE__ */ new Set();
+	const { toggles } = input;
+	let polls = 0;
+	const stillPending = () => polls >= 1 && polls <= input.pendingPolls;
+	const tauServer = () => ({
+		name: "tau",
+		status: "connected",
+		source: "sdk",
+		error: null,
+		tools: input.tauTools().map((name) => ({
+			name,
+			readOnly: false
+		}))
+	});
+	const connectorServer = (server) => {
+		const status = {
+			name: server.name,
+			status: stillPending() ? "pending" : server.status,
+			source: server.source ?? "claudeai",
+			error: null,
+			tools: stillPending() ? [] : server.tools
+		};
+		return switchedOff.has(server.name) ? disabledServer(status) : status;
+	};
+	const statuses = () => [tauServer(), ...input.open ? input.connectors.map(connectorServer) : []];
+	const loadedConnectorTools = () => statuses().filter((server) => server.source !== "sdk" && server.status === "connected").flatMap((server) => server.tools.map((tool) => ({
+		server: server.name,
+		tool: tool.name
+	})));
+	return {
+		toggles,
+		control: {
+			async mcpServerStatus() {
+				polls += 1;
+				return statuses();
+			},
+			async toggleMcpServer(name, enabled) {
+				toggles.push({
+					name,
+					enabled
+				});
+				if (enabled) switchedOff.delete(name);
+				else switchedOff.add(name);
+			}
+		},
+		context: () => {
+			const loadedMcpToolCounts = {};
+			for (const { server } of loadedConnectorTools()) loadedMcpToolCounts[server] = (loadedMcpToolCounts[server] ?? 0) + 1;
+			return {
+				memoryFileCount: 0,
+				loadedMcpToolCounts
+			};
+		},
+		activeToolNames: () => loadedConnectorTools().map(({ server, tool }) => connectorCliName(server, tool))
+	};
+}
+//#endregion
+export { connectorsAreOpen as a, connectorCliName as i, FAKE_NEEDS_AUTH as n, createFakeMcpState as o, FAKE_SLACK as r, isAllowedByList as s, FAKE_LINEAR as t };

package/dist/fake-claude-sdk-CvqW_1iQ.js

@@ -0,0 +1,571 @@
+import { t as TOOL_NAME_PREFIX } from "./tool-server-BjP37EJg.js";
+import { a as connectorsAreOpen, i as connectorCliName, o as createFakeMcpState, s as isAllowedByList } from "./fake-claude-connectors-sDLeP10T.js";
+//#region ../core/src/claude-cli/testing/fake-claude-events.ts
+const FAKE_USAGE = {
+	input_tokens: 10,
+	output_tokens: 5,
+	cache_read_input_tokens: 0,
+	cache_creation_input_tokens: 0
+};
+const FAKE_CONTEXT_WINDOW = 1e6;
+function createMessageIds() {
+	let message = 0;
+	let uuid = 0;
+	let tool = 0;
+	return {
+		messageId: () => `msg_fake_${++message}`,
+		uuid: () => `uuid-fake-${++uuid}`,
+		toolUseId: () => `toolu_fake_${++tool}`
+	};
+}
+const streamEvent = (sessionId, event) => ({
+	type: "stream_event",
+	session_id: sessionId,
+	event
+});
+const deltaOf = (block) => {
+	if (block.type === "text") return {
+		type: "text_delta",
+		text: block.text
+	};
+	if (block.type === "thinking") return {
+		type: "thinking_delta",
+		thinking: block.thinking
+	};
+	return {
+		type: "input_json_delta",
+		partial_json: JSON.stringify(block.input)
+	};
+};
+const startOf = (block) => block.type === "tool_use" ? {
+	...block,
+	input: {}
+} : {
+	...block,
+	text: "",
+	thinking: ""
+};
+/** Stream events, then one `assistant` message per content block, as the SDK emits them. */
+function apiMessageEvents(sessionId, message, ids) {
+	const events = [streamEvent(sessionId, {
+		type: "message_start",
+		message: {
+			id: message.id,
+			model: message.model,
+			usage: FAKE_USAGE
+		}
+	})];
+	message.blocks.forEach((block, index) => {
+		events.push(streamEvent(sessionId, {
+			type: "content_block_start",
+			index,
+			content_block: startOf(block)
+		}));
+		events.push(streamEvent(sessionId, {
+			type: "content_block_delta",
+			index,
+			delta: deltaOf(block)
+		}));
+		events.push(streamEvent(sessionId, {
+			type: "content_block_stop",
+			index
+		}));
+	});
+	events.push(streamEvent(sessionId, {
+		type: "message_delta",
+		delta: { stop_reason: message.stopReason },
+		usage: FAKE_USAGE
+	}), streamEvent(sessionId, { type: "message_stop" }));
+	for (const block of message.blocks) events.push({
+		type: "assistant",
+		uuid: ids.uuid(),
+		session_id: sessionId,
+		...message.error && { error: message.error },
+		message: {
+			id: message.id,
+			model: message.model,
+			role: "assistant",
+			content: [block],
+			stop_reason: message.stopReason,
+			usage: FAKE_USAGE
+		}
+	});
+	return events;
+}
+const rateLimitEvent = (sessionId, limit, uuid) => ({
+	type: "rate_limit_event",
+	uuid,
+	session_id: sessionId,
+	rate_limit_info: {
+		status: limit.status,
+		rateLimitType: "five_hour",
+		utilization: limit.fiveHour,
+		resetsAt: limit.resetsAt,
+		unifiedWindows: { five_hour: { utilization: limit.fiveHour } }
+	}
+});
+const toolResultEvent = (sessionId, toolUseId, text, isError, uuid) => ({
+	type: "user",
+	uuid,
+	session_id: sessionId,
+	message: {
+		role: "user",
+		content: [{
+			type: "tool_result",
+			tool_use_id: toolUseId,
+			content: text,
+			is_error: isError
+		}]
+	}
+});
+const resultEvent = (sessionId, model, outcome, uuid) => ({
+	type: "result",
+	uuid,
+	session_id: sessionId,
+	subtype: outcome === "success" ? "success" : "error_during_execution",
+	is_error: outcome !== "success",
+	...outcome === "interrupted" && { terminal_reason: "aborted_tools" },
+	usage: FAKE_USAGE,
+	modelUsage: { [model]: {
+		...FAKE_USAGE,
+		contextWindow: FAKE_CONTEXT_WINDOW,
+		costUSD: 0
+	} }
+});
+const initEvent = (sessionId, model, toolNames, apiKeySource) => ({
+	type: "system",
+	subtype: "init",
+	session_id: sessionId,
+	model,
+	tools: toolNames,
+	mcp_servers: [{
+		name: "tau",
+		status: "connected"
+	}],
+	apiKeySource,
+	claude_code_version: "0.0.0-fake"
+});
+//#endregion
+//#region ../core/src/claude-cli/testing/fake-claude-models.ts
+const STANDARD_EFFORT = [
+	"low",
+	"medium",
+	"high",
+	"xhigh"
+];
+const NO_EFFORT = [];
+const row = (value, resolvedModel, displayName, supportedEffortLevels = STANDARD_EFFORT) => ({
+	value,
+	resolvedModel,
+	displayName,
+	description: `${displayName} (fake)`,
+	supportedEffortLevels,
+	supportsThinkingOff: supportedEffortLevels.length === 0 || value === "haiku"
+});
+/** The 14 rows the spike saw from `supportedModels()` on CLI 2.1.302. */
+const FAKE_CLAUDE_MODELS = [
+	row("default", "claude-opus-5-5", "Default (Opus 5.5)"),
+	row("opus", "claude-opus-5-5", "Opus 5.5"),
+	row("fable", "claude-fable-5-1", "Fable 5.1"),
+	row("sonnet", "claude-sonnet-5-5", "Sonnet 5.5"),
+	row("haiku", "claude-haiku-5-5", "Haiku 5.5", NO_EFFORT),
+	row("claude-haiku-4-5-20251001", "claude-haiku-4-5-20251001", "Haiku 4.5", NO_EFFORT),
+	row("claude-sonnet-5", "claude-sonnet-5", "Sonnet 5"),
+	row("claude-opus-5", "claude-opus-5", "Opus 5"),
+	row("claude-fable-5", "claude-fable-5", "Fable 5"),
+	row("claude-opus-4-8", "claude-opus-4-8", "Opus 4.8"),
+	row("claude-opus-4-7", "claude-opus-4-7", "Opus 4.7"),
+	row("claude-opus-4-6", "claude-opus-4-6", "Opus 4.6"),
+	row("claude-sonnet-4-6", "claude-sonnet-4-6", "Sonnet 4.6"),
+	row("claude-mythos-5-1", "claude-mythos-5-1", "Mythos 5.1")
+];
+//#endregion
+//#region ../core/src/claude-cli/testing/message-channel.ts
+function createMessageChannel() {
+	const queue = [];
+	let ended = false;
+	let wake;
+	async function* iterate() {
+		while (true) {
+			while (queue.length === 0 && !ended) await new Promise((resolve) => wake = resolve);
+			const next = queue.shift();
+			if (next === void 0) return;
+			yield next;
+		}
+	}
+	return {
+		[Symbol.asyncIterator]: iterate,
+		push(value) {
+			if (ended) return;
+			queue.push(value);
+			wake?.();
+		},
+		end() {
+			ended = true;
+			wake?.();
+		}
+	};
+}
+//#endregion
+//#region ../core/src/claude-cli/testing/fake-claude-query.ts
+const INTERRUPTED_TEXT = "The tool call was interrupted by the user.";
+const textOfInput = (message) => typeof message.message.content === "string" ? message.message.content : message.message.content.map((block) => block.type === "text" ? block.text : "[image]").join("\n");
+const resolvedModel = (model) => FAKE_CLAUDE_MODELS.find((row) => row.value === model)?.resolvedModel ?? model;
+const textOfResult = (result) => result.content.map((block) => block.type === "text" ? block.text : "[image]").join("\n");
+const nextTick = () => new Promise((resolve) => setImmediate(resolve));
+const sleepMs = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const deniedText = (toolName) => `Permission to use ${toolName} has been denied.`;
+const unavailableText = (toolName) => `Error: No such tool available: ${toolName}`;
+const cliNameOf = (use) => use.connector ? connectorCliName(use.connector.server, use.name) : `${TOOL_NAME_PREFIX}${use.name}`;
+function createFakeQuery(deps) {
+	const { options, record, script, ids } = deps;
+	const out = createMessageChannel();
+	const pending = [];
+	let model = options.model;
+	let turnIndex = 0;
+	let initSent = false;
+	let inputDone = false;
+	let wake;
+	let interruptTurn;
+	let turnInterrupted;
+	const mcp = createFakeMcpState({
+		open: connectorsAreOpen(options),
+		connectors: deps.connectors,
+		tauTools: () => (options.toolHost?.listTools() ?? []).map((tool) => `${TOOL_NAME_PREFIX}${tool.name}`),
+		pendingPolls: deps.pendingPolls,
+		toggles: record.toggles
+	});
+	const emit = (message) => out.push(message);
+	const sessionId = () => record.sessionId;
+	async function readInput() {
+		if (typeof options.prompt === "string") {
+			pending.push(options.prompt);
+			record.inputs.push(options.prompt);
+			inputDone = true;
+			return;
+		}
+		for await (const message of options.prompt) {
+			const text = textOfInput(message);
+			record.inputs.push(text);
+			pending.push(text);
+			wake?.();
+		}
+		inputDone = true;
+	}
+	const emitApiMessage = (blocks, stopReason, error) => {
+		const message = {
+			id: ids.messageId(),
+			model: resolvedModel(model),
+			blocks,
+			stopReason,
+			error
+		};
+		for (const event of apiMessageEvents(sessionId(), message, ids)) emit(event);
+	};
+	const emitResult = (outcome) => emit(resultEvent(sessionId(), resolvedModel(model), outcome, ids.uuid()));
+	function foldPending() {
+		if (pending.length === 0) return;
+		record.folded.push({
+			turnIndex,
+			texts: pending.splice(0)
+		});
+	}
+	async function runTool(use, toolUseId) {
+		const host = options.toolHost;
+		if (!host) throw new Error("The fake SDK got a tool call but no tool host.");
+		const args = use.arguments ?? {};
+		record.toolCalls.push({
+			name: use.name,
+			toolUseId,
+			arguments: args
+		});
+		const call = host.callTool({
+			name: use.name,
+			arguments: args,
+			toolUseId
+		});
+		return turnInterrupted ? Promise.race([call, turnInterrupted]) : call;
+	}
+	async function askPermission(use, toolName, toolUseId) {
+		if (isAllowedByList(options.allowedTools, toolName)) return {
+			behavior: "allow",
+			updatedInput: use.arguments ?? {}
+		};
+		if (!options.canUseTool || options.permissionMode === "dontAsk") return {
+			behavior: "deny",
+			message: deniedText(toolName)
+		};
+		const controller = new AbortController();
+		const asked = options.canUseTool({
+			toolName,
+			input: use.arguments ?? {},
+			toolUseId,
+			signal: controller.signal,
+			mcpServer: {
+				name: use.connector?.server ?? "",
+				source: "claudeai"
+			}
+		});
+		const decision = await Promise.race([asked, turnInterrupted ?? asked]);
+		const settled = decision === "interrupted" ? "aborted" : decision.behavior;
+		record.permissionRequests.push({
+			toolName,
+			toolUseId,
+			decision: settled
+		});
+		if (decision === "interrupted") controller.abort();
+		return decision;
+	}
+	async function runConnector(use, toolUseId) {
+		const run = use.connector;
+		if (!run) return "done";
+		const toolName = cliNameOf(use);
+		const call = {
+			toolName,
+			toolUseId,
+			ran: false
+		};
+		record.connectorCalls.push(call);
+		if (!mcp.activeToolNames().includes(toolName)) {
+			emitToolResult(toolUseId, unavailableText(toolName), true);
+			return "done";
+		}
+		const decision = await askPermission(use, toolName, toolUseId);
+		if (decision === "interrupted") return "interrupted";
+		if (decision.behavior === "deny") {
+			emitToolResult(toolUseId, decision.message, true);
+			return "done";
+		}
+		if (await Promise.race([sleepMs(run.delayMs ?? 0), turnInterrupted ?? sleepMs(0)]) === "interrupted") return "interrupted";
+		call.ran = true;
+		emitToolResult(toolUseId, run.result, run.isError ?? false);
+		return "done";
+	}
+	async function runTauTool(use, toolUseId) {
+		const result = await runTool(use, toolUseId);
+		if (result === "interrupted") return "interrupted";
+		emitToolResult(toolUseId, textOfResult(result), result.isError);
+		return "done";
+	}
+	function emitToolResult(toolUseId, text, isError) {
+		record.toolResults.push({
+			toolUseId,
+			text,
+			isError
+		});
+		emit(toolResultEvent(sessionId(), toolUseId, text, isError, ids.uuid()));
+	}
+	async function runToolsStep(step) {
+		const uses = step.calls.map((call) => ({
+			call,
+			toolUseId: ids.toolUseId()
+		}));
+		const blocks = uses.map(({ call, toolUseId }) => ({
+			type: "tool_use",
+			id: toolUseId,
+			name: cliNameOf(call),
+			input: call.arguments ?? {}
+		}));
+		emitApiMessage([...step.text ? [{
+			type: "text",
+			text: step.text
+		}] : [], ...blocks], "tool_use");
+		for (const [index, { call, toolUseId }] of uses.entries()) if ((call.connector ? await runConnector(call, toolUseId) : await runTauTool(call, toolUseId)) === "interrupted") {
+			for (const open of uses.slice(index)) emitToolResult(open.toolUseId, INTERRUPTED_TEXT, true);
+			return "interrupted";
+		}
+		return "continue";
+	}
+	async function runStep(step) {
+		if (step.kind === "rateLimit") {
+			emit(rateLimitEvent(sessionId(), step.limit, ids.uuid()));
+			return "continue";
+		}
+		if (step.kind === "text") {
+			const thinking = step.thinking ? [{
+				type: "thinking",
+				thinking: step.thinking
+			}] : [];
+			emitApiMessage([...thinking, {
+				type: "text",
+				text: step.text
+			}], "end_turn");
+			emitResult("success");
+			return "ended";
+		}
+		if (step.kind === "error") {
+			emitApiMessage([{
+				type: "text",
+				text: step.text ?? step.code
+			}], "end_turn", step.code);
+			emitResult("error");
+			return "ended";
+		}
+		return runToolsStep(step);
+	}
+	async function runTurn(firstUserText) {
+		turnInterrupted = new Promise((resolve) => {
+			interruptTurn = () => resolve("interrupted");
+		});
+		if (!initSent) {
+			initSent = true;
+			const names = [...(options.toolHost?.listTools() ?? []).map((tool) => `${TOOL_NAME_PREFIX}${tool.name}`), ...mcp.activeToolNames()];
+			emit(initEvent(sessionId(), resolvedModel(model), names, deps.apiKeySource));
+		}
+		const steps = script(turnIndex, firstUserText, options.toolHost !== void 0);
+		for (const step of steps) {
+			await nextTick();
+			const outcome = await runStep(step);
+			if (outcome === "interrupted") return void emitResult("interrupted");
+			if (outcome === "ended") return;
+			foldPending();
+		}
+		emitResult("success");
+	}
+	async function drive() {
+		while (!record.closed) {
+			while (pending.length === 0 && !record.closed && !inputDone) await new Promise((resolve) => wake = resolve);
+			const first = pending.shift();
+			if (first === void 0) return;
+			await runTurn(first);
+			turnIndex += 1;
+			interruptTurn = void 0;
+		}
+	}
+	readInput().finally(() => wake?.());
+	drive().finally(() => out.end());
+	return {
+		[Symbol.asyncIterator]: () => out[Symbol.asyncIterator](),
+		async interrupt() {
+			record.interrupts += 1;
+			interruptTurn?.();
+		},
+		...mcp.control,
+		async setModel(next) {
+			record.models.push(next);
+			model = next;
+		},
+		async applyFlagSettings(settings) {
+			record.flags.push({ ...settings });
+		},
+		async isAutoCompactEnabled() {
+			return options.settings.autoCompactEnabled !== false;
+		},
+		close() {
+			record.closed = true;
+			wake?.();
+			interruptTurn?.();
+			out.end();
+		}
+	};
+}
+//#endregion
+//#region ../core/src/claude-cli/testing/fake-claude-script.ts
+const sayOk = () => [{
+	kind: "text",
+	text: "ok"
+}];
+//#endregion
+//#region ../core/src/claude-cli/testing/fake-claude-sdk.ts
+const FAKE_LOGGED_IN = {
+	loggedIn: true,
+	authMethod: "claude.ai",
+	subscriptionType: "team",
+	orgName: "Fake Org"
+};
+function createFakeClaudeSdk(options = {}) {
+	const queries = [];
+	const deletedSessions = [];
+	const ids = createMessageIds();
+	let script = options.script ?? sayOk;
+	let auth = options.auth ?? FAKE_LOGGED_IN;
+	let sessions = 0;
+	let loads = 0;
+	const probes = [];
+	const connectors = options.connectors ?? [];
+	const pendingPolls = options.pendingPolls ?? 0;
+	const startProbe = (probeOptions = {}) => {
+		probes.push({ settingSources: probeOptions.settingSources ?? [] });
+		const mcp = createFakeMcpState({
+			open: true,
+			connectors,
+			tauTools: () => [],
+			pendingPolls,
+			toggles: []
+		});
+		return {
+			...mcp.control,
+			contextSummary: async () => mcp.context(),
+			close: () => void 0
+		};
+	};
+	const sessionFor = (query) => query.resume && !query.forkSession ? query.resume : `fake-session-${++sessions}`;
+	const port = {
+		async authStatus() {
+			if (auth instanceof Error) throw auth;
+			return auth;
+		},
+		async accountInfo() {
+			return options.account ?? {
+				organization: "Fake Org",
+				subscriptionType: "Claude Team"
+			};
+		},
+		async supportedModels() {
+			return options.models ?? FAKE_CLAUDE_MODELS;
+		},
+		async bundledCliVersion() {
+			return options.bundledCliVersion ?? "0.0.0-fake";
+		},
+		startProbe,
+		startQuery(queryOptions) {
+			const record = {
+				options: queryOptions,
+				sessionId: sessionFor(queryOptions),
+				inputs: [],
+				folded: [],
+				toolCalls: [],
+				toolResults: [],
+				models: [],
+				flags: [],
+				interrupts: 0,
+				closed: false,
+				permissionRequests: [],
+				connectorCalls: [],
+				toggles: []
+			};
+			queries.push(record);
+			return createFakeQuery({
+				options: queryOptions,
+				record,
+				script: (turn, text, hasTools) => script(turn, text, hasTools),
+				ids,
+				apiKeySource: options.apiKeySource ?? "none",
+				connectors,
+				pendingPolls
+			});
+		},
+		async deleteSession(sessionId) {
+			deletedSessions.push(sessionId);
+		}
+	};
+	return {
+		port,
+		queries,
+		deletedSessions,
+		probes,
+		loadCount: () => loads,
+		async load() {
+			loads += 1;
+			return port;
+		},
+		setScript(next) {
+			script = next;
+		},
+		setAuth(next) {
+			auth = next;
+		}
+	};
+}
+//#endregion
+export { FAKE_LOGGED_IN, createFakeClaudeSdk };