Auto-generate useTasksApi from TasksApi at runtime

Add buildApiHook and ApiHook<Api> to protocol.ts so that useTasksApi
can be derived from the TasksApi definition object with zero manual sync.

- Add ApiHook<Api> mapped type that derives request, command, and
  notification subscription signatures from an API definition
- Add buildApiHook() that iterates API entries by kind at runtime,
  dispatching to ipc.request/command/onNotification
- Replace ~60 lines of manual method listings in useTasksApi with a
  single buildApiHook(TasksApi, useIpc()) call
- Update 5 consumer call sites from positional args to params objects
- Inline intermediate const declarations in api.ts into TasksApi object
- Remove unused ParamsOf and ResponseOf utility types

Author: EhabY

packages/shared/src/ipc/protocol.ts

@@ -76,16 +76,6 @@ export interface IpcNotification<D = unknown> {
 	readonly data?: D;
 }
 
-// --- Handler utilities ---
-
-/** Extract params type from a request/command definition */
-export type ParamsOf<T> = T extends { _types?: { params: infer P } } ? P : void;
-
-/** Extract response type from a request definition */
-export type ResponseOf<T> = T extends { _types?: { response: infer R } }
-	? R
-	: void;
-
 // --- Mapped types for handler completeness ---
 
 /** Requires a handler for every RequestDef in Api. Compile error if one is missing. */
@@ -106,6 +96,31 @@ export type CommandHandlerMap<Api> = {
 		: never;
 };
 
+// --- API hook type ---
+
+/** Derives a fully typed hook interface from an API definition object. */
+export type ApiHook<Api> = {
+	[K in keyof Api as Api[K] extends { kind: "request" }
+		? K
+		: never]: Api[K] extends RequestDef<infer P, infer R>
+		? (...args: P extends void ? [] : [params: P]) => Promise<R>
+		: never;
+} & {
+	[K in keyof Api as Api[K] extends { kind: "command" }
+		? K
+		: never]: Api[K] extends CommandDef<infer P>
+		? (...args: P extends void ? [] : [params: P]) => void
+		: never;
+} & {
+	[K in keyof Api as Api[K] extends { kind: "notification" }
+		? `on${Capitalize<K & string>}`
+		: never]: Api[K] extends NotificationDef<infer D>
+		? D extends void
+			? (cb: () => void) => () => void
+			: (cb: (data: D) => void) => () => void
+		: never;
+};
+
 // --- Builder functions ---
 
 /** Build a method-indexed map of request handlers with compile-time completeness. */
@@ -143,3 +158,53 @@ export function buildCommandHandlers(
 	}
 	return result;
 }
+
+/** Build a typed API hook from an API definition and IPC primitives. */
+export function buildApiHook<
+	Api extends Record<string, { kind: string; method: string }>,
+>(
+	api: Api,
+	ipc: {
+		request: <P, R>(
+			def: { method: string; _types?: { params: P; response: R } },
+			...args: P extends void ? [] : [params: P]
+		) => Promise<R>;
+		command: <P>(
+			def: { method: string; _types?: { params: P } },
+			...args: P extends void ? [] : [params: P]
+		) => void;
+		onNotification: <D>(
+			def: { method: string; _types?: { data: D } },
+			cb: (data: D) => void,
+		) => () => void;
+	},
+): ApiHook<Api>;
+export function buildApiHook(
+	api: Record<string, { kind: string; method: string }>,
+	ipc: {
+		request: (def: { method: string }, params: unknown) => Promise<unknown>;
+		command: (def: { method: string }, params: unknown) => void;
+		onNotification: (
+			def: { method: string },
+			cb: (data: unknown) => void,
+		) => () => void;
+	},
+) {
+	const result: Record<string, unknown> = {};
+	for (const [key, def] of Object.entries(api)) {
+		switch (def.kind) {
+			case "request":
+				result[key] = (params: unknown) => ipc.request(def, params);
+				break;
+			case "command":
+				result[key] = (params: unknown) => ipc.command(def, params);
+				break;
+			case "notification":
+				result[`on${key[0].toUpperCase()}${key.slice(1)}`] = (
+					cb: (data: unknown) => void,
+				) => ipc.onNotification(def, cb);
+				break;
+		}
+	}
+	return result;
+}

packages/shared/src/tasks/api.ts

@@ -21,65 +21,40 @@ export interface TaskIdParams {
 	taskId: string;
 }
 
-const getTasks = defineRequest<void, readonly Task[] | null>("getTasks");
-const getTemplates = defineRequest<void, readonly TaskTemplate[] | null>(
-	"getTemplates",
-);
-const getTask = defineRequest<TaskIdParams, Task>("getTask");
-const getTaskDetails = defineRequest<TaskIdParams, TaskDetails>(
-	"getTaskDetails",
-);
-
 export interface CreateTaskParams {
 	templateVersionId: string;
 	prompt: string;
 	presetId?: string;
 }
-const createTask = defineRequest<CreateTaskParams, Task>("createTask");
 
 export interface TaskActionParams extends TaskIdParams {
 	taskName: string;
 }
-const deleteTask = defineRequest<TaskActionParams, void>("deleteTask");
-const pauseTask = defineRequest<TaskActionParams, void>("pauseTask");
-const resumeTask = defineRequest<TaskActionParams, void>("resumeTask");
-const downloadLogs = defineRequest<TaskIdParams, void>("downloadLogs");
-const sendTaskMessage = defineRequest<TaskIdParams & { message: string }, void>(
-	"sendTaskMessage",
-);
-
-const viewInCoder = defineCommand<TaskIdParams>("viewInCoder");
-const viewLogs = defineCommand<TaskIdParams>("viewLogs");
-const stopStreamingWorkspaceLogs = defineCommand<void>(
-	"stopStreamingWorkspaceLogs",
-);
-
-const taskUpdated = defineNotification<Task>("taskUpdated");
-const tasksUpdated = defineNotification<Task[]>("tasksUpdated");
-const workspaceLogsAppend = defineNotification<string[]>("workspaceLogsAppend");
-const refresh = defineNotification<void>("refresh");
-const showCreateForm = defineNotification<void>("showCreateForm");
 
 export const TasksApi = {
 	// Requests
-	getTasks,
-	getTemplates,
-	getTask,
-	getTaskDetails,
-	createTask,
-	deleteTask,
-	pauseTask,
-	resumeTask,
-	downloadLogs,
-	sendTaskMessage,
+	getTasks: defineRequest<void, readonly Task[] | null>("getTasks"),
+	getTemplates: defineRequest<void, readonly TaskTemplate[] | null>(
+		"getTemplates",
+	),
+	getTask: defineRequest<TaskIdParams, Task>("getTask"),
+	getTaskDetails: defineRequest<TaskIdParams, TaskDetails>("getTaskDetails"),
+	createTask: defineRequest<CreateTaskParams, Task>("createTask"),
+	deleteTask: defineRequest<TaskActionParams, void>("deleteTask"),
+	pauseTask: defineRequest<TaskActionParams, void>("pauseTask"),
+	resumeTask: defineRequest<TaskActionParams, void>("resumeTask"),
+	downloadLogs: defineRequest<TaskIdParams, void>("downloadLogs"),
+	sendTaskMessage: defineRequest<TaskIdParams & { message: string }, void>(
+		"sendTaskMessage",
+	),
 	// Commands
-	viewInCoder,
-	viewLogs,
-	stopStreamingWorkspaceLogs,
+	viewInCoder: defineCommand<TaskIdParams>("viewInCoder"),
+	viewLogs: defineCommand<TaskIdParams>("viewLogs"),
+	stopStreamingWorkspaceLogs: defineCommand<void>("stopStreamingWorkspaceLogs"),
 	// Notifications
-	taskUpdated,
-	tasksUpdated,
-	workspaceLogsAppend,
-	refresh,
-	showCreateForm,
+	taskUpdated: defineNotification<Task>("taskUpdated"),
+	tasksUpdated: defineNotification<Task[]>("tasksUpdated"),
+	workspaceLogsAppend: defineNotification<string[]>("workspaceLogsAppend"),
+	refresh: defineNotification<void>("refresh"),
+	showCreateForm: defineNotification<void>("showCreateForm"),
 } as const;

packages/tasks/src/components/ErrorBanner.tsx

@@ -19,7 +19,7 @@ export function ErrorBanner({ task }: ErrorBannerProps) {
 			<button
 				type="button"
 				className="text-link"
-				onClick={() => api.viewLogs(task.id)}
+				onClick={() => api.viewLogs({ taskId: task.id })}
 			>
 				View logs <VscodeIcon name="link-external" />
 			</button>

packages/tasks/src/components/TaskMessageInput.tsx

@@ -69,7 +69,8 @@ export function TaskMessageInput({ task }: TaskMessageInputProps) {
 	});
 
 	const { mutate: sendMessage, isPending: isSending } = useMutation({
-		mutationFn: (msg: string) => api.sendTaskMessage(task.id, msg),
+		mutationFn: (msg: string) =>
+			api.sendTaskMessage({ taskId: task.id, message: msg }),
 		onSuccess: () => setMessage(""),
 		onError: (err) => logger.error("Failed to send message", err),
 	});

packages/tasks/src/components/useTaskMenuItems.ts

@@ -73,13 +73,14 @@ export function useTaskMenuItems({
 	menuItems.push({
 		label: "View in Coder",
 		icon: "link-external",
-		onClick: () => api.viewInCoder(task.id),
+		onClick: () => api.viewInCoder({ taskId: task.id }),
 	});
 
 	menuItems.push({
 		label: "Download Logs",
 		icon: "cloud-download",
-		onClick: () => run("downloading", () => api.downloadLogs(task.id)),
+		onClick: () =>
+			run("downloading", () => api.downloadLogs({ taskId: task.id })),
 		loading: action === "downloading",
 	});
 

packages/tasks/src/hooks/useSelectedTask.ts

@@ -30,7 +30,7 @@ export function useSelectedTask(tasks: readonly Task[]) {
 			? queryKeys.taskDetail(selectedTaskId)
 			: queryKeys.details,
 		queryFn: selectedTaskId
-			? () => api.getTaskDetails(selectedTaskId)
+			? () => api.getTaskDetails({ taskId: selectedTaskId })
 			: skipToken,
 		refetchInterval: (query) => {
 			const task = query.state.data?.task;

packages/tasks/src/hooks/useTasksApi.ts

@@ -1,60 +1,6 @@
-/**
- * Tasks API hook - provides type-safe access to all Tasks operations.
- *
- * @example
- * ```tsx
- * const api = useTasksApi();
- * const tasks = await api.getTasks();
- * api.viewInCoder("task-id");
- * ```
- */
-
-import {
-	TasksApi,
-	type CreateTaskParams,
-	type Task,
-	type TaskActionParams,
-} from "@repo/shared";
+import { TasksApi, buildApiHook } from "@repo/shared";
 import { useIpc } from "@repo/webview-shared/react";
 
 export function useTasksApi() {
-	const { request, command, onNotification } = useIpc();
-
-	return {
-		// Requests
-		getTasks: () => request(TasksApi.getTasks),
-		getTemplates: () => request(TasksApi.getTemplates),
-		getTask: (taskId: string) => request(TasksApi.getTask, { taskId }),
-		getTaskDetails: (taskId: string) =>
-			request(TasksApi.getTaskDetails, { taskId }),
-		createTask: (params: CreateTaskParams) =>
-			request(TasksApi.createTask, params),
-		deleteTask: (params: TaskActionParams) =>
-			request(TasksApi.deleteTask, params),
-		pauseTask: (params: TaskActionParams) =>
-			request(TasksApi.pauseTask, params),
-		resumeTask: (params: TaskActionParams) =>
-			request(TasksApi.resumeTask, params),
-		downloadLogs: (taskId: string) =>
-			request(TasksApi.downloadLogs, { taskId }),
-		sendTaskMessage: (taskId: string, message: string) =>
-			request(TasksApi.sendTaskMessage, { taskId, message }),
-
-		// Commands
-		viewInCoder: (taskId: string) => command(TasksApi.viewInCoder, { taskId }),
-		viewLogs: (taskId: string) => command(TasksApi.viewLogs, { taskId }),
-		stopStreamingWorkspaceLogs: () =>
-			command(TasksApi.stopStreamingWorkspaceLogs),
-
-		// Notifications
-		onTaskUpdated: (cb: (task: Task) => void) =>
-			onNotification(TasksApi.taskUpdated, cb),
-		onTasksUpdated: (cb: (tasks: Task[]) => void) =>
-			onNotification(TasksApi.tasksUpdated, cb),
-		onWorkspaceLogsAppend: (cb: (lines: string[]) => void) =>
-			onNotification(TasksApi.workspaceLogsAppend, cb),
-		onRefresh: (cb: () => void) => onNotification(TasksApi.refresh, cb),
-		onShowCreateForm: (cb: () => void) =>
-			onNotification(TasksApi.showCreateForm, cb),
-	};
+	return buildApiHook(TasksApi, useIpc());
 }

test/webview/tasks/ErrorBanner.test.tsx

@@ -58,6 +58,6 @@ describe("ErrorBanner", () => {
 		const t = task({ id: "task-42", status: "error" });
 		renderWithQuery(<ErrorBanner task={t} />);
 		fireEvent.click(screen.getByText("View logs"));
-		expect(mockApi.viewLogs).toHaveBeenCalledWith("task-42");
+		expect(mockApi.viewLogs).toHaveBeenCalledWith({ taskId: "task-42" });
 	});
 });

test/webview/tasks/TaskMessageInput.test.tsx

@@ -162,10 +162,10 @@ describe("TaskMessageInput", () => {
 		fireEvent.keyDown(getTextarea(), { key: "Enter", ctrlKey: true });
 
 		await waitFor(() => {
-			expect(mockApi.sendTaskMessage).toHaveBeenCalledWith(
-				"task-1",
-				"Hello agent",
-			);
+			expect(mockApi.sendTaskMessage).toHaveBeenCalledWith({
+				taskId: "task-1",
+				message: "Hello agent",
+			});
 		});
 		await waitFor(() => {
 			expect(getTextarea()).toHaveValue("");

test/webview/tasks/useTaskMenuItems.test.tsx

@@ -134,7 +134,7 @@ describe("useTaskMenuItems", () => {
 		const { result } = renderTask(testTask);
 		clickItem(result.current.menuItems, label);
 		await waitFor(() => {
-			expect(mockApi[apiMethod]).toHaveBeenCalledWith(testTask.id);
+			expect(mockApi[apiMethod]).toHaveBeenCalledWith({ taskId: testTask.id });
 		});
 	});