gsd-pi 2.46.0 → 2.46.1-dev.79664f2

package/src/resources/extensions/claude-code-cli/partial-builder.ts

@@ -0,0 +1,258 @@
+/**
+ * Content-block mapping helpers and streaming state tracker.
+ *
+ * Translates the Claude Agent SDK's `BetaRawMessageStreamEvent` sequence
+ * into GSD's `AssistantMessageEvent` deltas for incremental TUI rendering.
+ */
+
+import type {
+	AssistantMessage,
+	AssistantMessageEvent,
+	ServerToolUseContent,
+	StopReason,
+	TextContent,
+	ThinkingContent,
+	ToolCall,
+	Usage,
+	WebSearchResultContent,
+} from "@gsd/pi-ai";
+import type { BetaContentBlock, BetaRawMessageStreamEvent, NonNullableUsage } from "./sdk-types.js";
+
+// ---------------------------------------------------------------------------
+// Content-block mapping helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Convert a single BetaContentBlock to the corresponding GSD content type.
+ */
+export function mapContentBlock(
+	block: BetaContentBlock,
+): TextContent | ThinkingContent | ToolCall | ServerToolUseContent | WebSearchResultContent {
+	switch (block.type) {
+		case "text":
+			return { type: "text", text: block.text } satisfies TextContent;
+
+		case "thinking":
+			return {
+				type: "thinking",
+				thinking: block.thinking,
+				...(block.signature ? { thinkingSignature: block.signature } : {}),
+			} satisfies ThinkingContent;
+
+		case "tool_use":
+			return {
+				type: "toolCall",
+				id: block.id,
+				name: block.name,
+				arguments: block.input,
+			} satisfies ToolCall;
+
+		case "server_tool_use":
+			return {
+				type: "serverToolUse",
+				id: block.id,
+				name: block.name,
+				input: block.input,
+			} satisfies ServerToolUseContent;
+
+		case "web_search_tool_result":
+			return {
+				type: "webSearchResult",
+				toolUseId: block.tool_use_id,
+				content: block.content,
+			} satisfies WebSearchResultContent;
+
+		default: {
+			const unknown = block as Record<string, unknown>;
+			return { type: "text", text: `[unknown content block: ${JSON.stringify(unknown)}]` };
+		}
+	}
+}
+
+export function mapStopReason(reason: string | null): StopReason {
+	switch (reason) {
+		case "end_turn":
+		case "stop_sequence":
+			return "stop";
+		case "max_tokens":
+			return "length";
+		case "tool_use":
+			return "toolUse";
+		default:
+			return "stop";
+	}
+}
+
+/**
+ * Convert SDK usage + total_cost_usd into GSD's Usage shape.
+ *
+ * The SDK does not break cost down per-bucket, so all cost is
+ * attributed to `cost.total`.
+ */
+export function mapUsage(sdkUsage: NonNullableUsage, totalCostUsd: number): Usage {
+	return {
+		input: sdkUsage.input_tokens,
+		output: sdkUsage.output_tokens,
+		cacheRead: sdkUsage.cache_read_input_tokens,
+		cacheWrite: sdkUsage.cache_creation_input_tokens,
+		totalTokens:
+			sdkUsage.input_tokens +
+			sdkUsage.output_tokens +
+			sdkUsage.cache_read_input_tokens +
+			sdkUsage.cache_creation_input_tokens,
+		cost: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+			total: totalCostUsd,
+		},
+	};
+}
+
+// ---------------------------------------------------------------------------
+// Zero-cost usage constant
+// ---------------------------------------------------------------------------
+
+export const ZERO_USAGE: Usage = {
+	input: 0,
+	output: 0,
+	cacheRead: 0,
+	cacheWrite: 0,
+	totalTokens: 0,
+	cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+};
+
+// ---------------------------------------------------------------------------
+// Streaming partial-message state tracker
+// ---------------------------------------------------------------------------
+
+/**
+ * Mutable accumulator that tracks the partial AssistantMessage being built
+ * from a sequence of stream_event messages. Produces AssistantMessageEvent
+ * deltas that the TUI can render incrementally.
+ */
+export class PartialMessageBuilder {
+	private partial: AssistantMessage;
+	/** Map from stream-event `index` to our content array index. */
+	private indexMap = new Map<number, number>();
+	/** Accumulated JSON input string per tool_use block (keyed by stream index). */
+	private toolJsonAccum = new Map<number, string>();
+
+	constructor(model: string) {
+		this.partial = {
+			role: "assistant",
+			content: [],
+			api: "anthropic-messages",
+			provider: "claude-code",
+			model,
+			usage: { ...ZERO_USAGE },
+			stopReason: "stop",
+			timestamp: Date.now(),
+		};
+	}
+
+	get message(): AssistantMessage {
+		return this.partial;
+	}
+
+	/**
+	 * Feed a BetaRawMessageStreamEvent and return the corresponding
+	 * AssistantMessageEvent (or null if the event is not mapped).
+	 */
+	handleEvent(event: BetaRawMessageStreamEvent): AssistantMessageEvent | null {
+		const streamIndex = event.index ?? 0;
+
+		switch (event.type) {
+			// ---- Block start ----
+			case "content_block_start": {
+				const block = event.content_block;
+				if (!block) return null;
+
+				const contentIndex = this.partial.content.length;
+				this.indexMap.set(streamIndex, contentIndex);
+
+				if (block.type === "text") {
+					this.partial.content.push({ type: "text", text: "" });
+					return { type: "text_start", contentIndex, partial: this.partial };
+				}
+				if (block.type === "thinking") {
+					this.partial.content.push({ type: "thinking", thinking: "" });
+					return { type: "thinking_start", contentIndex, partial: this.partial };
+				}
+				if (block.type === "tool_use") {
+					this.toolJsonAccum.set(streamIndex, "");
+					this.partial.content.push({
+						type: "toolCall",
+						id: block.id,
+						name: block.name,
+						arguments: {},
+					});
+					return { type: "toolcall_start", contentIndex, partial: this.partial };
+				}
+				if (block.type === "server_tool_use") {
+					this.partial.content.push({
+						type: "serverToolUse",
+						id: block.id,
+						name: block.name,
+						input: block.input,
+					});
+					return { type: "server_tool_use", contentIndex, partial: this.partial };
+				}
+				return null;
+			}
+
+			// ---- Block delta ----
+			case "content_block_delta": {
+				const contentIndex = this.indexMap.get(streamIndex);
+				if (contentIndex === undefined) return null;
+				const delta = event.delta;
+				if (!delta) return null;
+
+				if (delta.type === "text_delta" && typeof delta.text === "string") {
+					const existing = this.partial.content[contentIndex] as TextContent;
+					existing.text += delta.text;
+					return { type: "text_delta", contentIndex, delta: delta.text, partial: this.partial };
+				}
+				if (delta.type === "thinking_delta" && typeof delta.thinking === "string") {
+					const existing = this.partial.content[contentIndex] as ThinkingContent;
+					existing.thinking += delta.thinking;
+					return { type: "thinking_delta", contentIndex, delta: delta.thinking, partial: this.partial };
+				}
+				if (delta.type === "input_json_delta" && typeof delta.partial_json === "string") {
+					const accum = (this.toolJsonAccum.get(streamIndex) ?? "") + delta.partial_json;
+					this.toolJsonAccum.set(streamIndex, accum);
+					return { type: "toolcall_delta", contentIndex, delta: delta.partial_json, partial: this.partial };
+				}
+				return null;
+			}
+
+			// ---- Block stop ----
+			case "content_block_stop": {
+				const contentIndex = this.indexMap.get(streamIndex);
+				if (contentIndex === undefined) return null;
+				const block = this.partial.content[contentIndex];
+
+				if (block.type === "text") {
+					return { type: "text_end", contentIndex, content: block.text, partial: this.partial };
+				}
+				if (block.type === "thinking") {
+					return { type: "thinking_end", contentIndex, content: block.thinking, partial: this.partial };
+				}
+				if (block.type === "toolCall") {
+					const jsonStr = this.toolJsonAccum.get(streamIndex) ?? "{}";
+					try {
+						block.arguments = JSON.parse(jsonStr);
+					} catch {
+						block.arguments = { _raw: jsonStr };
+					}
+					return { type: "toolcall_end", contentIndex, toolCall: block, partial: this.partial };
+				}
+				return null;
+			}
+
+			default:
+				return null;
+		}
+	}
+}

package/src/resources/extensions/claude-code-cli/readiness.ts

@@ -0,0 +1,30 @@
+/**
+ * Readiness check for the Claude Code CLI provider.
+ *
+ * Verifies the `claude` binary is installed and responsive.
+ * Result is cached for 30 seconds to avoid shelling out on every
+ * model-availability check.
+ */
+
+import { execSync } from "node:child_process";
+
+let cachedReady: boolean | null = null;
+let lastCheckMs = 0;
+const CHECK_INTERVAL_MS = 30_000;
+
+export function isClaudeCodeReady(): boolean {
+	const now = Date.now();
+	if (cachedReady !== null && now - lastCheckMs < CHECK_INTERVAL_MS) {
+		return cachedReady;
+	}
+
+	try {
+		execSync("claude --version", { timeout: 5_000, stdio: "pipe" });
+		cachedReady = true;
+	} catch {
+		cachedReady = false;
+	}
+
+	lastCheckMs = now;
+	return cachedReady;
+}

package/src/resources/extensions/claude-code-cli/sdk-types.ts

@@ -0,0 +1,149 @@
+/**
+ * Lightweight type mirrors for the Claude Agent SDK.
+ *
+ * These stubs allow the extension to compile without a hard dependency on
+ * `@anthropic-ai/claude-agent-sdk`. The real SDK is imported dynamically
+ * at runtime in stream-adapter.ts.
+ */
+
+/** UUID branded string from the SDK. */
+export type UUID = string;
+
+/** BetaMessage from the Anthropic SDK, as wrapped by SDKAssistantMessage. */
+export interface BetaMessage {
+	id: string;
+	type: "message";
+	role: "assistant";
+	content: BetaContentBlock[];
+	model: string;
+	stop_reason: "end_turn" | "max_tokens" | "stop_sequence" | "tool_use" | null;
+	usage: { input_tokens: number; output_tokens: number };
+}
+
+export type BetaContentBlock =
+	| { type: "text"; text: string }
+	| { type: "thinking"; thinking: string; signature?: string }
+	| { type: "tool_use"; id: string; name: string; input: Record<string, unknown> }
+	| { type: "server_tool_use"; id: string; name: string; input: unknown }
+	| { type: "web_search_tool_result"; tool_use_id: string; content: unknown };
+
+/** Streaming event emitted when includePartialMessages is true. */
+export interface BetaRawMessageStreamEvent {
+	type: string;
+	index?: number;
+	content_block?: BetaContentBlock;
+	delta?: Record<string, unknown>;
+}
+
+export interface SDKAssistantMessage {
+	type: "assistant";
+	uuid: UUID;
+	session_id: string;
+	message: BetaMessage;
+	parent_tool_use_id: string | null;
+	error?: { type: string; message: string };
+}
+
+export interface SDKUserMessage {
+	type: "user";
+	uuid?: UUID;
+	session_id: string;
+	message: unknown;
+	parent_tool_use_id: string | null;
+	isSynthetic?: boolean;
+	tool_use_result?: unknown;
+}
+
+export interface SDKSystemMessage {
+	type: "system";
+	subtype: "init";
+	[key: string]: unknown;
+}
+
+export interface SDKStatusMessage {
+	type: "system";
+	subtype: "status";
+	status: "compacting" | null;
+	uuid: UUID;
+	session_id: string;
+}
+
+export interface SDKPartialAssistantMessage {
+	type: "stream_event";
+	event: BetaRawMessageStreamEvent;
+	parent_tool_use_id: string | null;
+	uuid: UUID;
+	session_id: string;
+}
+
+export interface SDKToolProgressMessage {
+	type: "tool_progress";
+	tool_use_id: string;
+	tool_name: string;
+	parent_tool_use_id: string | null;
+	elapsed_time_seconds: number;
+	task_id?: string;
+	uuid: UUID;
+	session_id: string;
+}
+
+export interface NonNullableUsage {
+	input_tokens: number;
+	output_tokens: number;
+	cache_read_input_tokens: number;
+	cache_creation_input_tokens: number;
+}
+
+export type SDKResultMessage =
+	| {
+			type: "result";
+			subtype: "success";
+			uuid: UUID;
+			session_id: string;
+			duration_ms: number;
+			duration_api_ms: number;
+			is_error: boolean;
+			num_turns: number;
+			result: string;
+			stop_reason: string | null;
+			total_cost_usd: number;
+			usage: NonNullableUsage;
+	  }
+	| {
+			type: "result";
+			subtype:
+				| "error_max_turns"
+				| "error_during_execution"
+				| "error_max_budget_usd"
+				| "error_max_structured_output_retries";
+			uuid: UUID;
+			session_id: string;
+			duration_ms: number;
+			duration_api_ms: number;
+			is_error: boolean;
+			num_turns: number;
+			stop_reason: string | null;
+			total_cost_usd: number;
+			usage: NonNullableUsage;
+			errors: string[];
+	  };
+
+/** Catch-all for SDK message types we don't map. */
+export interface SDKOtherMessage {
+	type: string;
+	[key: string]: unknown;
+}
+
+/**
+ * Union of all SDK message types this extension handles.
+ * Mirrors the real `SDKMessage` from `@anthropic-ai/claude-agent-sdk`.
+ */
+export type SDKMessage =
+	| SDKAssistantMessage
+	| SDKUserMessage
+	| SDKResultMessage
+	| SDKSystemMessage
+	| SDKStatusMessage
+	| SDKPartialAssistantMessage
+	| SDKToolProgressMessage
+	| SDKOtherMessage;