Add support to sending messages for created tasks

Author: EhabY

packages/tasks/src/components/TaskMessageInput.tsx

@@ -6,33 +6,57 @@ import { useTasksApi } from "../hooks/useTasksApi";
 
 import { PromptInput } from "./PromptInput";
 
-function getPlaceholder(task: Task): string {
-	if (task.status === "error" || task.current_state?.state === "failed") {
-		return "Send a message to retry or give new instructions...";
-	}
-	if (task.status === "paused") {
-		return "Send a message to resume the task...";
-	}
-	if (task.status === "pending" || task.status === "initializing") {
-		return "Waiting for the agent to start...";
-	}
-	if (task.current_state?.state === "working") {
-		return "Agent is working — you can pause or wait for it to finish...";
-	}
-	if (task.current_state?.state === "complete") {
-		return "Task completed — send a follow-up message to continue...";
-	}
-	return "Send a message to the agent...";
+interface InputState {
+	placeholder: string;
+	canSend: boolean;
 }
 
-function isInputEnabled(task: Task): boolean {
+function getInputState(task: Task): InputState {
 	const state = task.current_state?.state;
-	return (
-		state === "idle" ||
-		state === "complete" ||
-		state === "failed" ||
-		task.status === "paused"
-	);
+
+	switch (task.status) {
+		case "paused":
+			return {
+				placeholder: "Send a message to resume the task...",
+				canSend: true,
+			};
+		case "initializing":
+		case "pending":
+			return {
+				placeholder: "Waiting for the agent to start...",
+				canSend: false,
+			};
+		case "active":
+			switch (state) {
+				case "working":
+					return {
+						placeholder:
+							"Agent is working — you can pause or wait for it to finish...",
+						canSend: false,
+					};
+				case "complete":
+					return {
+						placeholder: "Task completed — send a follow-up to continue...",
+						canSend: true,
+					};
+				case "failed":
+					return {
+						placeholder: "Task failed — send a message to retry...",
+						canSend: true,
+					};
+				default:
+					return {
+						placeholder: "Send a message to the agent...",
+						canSend: true,
+					};
+			}
+		case "error":
+		case "unknown":
+			return {
+				placeholder: "Task is in an error state and cannot receive messages",
+				canSend: false,
+			};
+	}
 }
 
 interface TaskMessageInputProps {
@@ -44,35 +68,32 @@ export function TaskMessageInput({ task }: TaskMessageInputProps) {
 	const [message, setMessage] = useState("");
 
 	const { canPause } = getTaskPermissions(task);
-	const inputEnabled = isInputEnabled(task);
+	const { placeholder, canSend } = getInputState(task);
 	const showPauseButton = task.current_state?.state === "working" && canPause;
 
-	const { mutate: sendMessage, isPending: isSending } = useMutation({
-		mutationFn: (msg: string) => api.sendTaskMessage(task.id, msg),
-		onSuccess: () => setMessage(""),
-	});
-
 	const { mutate: pauseTask, isPending: isPausing } = useMutation({
 		mutationFn: () =>
 			api.pauseTask({ taskId: task.id, taskName: getTaskLabel(task) }),
 	});
 
-	const handleSend = () => {
-		if (!message.trim() || !inputEnabled || isSending) return;
-		sendMessage(message.trim());
-	};
+	const { mutate: sendMessage, isPending: isSending } = useMutation({
+		mutationFn: () => api.sendTaskMessage(task.id, message),
+		onSuccess: () => setMessage(""),
+	});
+
+	const canSubmitMessage = canSend && message.trim().length > 0;
 
 	return (
 		<PromptInput
-			placeholder={getPlaceholder(task)}
+			placeholder={placeholder}
 			value={message}
 			onChange={setMessage}
-			onSubmit={showPauseButton ? pauseTask : handleSend}
-			disabled={!inputEnabled}
+			onSubmit={showPauseButton ? pauseTask : sendMessage}
+			disabled={!canSend && !showPauseButton}
 			loading={showPauseButton ? isPausing : isSending}
 			actionIcon={showPauseButton ? "debug-pause" : "send"}
 			actionLabel={showPauseButton ? "Pause task" : "Send message"}
-			actionDisabled={!showPauseButton && (!inputEnabled || !message.trim())}
+			actionDisabled={showPauseButton ? false : !canSubmitMessage}
 		/>
 	);
 }

src/api/coderApi.ts

@@ -200,6 +200,16 @@ export class CoderApi extends Api implements vscode.Disposable {
 		return response.data.logs ?? [];
 	};
 
+	sendTaskInput = async (
+		user: string,
+		taskId: string,
+		input: string,
+	): Promise<void> => {
+		await this.getAxiosInstance().post(`/api/v2/tasks/${user}/${taskId}/send`, {
+			input,
+		});
+	};
+
 	watchInboxNotifications = async (
 		watchTemplates: string[],
 		watchTargets: string[],

src/webviews/tasks/tasksPanel.ts

@@ -74,6 +74,7 @@ export class TasksPanel
 		TasksApi.resumeTask.method,
 		TasksApi.deleteTask.method,
 		TasksApi.downloadLogs.method,
+		TasksApi.sendTaskMessage.method,
 	]);
 
 	private view?: vscode.WebviewView;
@@ -337,7 +338,7 @@ export class TasksPanel
 
 		await this.client.stopWorkspace(task.workspace_id);
 
-		await this.refreshAndNotifyTasks();
+		await this.refreshAndNotifyTask(taskId);
 		vscode.window.showInformationMessage(`Task "${taskName}" paused`);
 	}
 
@@ -355,10 +356,44 @@ export class TasksPanel
 			task.template_version_id,
 		);
 
-		await this.refreshAndNotifyTasks();
+		await this.refreshAndNotifyTask(taskId);
 		vscode.window.showInformationMessage(`Task "${taskName}" resumed`);
 	}
 
+	private async handleSendMessage(
+		taskId: string,
+		message: string,
+	): Promise<void> {
+		const task = await this.client.getTask("me", taskId);
+
+		if (task.status === "paused") {
+			if (!task.workspace_id) {
+				throw new Error("Task has no workspace");
+			}
+			await this.client.startWorkspace(
+				task.workspace_id,
+				task.template_version_id,
+			);
+		}
+
+		try {
+			await this.client.sendTaskInput("me", taskId, message);
+		} catch (err) {
+			if (
+				isAxiosError(err) &&
+				(err.response?.status === 409 || err.response?.status === 400)
+			) {
+				throw new Error("Task is not ready to receive messages");
+			}
+			throw err;
+		}
+
+		await this.refreshAndNotifyTask(taskId);
+		vscode.window.showInformationMessage(
+			`Message sent to "${getTaskLabel(task)}"`,
+		);
+	}
+
 	private async handleViewInCoder(taskId: string): Promise<void> {
 		const baseUrl = this.client.getHost();
 		if (!baseUrl) return;
@@ -409,18 +444,6 @@ export class TasksPanel
 		}
 	}
 
-	/**
-	 * Placeholder handler for sending follow-up messages to a task.
-	 * The Coder API does not yet support this feature.
-	 */
-	private handleSendMessage(taskId: string, message: string): Promise<void> {
-		this.logger.info(`Sending message to task ${taskId}: ${message}`);
-		vscode.window.showInformationMessage(
-			"Follow-up messages are not yet supported by the API",
-		);
-		return Promise.resolve();
-	}
-
 	private async fetchTasksWithStatus(): Promise<{
 		tasks: readonly Task[];
 		supported: boolean;
@@ -452,6 +475,18 @@ export class TasksPanel
 		}
 	}
 
+	private async refreshAndNotifyTask(taskId: string): Promise<void> {
+		try {
+			const task = await this.client.getTask("me", taskId);
+			this.sendNotification({
+				type: TasksApi.taskUpdated.method,
+				data: task,
+			});
+		} catch (err) {
+			this.logger.warn("Failed to refresh task after action", err);
+		}
+	}
+
 	private async fetchTemplates(): Promise<TaskTemplate[]> {
 		if (!this.client.getHost()) {
 			return [];
@@ -529,10 +564,7 @@ export class TasksPanel
 			const logs = await this.client.getTaskLogs("me", taskId);
 			return { logs, status: "ok" };
 		} catch (err) {
-			if (
-				isAxiosError(err) &&
-				(err.response?.status === 400 || err.response?.status === 409)
-			) {
+			if (isAxiosError(err) && err.response?.status === 409) {
 				return { logs: [], status: "not_available" };
 			}
 			this.logger.warn("Failed to fetch task logs", err);