@myrialabs/clopen 0.1.1 → 0.1.3

package/backend/index.ts

@@ -81,7 +81,10 @@ if (!isDevelopment) {
 			if (filePath.startsWith(distDir)) {
 				try {
 					if (statSync(filePath).isFile()) {
-						return new Response(Bun.file(filePath));
+						const file = Bun.file(filePath);
+						return new Response(file, {
+							headers: { 'Content-Type': file.type || 'application/octet-stream' }
+						});
 					}
 				} catch {}
 			}

package/backend/lib/engine/adapters/opencode/message-converter.ts

@@ -127,6 +127,8 @@ const TOOL_NAME_MAP: Record<string, string> = {
 	'todo_write': 'TodoWrite',
 	'todowrite': 'TodoWrite',
 	'todoread': 'TodoWrite',
+	// Agent / sub-agent
+	'task': 'Agent',
 	// User interaction
 	'question': 'AskUserQuestion',
 	// Code intelligence & utilities
@@ -385,6 +387,7 @@ interface AssistantMessageParams {
 	sessionId: string;
 	stopReason: string | null;
 	uuid: string;
+	parentToolUseId?: string | null;
 }
 
 /** Build a single SDKAssistantMessage from content blocks */
@@ -402,7 +405,7 @@ function buildAssistantSDKMessage(params: AssistantMessageParams): SDKMessage {
 			...(params.usage && { usage: params.usage }),
 			context_management: null
 		},
-		parent_tool_use_id: null,
+		parent_tool_use_id: params.parentToolUseId ?? null,
 		session_id: params.sessionId,
 		uuid: params.uuid
 	} as unknown as SDKMessage;
@@ -495,6 +498,20 @@ export function convertAssistantMessages(
 
 			allBlocks.push(block);
 		}
+		else if (part.type === 'subtask') {
+			// Subtask = Agent/sub-agent invocation
+			const subtaskPart = part as any;
+			allBlocks.push({
+				type: 'tool_use',
+				id: subtaskPart.id || crypto.randomUUID(),
+				name: 'Agent',
+				input: {
+					prompt: subtaskPart.prompt || '',
+					description: subtaskPart.description || '',
+					subagent_type: subtaskPart.agent || 'general-purpose',
+				} as NormalizedToolInput,
+			});
+		}
 		// Skip: reasoning, step-start, step-finish, snapshot, patch, agent, retry, compaction
 	}
 
@@ -682,6 +699,7 @@ export function convertToolUseOnly(
 	toolPart: ToolPart,
 	ocMessage: OCMessage,
 	sessionId: string,
+	parentToolUseId: string | null = null,
 ): SDKMessage {
 	const claudeName = mapToolName(toolPart.tool || 'unknown');
 	const resolvedInput = getToolInput(toolPart);
@@ -703,6 +721,7 @@ export function convertToolUseOnly(
 		sessionId,
 		stopReason: 'tool_use',
 		uuid: crypto.randomUUID(),
+		parentToolUseId,
 	});
 }
 
@@ -783,6 +802,37 @@ export function convertReasoningStreamStop(sessionId: string): EngineSDKMessage
 	} as unknown as EngineSDKMessage;
 }
 
+/**
+ * Convert a subtask part → assistant message with Agent tool_use.
+ * Used for progressive rendering when OpenCode emits subtask parts.
+ */
+export function convertSubtaskToolUseOnly(
+	subtaskPart: { id: string; prompt: string; description: string; agent: string },
+	ocMessage: OCMessage,
+	sessionId: string,
+): SDKMessage {
+	const assistantMsg = ocMessage.role === 'assistant' ? ocMessage as AssistantMessage : null;
+	const modelId = assistantMsg ? `${assistantMsg.providerID}/${assistantMsg.modelID}` : '';
+
+	return buildAssistantSDKMessage({
+		content: [{
+			type: 'tool_use',
+			id: subtaskPart.id || crypto.randomUUID(),
+			name: 'Agent',
+			input: {
+				prompt: subtaskPart.prompt || '',
+				description: subtaskPart.description || '',
+				subagent_type: subtaskPart.agent || 'general-purpose',
+			} as NormalizedToolInput,
+		}],
+		ocMessage,
+		modelId,
+		sessionId,
+		stopReason: 'tool_use',
+		uuid: crypto.randomUUID(),
+	});
+}
+
 /**
  * Convert a completed/errored tool part → user message with tool_result.
  * Sent after the tool finishes executing, matching Claude Code's pattern
@@ -791,6 +841,7 @@ export function convertReasoningStreamStop(sessionId: string): EngineSDKMessage
 export function convertToolResultOnly(
 	toolPart: ToolPart,
 	sessionId: string,
+	parentToolUseId: string | null = null,
 ): SDKMessage {
 	const toolUseId = toolPart.callID || toolPart.id || crypto.randomUUID();
 
@@ -807,7 +858,7 @@ export function convertToolResultOnly(
 		type: 'user',
 		uuid: crypto.randomUUID(),
 		session_id: sessionId,
-		parent_tool_use_id: null,
+		parent_tool_use_id: parentToolUseId,
 		message: {
 			role: 'user',
 			content: [{

package/backend/lib/engine/adapters/opencode/stream.ts

@@ -37,6 +37,7 @@ import {
 	convertPartialReasoningDelta,
 	convertReasoningStreamStart,
 	convertReasoningStreamStop,
+	convertSubtaskToolUseOnly,
 	getToolInput,
 } from './message-converter';
 import { ensureClient, getClient } from './server';
@@ -236,6 +237,13 @@ export class OpenCodeEngine implements AIEngine {
 			let reasoningStreamActive = false; // Whether reasoning is currently streaming
 			let reasoningText = ''; // Accumulated reasoning text
 
+			// Child session tracking (for Agent tool sub-messages)
+			const childSessionToAgentTool = new Map<string, string>(); // child sessionID → agent tool callID
+			const childAssistantMessages = new Map<string, OCMessage>(); // child msgID → message
+			const childEmittedToolParts = new Set<string>();
+			const childCompletedToolParts = new Set<string>();
+			let lastAgentToolCallId: string | null = null;
+
 			/**
 			 * Flush active reasoning stream: stop reasoning stream, emit final reasoning message.
 			 */
@@ -266,9 +274,10 @@ export class OpenCodeEngine implements AIEngine {
 				yield convertStreamStop(sessionId);
 
 				const parts = messageParts.get(msgId) || [];
-				// Filter out tool parts and reasoning parts already emitted
+				// Filter out tool parts, subtask parts, and reasoning parts already emitted
 				const remainingParts = parts.filter(p => {
 					if (p.type === 'tool') return !emittedToolParts.has(p.id);
+					if (p.type === 'subtask') return !emittedToolParts.has(p.id);
 					if (p.type === 'reasoning') return false; // Already emitted as reasoning message
 					return true;
 				});
@@ -312,6 +321,15 @@ export class OpenCodeEngine implements AIEngine {
 								}
 								currentAssistantId = info.id;
 							}
+
+							// Track child session assistant messages (for Agent tool sub-messages)
+							if (info.role === 'assistant' && info.sessionID !== sessionId && lastAgentToolCallId) {
+								if (!childSessionToAgentTool.has(info.sessionID)) {
+									childSessionToAgentTool.set(info.sessionID, lastAgentToolCallId);
+									debug.log('engine', `[OC] child session detected: ${info.sessionID} → agent tool ${lastAgentToolCallId}`);
+								}
+								childAssistantMessages.set(info.id, info);
+							}
 							break;
 						}
 
@@ -321,8 +339,36 @@ export class OpenCodeEngine implements AIEngine {
 
 							debug.log('engine', `[OC] part.updated: type=${part.type}, partId=${part.id}, msgId=${part.messageID}, session=${part.sessionID === sessionId ? 'match' : 'skip'}`);
 
-							// Only process parts belonging to our session
-							if (part.sessionID !== sessionId) break;
+							// Handle child session parts (sub-agent tool activities)
+							if (part.sessionID !== sessionId) {
+								const agentCallId = childSessionToAgentTool.get(part.sessionID);
+								if (agentCallId && childAssistantMessages.has(part.messageID)) {
+									const childMsg = childAssistantMessages.get(part.messageID)!;
+
+									if (part.type === 'tool') {
+										const childToolPart = part as ToolPart;
+										if (!childEmittedToolParts.has(part.id)) {
+											const resolvedInput = getToolInput(childToolPart);
+											const hasInput = Object.keys(resolvedInput).length > 0
+												|| childToolPart.state.status !== 'pending';
+											if (hasInput) {
+												childEmittedToolParts.add(part.id);
+												yield convertToolUseOnly(childToolPart, childMsg, sessionId, agentCallId);
+												if (childToolPart.state.status === 'completed' || childToolPart.state.status === 'error') {
+													childCompletedToolParts.add(part.id);
+													yield convertToolResultOnly(childToolPart, sessionId, agentCallId);
+												}
+											}
+										} else if (!childCompletedToolParts.has(part.id)) {
+											if (childToolPart.state.status === 'completed' || childToolPart.state.status === 'error') {
+												childCompletedToolParts.add(part.id);
+												yield convertToolResultOnly(childToolPart, sessionId, agentCallId);
+											}
+										}
+									}
+								}
+								break;
+							}
 
 							// Only process parts for tracked assistant messages (skip user message parts)
 							if (!assistantMessages.has(part.messageID)) {
@@ -364,6 +410,11 @@ export class OpenCodeEngine implements AIEngine {
 									if (hasInput) {
 										emittedToolParts.add(part.id);
 
+										// Track agent tool callID for child session linking
+										if (toolPart.tool === 'task') {
+											lastAgentToolCallId = toolPart.callID || toolPart.id;
+										}
+
 										yield convertStreamStop(sessionId);
 										yield convertToolUseOnly(toolPart, msg, sessionId);
 
@@ -412,6 +463,25 @@ export class OpenCodeEngine implements AIEngine {
 								}
 							}
 
+							// Handle subtask parts — convert to Agent tool_use for progressive rendering
+							if (part.type === 'subtask') {
+								const subtaskPart = part as any;
+								const msg = assistantMessages.get(msgId);
+								if (msg && !emittedToolParts.has(part.id)) {
+									emittedToolParts.add(part.id);
+									// Track for child session linking
+									lastAgentToolCallId = part.id;
+									if (reasoningStreamActive) {
+										yield* flushReasoning(msg);
+									}
+									yield convertStreamStop(sessionId);
+									yield convertSubtaskToolUseOnly(subtaskPart, msg, sessionId);
+									yield convertStreamStart(sessionId);
+									streamingText = '';
+								}
+								break;
+							}
+
 							// Skip non-text/non-reasoning parts (step-start, step-finish, etc.)
 							if (part.type !== 'text') {
 								debug.log('engine', `[OC] part.updated: skipped non-text type=${part.type}`);
@@ -455,6 +525,12 @@ export class OpenCodeEngine implements AIEngine {
 						}
 
 						case 'session.idle': {
+							// Only handle idle for our session (sub-agent sessions have different IDs)
+							const idleProps = (event as EventSessionIdle).properties;
+							if (idleProps.sessionID !== sessionId) {
+								debug.log('engine', `[OC] session.idle: ignored (session=${idleProps.sessionID}, ours=${sessionId})`);
+								break;
+							}
 							// Session finished — flush reasoning and emit the last assistant message
 							if (currentAssistantId && !emittedMessageIds.has(currentAssistantId)) {
 								const msg = assistantMessages.get(currentAssistantId);
@@ -468,6 +544,7 @@ export class OpenCodeEngine implements AIEngine {
 									// Filter out tool parts and reasoning parts already emitted
 									const remainingParts = parts.filter(p => {
 										if (p.type === 'tool') return !emittedToolParts.has(p.id);
+										if (p.type === 'subtask') return !emittedToolParts.has(p.id);
 										if (p.type === 'reasoning') return false;
 										return true;
 									});
@@ -495,7 +572,10 @@ export class OpenCodeEngine implements AIEngine {
 						}
 
 						case 'session.status': {
-							const { status } = (event as EventSessionStatus).properties;
+							const statusProps = (event as EventSessionStatus).properties;
+							// Only handle status for our session (sub-agent sessions have different IDs)
+							if (statusProps.sessionID !== sessionId) break;
+							const { status } = statusProps;
 							if (status.type === 'idle') {
 								// Same as session.idle
 								if (currentAssistantId && !emittedMessageIds.has(currentAssistantId)) {
@@ -508,6 +588,7 @@ export class OpenCodeEngine implements AIEngine {
 										const parts = messageParts.get(currentAssistantId) || [];
 										const remainingParts = parts.filter(p => {
 											if (p.type === 'tool') return !emittedToolParts.has(p.id);
+											if (p.type === 'subtask') return !emittedToolParts.has(p.id);
 											if (p.type === 'reasoning') return false;
 											return true;
 										});
@@ -584,7 +665,10 @@ export class OpenCodeEngine implements AIEngine {
 						}
 
 						case 'session.error': {
-							const { error } = (event as EventSessionError).properties;
+							const errorProps = (event as EventSessionError).properties;
+							// Only handle errors for our session (sessionID is optional on errors)
+							if (errorProps.sessionID && errorProps.sessionID !== sessionId) break;
+							const { error } = errorProps;
 							// Extract a human-readable error message.
 							// OpenCode SDK errors follow: { name: string, data: { message, statusCode?, providerID?, responseBody? } }
 							// Don't prepend error class names (e.g. "APIError") — those are SDK