@agentuity/coder 1.0.39 → 1.0.41

package/src/index.ts

@@ -18,6 +18,8 @@ import { AgentManagerOverlay } from './overlay.ts';
 import { ChainEditorOverlay, type ChainResult } from './chain-preview.ts';
 import { HubOverlay } from './hub-overlay.ts';
 import { OutputViewerOverlay, type StoredResult } from './output-viewer.ts';
+import { setNativeRemoteExtensionContext } from './native-remote-ui-context.ts';
+import { handleRemoteUiRequest } from './remote-ui-handler.ts';
 import type {
 	HubAction,
 	HubResponse,
@@ -280,6 +282,7 @@ export function agentuityCoderHub(pi: ExtensionAPI) {
 	// to an existing sandbox session. The full UI is set up (tools, commands, /hub)
 	// but user input is relayed to the remote sandbox instead of the local Pi agent.
 	const remoteSessionId = process.env[REMOTE_SESSION_ENV] || null;
+	const isNativeRemote = !!process.env[NATIVE_REMOTE_ENV];
 	if (remoteSessionId) {
 		log(`Remote mode: will connect as controller to session ${remoteSessionId}`);
 	}
@@ -573,7 +576,13 @@ export function agentuityCoderHub(pi: ExtensionAPI) {
 			// Server sends JSON Schema; TypeBox schemas are JSON Schema at runtime
 			parameters: toolDef.parameters as TSchema,
 			...(toolDef.promptSnippet ? { promptSnippet: toolDef.promptSnippet } : {}),
-			...(toolDef.promptGuidelines ? { promptGuidelines: toolDef.promptGuidelines } : {}),
+			...(toolDef.promptGuidelines
+				? {
+						promptGuidelines: Array.isArray(toolDef.promptGuidelines)
+							? toolDef.promptGuidelines
+							: [toolDef.promptGuidelines],
+					}
+				: {}),
 			async execute(
 				toolCallId: string,
 				params: unknown,
@@ -1347,8 +1356,11 @@ export function agentuityCoderHub(pi: ExtensionAPI) {
 
 	// session_start: establish WebSocket connection to Hub + set up footer
 	onEvent('session_start', async (event: unknown, ctx: ExtensionContext) => {
-		await ensureConnected();
 		footerCtx = ctx;
+		if (isNativeRemote && remoteSessionId) {
+			setNativeRemoteExtensionContext(ctx);
+		}
+		await ensureConnected();
 		if (ctx.hasUI) {
 			ctx.ui.setStatus('hub_connection', getHubUiStatus());
 		}
@@ -1424,8 +1436,6 @@ export function agentuityCoderHub(pi: ExtensionAPI) {
 	//      via Agent.emit(). Extension only provides Hub UI (footer, /hub, commands).
 	//      No pi.sendMessage() rendering, no setupRemoteMode() event handlers.
 	//   2. Legacy remote: Extension handles all rendering via pi.sendMessage({ customType }).
-	const isNativeRemote = !!process.env[NATIVE_REMOTE_ENV];
-
 	if (remoteSessionId) {
 		let remoteSession: RemoteSession | null = null;
 
@@ -1481,52 +1491,8 @@ export function agentuityCoderHub(pi: ExtensionAPI) {
 					});
 
 					remoteSession.setUiHandler(async (request) => {
-						if (!footerCtx?.hasUI) return null;
-						const ui = footerCtx.ui;
-						switch (request.method) {
-							case 'select': {
-								const options =
-									(request.params.options as Array<{ label: string; value: string }>) ??
-									[];
-								const title = (request.params.title as string) ?? 'Select';
-								const result = await ui.select(
-									title,
-									options.map((o) => o.label)
-								);
-								if (result === null || result === undefined) return null;
-								const idx = typeof result === 'number' ? result : Number(result);
-								return options[idx]?.value ?? null;
-							}
-							case 'confirm':
-								return await ui.confirm(
-									(request.params.message as string) ?? 'Confirm?',
-									(request.params.message as string) ?? 'Confirm?'
-								);
-							case 'input':
-								return await ui.input(
-									(request.params.prompt as string) ?? 'Input:',
-									(request.params.placeholder as string) ?? ''
-								);
-							case 'editor':
-								return await ui.editor(
-									(request.params.content as string) ?? '',
-									(request.params.language as string) ?? 'text'
-								);
-							case 'notify':
-								ui.notify((request.params.message as string) ?? '');
-								return undefined;
-							case 'setStatus':
-								ui.setStatus(
-									(request.params.key as string) ?? 'remote',
-									(request.params.text as string) ?? ''
-								);
-								return undefined;
-							case 'setTitle':
-								ui.setTitle((request.params.title as string) ?? '');
-								return undefined;
-							default:
-								return null;
-						}
+						if (!footerCtx) return null;
+						return await handleRemoteUiRequest(footerCtx, request);
 					});
 				} catch (err) {
 					const msg = err instanceof Error ? err.message : String(err);
@@ -1549,6 +1515,9 @@ export function agentuityCoderHub(pi: ExtensionAPI) {
 		'session_shutdown',
 		async (_event: unknown, _ctx: ExtensionContext) => {
 			log('Shutting down — closing Hub connection');
+			if (isNativeRemote && remoteSessionId) {
+				setNativeRemoteExtensionContext(null);
+			}
 			try {
 				client.close();
 			} catch {

package/src/native-remote-ui-context.ts

@@ -0,0 +1,41 @@
+import type { ExtensionContext } from '@mariozechner/pi-coding-agent';
+
+type ContextWaiter = (ctx: ExtensionContext | null) => void;
+
+let nativeRemoteExtensionContext: ExtensionContext | null = null;
+const waiters = new Set<ContextWaiter>();
+
+export function setNativeRemoteExtensionContext(ctx: ExtensionContext | null): void {
+	nativeRemoteExtensionContext = ctx;
+	for (const waiter of waiters) {
+		waiter(ctx);
+	}
+	waiters.clear();
+}
+
+export function getNativeRemoteExtensionContext(): ExtensionContext | null {
+	return nativeRemoteExtensionContext;
+}
+
+export function waitForNativeRemoteExtensionContext(
+	timeoutMs = 10_000
+): Promise<ExtensionContext | null> {
+	if (nativeRemoteExtensionContext) {
+		return Promise.resolve(nativeRemoteExtensionContext);
+	}
+
+	return new Promise((resolve) => {
+		const waiter: ContextWaiter = (ctx) => {
+			clearTimeout(timer);
+			waiters.delete(waiter);
+			resolve(ctx);
+		};
+
+		const timer = setTimeout(() => {
+			waiters.delete(waiter);
+			resolve(nativeRemoteExtensionContext);
+		}, timeoutMs);
+
+		waiters.add(waiter);
+	});
+}

package/src/protocol.ts

@@ -1,22 +1,80 @@
-// ---- Init Message (Server → Client on connect) ----
+// Hub protocol types used by the Coder TUI package.
+// Keep the legacy exported names stable while modeling the newer hub envelopes.
 
 export interface HubToolDefinition {
 	name: string;
 	label: string;
 	description: string;
-	parameters: Record<string, unknown>; // JSON Schema object
+	parameters: Record<string, unknown>;
 	promptSnippet?: string;
-	promptGuidelines?: string;
+	promptGuidelines?: string | string[];
 }
 
-/** Command definition sent by Hub for agent routing slash commands. */
 export interface HubCommandDefinition {
 	name: string;
 	description: string;
 }
 
+export interface AckAction {
+	action: 'ACK';
+}
+
+export interface BlockAction {
+	action: 'BLOCK';
+	reason: string;
+}
+
+export interface ConfirmAction {
+	action: 'CONFIRM';
+	title: string;
+	message: string;
+	deny_reason?: string;
+}
+
+export interface NotifyAction {
+	action: 'NOTIFY';
+	message: string;
+	level?: 'info' | 'warning' | 'error';
+}
+
+export interface ReturnAction {
+	action: 'RETURN';
+	result: unknown;
+}
+
+export interface StatusAction {
+	action: 'STATUS';
+	key: string;
+	text?: string;
+}
+
+export interface SystemPromptAction {
+	action: 'SYSTEM_PROMPT';
+	systemPrompt: string;
+	mode?: 'replace' | 'prefix' | 'suffix';
+}
+
+export interface InjectMessageAction {
+	action: 'INJECT_MESSAGE';
+	message: {
+		role: 'user' | 'assistant';
+		content: string;
+	};
+}
+
+export type HubAction =
+	| AckAction
+	| BlockAction
+	| ConfirmAction
+	| NotifyAction
+	| ReturnAction
+	| StatusAction
+	| SystemPromptAction
+	| InjectMessageAction;
+
 export interface AgentDefinition {
 	name: string;
+	displayName?: string;
 	description: string;
 	systemPrompt: string;
 	model?: string;
@@ -41,10 +99,14 @@ export interface InitMessage {
 	commands?: HubCommandDefinition[];
 	agents?: AgentDefinition[];
 	config?: HubConfig;
+	model?: {
+		provider: string;
+		id: string;
+	};
+	thinkingLevel?: string;
+	task?: string;
 }
 
-// ---- Request Messages (Client → Server) ----
-
 export interface EventRequest {
 	id: string;
 	type: 'event';
@@ -60,7 +122,6 @@ export interface ToolRequest {
 	params: Record<string, unknown>;
 }
 
-/** Command request (Client -> Server) for slash command execution. */
 export interface CommandRequest {
 	id: string;
 	type: 'command';
@@ -70,68 +131,228 @@ export interface CommandRequest {
 
 export type HubRequest = EventRequest | ToolRequest | CommandRequest;
 
-// ---- Actions ----
+export interface SessionEntryMessage {
+	type: 'session_entry';
+	path: string;
+	line: string;
+}
 
-export interface AckAction {
-	action: 'ACK';
+export interface SessionWriteMessage {
+	type: 'session_write';
+	path: string;
+	content: string;
 }
 
-export interface BlockAction {
-	action: 'BLOCK';
-	reason: string;
+export interface RpcCommandMessage {
+	type: 'rpc_command';
+	command: Record<string, unknown>;
 }
 
-export interface ConfirmAction {
-	action: 'CONFIRM';
-	title: string;
-	message: string;
-	deny_reason?: string;
+export interface RpcUiResponseMessage {
+	type: 'rpc_ui_response';
+	id: string;
+	result: unknown;
 }
 
-export interface NotifyAction {
-	action: 'NOTIFY';
+export interface PingMessage {
+	type: 'ping';
+	timestamp: number;
+}
+
+export type HubClientMessage =
+	| HubRequest
+	| SessionEntryMessage
+	| SessionWriteMessage
+	| RpcCommandMessage
+	| RpcUiResponseMessage
+	| PingMessage;
+
+export interface HubResponse {
+	id: string;
+	actions: HubAction[];
+}
+
+export interface CoderHubStreamReadyMessage {
+	type: 'session_stream_ready';
+	streamId: string;
+	streamUrl: string;
+}
+
+export interface CoderHubSessionResumeMessage {
+	type: 'session_resume';
+	streamUrl: string;
+	streamId: string;
+	activePrdKey?: string;
+}
+
+export interface ConnectionRejectedMessage {
+	type: 'connection_rejected';
+	code: string;
 	message: string;
-	level?: 'info' | 'warning' | 'error';
+	sessionId?: string;
+	reconnectState?: string;
+	expiredAt?: number;
+	timestamp: number;
 }
 
-export interface ReturnAction {
-	action: 'RETURN';
-	result: unknown;
+export interface ConversationEntry {
+	type:
+		| 'message'
+		| 'thinking'
+		| 'tool_call'
+		| 'tool_result'
+		| 'task_result'
+		| 'turn'
+		| 'user_prompt';
+	agent?: string;
+	content?: string;
+	toolName?: string;
+	toolArgs?: Record<string, unknown>;
+	toolCallId?: string;
+	isError?: boolean;
+	taskId?: string;
+	timestamp: number;
 }
 
-export interface StatusAction {
-	action: 'STATUS';
-	key: string;
-	text?: string; // undefined = clear status
+export interface HydrationTaskState {
+	taskId: string;
+	agent: string;
+	status: 'running' | 'completed' | 'failed';
+	prompt: string;
+	duration?: number;
+	result?: string;
+	error?: string;
 }
 
-export interface SystemPromptAction {
-	action: 'SYSTEM_PROMPT';
-	systemPrompt: string;
-	mode?: 'replace' | 'prefix' | 'suffix';
+export interface SessionParticipant {
+	id: string;
+	role: 'lead' | 'observer' | 'controller';
+	transport: 'ws' | 'sse';
+	subscriptions: string[];
+	connectedAt: number;
+	lastActivity: number;
 }
 
-export interface InjectMessageAction {
-	action: 'INJECT_MESSAGE';
-	message: {
-		role: 'user' | 'assistant';
-		content: string;
+export interface SessionStreamBlock {
+	output: string;
+	thinking: string;
+}
+
+export interface SessionStreamProjection extends SessionStreamBlock {
+	tasks: Record<string, SessionStreamBlock>;
+}
+
+export interface SessionSnapshot {
+	sessionId: string;
+	label: string;
+	status: 'active' | 'paused' | 'shutdown' | 'archived' | 'error' | 'stopped';
+	createdAt: string;
+	mode: 'sandbox' | 'tui';
+	task?: string;
+	error?: string;
+	streamId?: string | null;
+	streamUrl?: string | null;
+	context: {
+		branch?: string;
+		workingDirectory?: string;
 	};
+	participants: SessionParticipant[];
+	tasks: Array<{
+		taskId: string;
+		agent: string;
+		status: 'running' | 'completed' | 'failed';
+		prompt: string;
+		duration?: number;
+		startedAt?: string;
+		completedAt?: string;
+	}>;
+	agentActivity: Record<
+		string,
+		{
+			name?: string;
+			status: string;
+			currentTool?: string;
+			currentToolArgs?: string;
+			toolCallCount: number;
+			lastActivity: number;
+			totalElapsed?: number;
+		}
+	>;
+	stream?: SessionStreamProjection;
+	tags?: string[];
+	defaultAgent?: string;
+	bucket?: 'running' | 'paused' | 'provisioning' | 'history';
+	runtimeAvailable?: boolean;
+	controlAvailable?: boolean;
+	historyOnly?: boolean;
 }
 
-export type HubAction =
-	| AckAction
-	| BlockAction
-	| ConfirmAction
-	| NotifyAction
-	| ReturnAction
-	| StatusAction
-	| SystemPromptAction
-	| InjectMessageAction;
+export interface CoderHubHydrationMessage {
+	type: 'session_hydration';
+	sessionId: string;
+	resumedAt: number;
+	entries: ConversationEntry[];
+	tasks: HydrationTaskState[];
+	stream?: SessionStreamProjection;
+	task?: string;
+	streamingState?: {
+		isStreaming?: boolean;
+		activeTasks?: Array<{
+			taskId: string;
+			agent: string;
+		}>;
+	};
+}
 
-// ---- Progress Tracking (Sub-Agent → Parent) ----
+export interface PresenceEventMessage {
+	type: 'presence';
+	event: 'session_join' | 'session_leave' | 'presence_update';
+	participant?: SessionParticipant;
+	participants?: SessionParticipant[];
+	sessionId: string;
+	timestamp: number;
+}
+
+export interface BroadcastEventMessage {
+	type: 'broadcast';
+	event: string;
+	data: Record<string, unknown>;
+	category?: string;
+	sessionId?: string;
+	timestamp?: number;
+}
+
+export interface RpcEventMessage {
+	type: 'rpc_event';
+	event: Record<string, unknown>;
+	timestamp: number;
+}
+
+export interface RpcResponseMessage {
+	type: 'rpc_response';
+	response: Record<string, unknown>;
+}
+
+export interface RpcUiRequestMessage {
+	type: 'rpc_ui_request';
+	id: string;
+	method: string;
+	params: Record<string, unknown>;
+}
+
+export type ServerMessage =
+	| InitMessage
+	| HubResponse
+	| CoderHubHydrationMessage
+	| CoderHubStreamReadyMessage
+	| CoderHubSessionResumeMessage
+	| ConnectionRejectedMessage
+	| PresenceEventMessage
+	| BroadcastEventMessage
+	| RpcEventMessage
+	| RpcResponseMessage
+	| RpcUiRequestMessage;
 
-/** Progress update from a running sub-agent */
 export interface AgentProgressUpdate {
 	agentName: string;
 	status:
@@ -146,12 +367,5 @@ export interface AgentProgressUpdate {
 	currentToolArgs?: string;
 	elapsed: number;
 	tokens?: { input: number; output: number; cost: number };
-	delta?: string; // Streaming token delta for thinking_delta / text_delta
-}
-
-// ---- Response Message (Server → Client) ----
-
-export interface HubResponse {
-	id: string;
-	actions: HubAction[];
+	delta?: string;
 }