Done correctly based on docs and remove old logging hook

Author: TylerLeonhardt

src/extension/chatSessions/claude/common/claudeMessageDispatch.ts

@@ -3,15 +3,16 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import type { SDKAssistantMessage, SDKCompactBoundaryMessage, SDKHookResponseMessage, SDKHookStartedMessage, SDKMessage, SDKResultMessage, SDKUserMessage, SDKUserMessageReplay } from '@anthropic-ai/claude-agent-sdk';
+import type { SDKAssistantMessage, SDKCompactBoundaryMessage, SDKHookProgressMessage, SDKHookResponseMessage, SDKHookStartedMessage, SDKMessage, SDKResultMessage, SDKUserMessage, SDKUserMessageReplay } from '@anthropic-ai/claude-agent-sdk';
 import type { TodoWriteInput } from '@anthropic-ai/claude-agent-sdk/sdk-tools';
 import type Anthropic from '@anthropic-ai/sdk';
 import * as l10n from '@vscode/l10n';
 import type * as vscode from 'vscode';
+import { vBoolean, vLiteral, vObj, vString, type ValidatorType } from '../../../../platform/configuration/common/validator';
 import { ILogService } from '../../../../platform/log/common/logService';
-import { CopilotChatAttr, GenAiAttr, GenAiOperationName, IOTelService, type ISpanHandle, SpanKind, SpanStatusCode, truncateForOTel } from '../../../../platform/otel/common/index';
+import { CopilotChatAttr, GenAiAttr, GenAiOperationName, IOTelService, SpanKind, SpanStatusCode, truncateForOTel, type ISpanHandle } from '../../../../platform/otel/common/index';
 import { ServicesAccessor } from '../../../../util/vs/platform/instantiation/common/instantiation';
-import { ChatResponseThinkingProgressPart } from '../../../../vscodeTypes';
+import { ChatResponseThinkingProgressPart, type ChatHookType } from '../../../../vscodeTypes';
 import { ToolName } from '../../../tools/common/toolNames';
 import { IToolsService } from '../../../tools/common/toolsService';
 import { ClaudeToolNames } from './claudeTools';
@@ -89,9 +90,7 @@ export const ALL_KNOWN_MESSAGE_KEYS = new Set([
 	// TODO: Show `system:local_command_output` — has `content` text from local slash commands
 	'system:local_command_output',
 	'system:hook_started',
-	// TODO: Show `system:hook_progress` — has `stdout`, `stderr`, `output` for streaming hook output
 	'system:hook_progress',
-	// TODO: Show `system:hook_response` — has `output`, `stderr`, `outcome` — surface errors to user
 	'system:hook_response',
 	// TODO: Show `system:task_notification` — has `summary` and `status` for subagent completion
 	'system:task_notification',
@@ -311,13 +310,127 @@ export function handleHookStarted(
 	state.otelHookSpans.set(message.hook_id, span);
 }
 
+// #region Hook JSON output validator
+
+/**
+ * Validator for structured JSON output from hooks (exit code 0 only).
+ *
+ * Hooks can return JSON with these fields:
+ * - `continue`: if false, stops processing entirely
+ * - `stopReason`: message shown to user when `continue` is false
+ * - `systemMessage`: warning shown to user
+ * - `decision`: "block" to prevent the operation
+ * - `reason`: explanation when `decision` is "block"
+ *
+ * @see https://code.claude.com/docs/en/hooks.md
+ */
+const vHookJsonOutput = vObj({
+	continue: vBoolean(),
+	stopReason: vString(),
+	systemMessage: vString(),
+	decision: vLiteral('block'),
+	reason: vString(),
+});
+
+export type HookJsonOutput = ValidatorType<typeof vHookJsonOutput>;
+
+/**
+ * Parses JSON output from a hook's stdout.
+ * Returns the validated fields, or undefined if parsing/validation fails.
+ * Fields that are missing from the JSON are simply absent from the result.
+ */
+export function parseHookJsonOutput(stdout: string): Partial<HookJsonOutput> | undefined {
+	let raw: unknown;
+	try {
+		raw = JSON.parse(stdout);
+	} catch {
+		return undefined;
+	}
+
+	if (typeof raw !== 'object' || raw === null || Array.isArray(raw)) {
+		return undefined;
+	}
+
+	// Use the validator to extract known fields with type safety.
+	// vObj skips missing optional fields, so partial results are expected.
+	const result = vHookJsonOutput.validate(raw);
+	if (result.error) {
+		// Validation error means some present field had the wrong type —
+		// extract what we can by validating each field individually.
+		const obj = raw as Record<string, unknown>;
+		const partial: Partial<HookJsonOutput> = {};
+
+		const continueResult = vBoolean().validate(obj['continue']);
+		if (!continueResult.error) {
+			partial.continue = continueResult.content;
+		}
+		const stopReasonResult = vString().validate(obj['stopReason']);
+		if (!stopReasonResult.error) {
+			partial.stopReason = stopReasonResult.content;
+		}
+		const systemMessageResult = vString().validate(obj['systemMessage']);
+		if (!systemMessageResult.error) {
+			partial.systemMessage = systemMessageResult.content;
+		}
+		const decisionResult = vLiteral('block').validate(obj['decision']);
+		if (!decisionResult.error) {
+			partial.decision = decisionResult.content;
+		}
+		const reasonResult = vString().validate(obj['reason']);
+		if (!reasonResult.error) {
+			partial.reason = reasonResult.content;
+		}
+
+		return Object.keys(partial).length > 0 ? partial : undefined;
+	}
+
+	return result.content;
+}
+
+// #endregion
+
+/**
+ * Formats a localized error message for a failed hook.
+ * @param errorMessage The error message from the hook
+ * @returns A localized error message string
+ * @todo use a common function with: https://github.com/microsoft/vscode-copilot-chat/blob/9a9461734da42f28e4e2d0b975ebeae6162e9b4c/src/extension/intents/node/hookResultProcessor.ts#L142
+ */
+function formatHookErrorMessage(errorMessage: string): string {
+	if (errorMessage) {
+		return l10n.t('A hook prevented chat from continuing. Please check the GitHub Copilot Chat Hooks output channel for more details. \nError message: {0}', errorMessage);
+	}
+	return l10n.t('A hook prevented chat from continuing. Please check the GitHub Copilot Chat Hooks output channel for more details.');
+}
+
+
+export function handleHookProgress(
+	message: SDKHookProgressMessage,
+	accessor: ServicesAccessor,
+	request: MessageHandlerRequestContext,
+): void {
+	const logService = accessor.get(ILogService);
+	// TODO: can we map these types better
+	const hookType = message.hook_event as ChatHookType;
+	const progressText = message.stdout || message.stderr;
+
+	logService.trace(`[ClaudeMessageDispatch] Hook progress "${message.hook_name}" (${message.hook_event}): ${progressText}`);
+
+	if (progressText) {
+		request.stream.hookProgress(hookType, undefined, progressText);
+	}
+}
+
 export function handleHookResponse(
 	message: SDKHookResponseMessage,
 	accessor: ServicesAccessor,
 	request: MessageHandlerRequestContext,
 	state: MessageHandlerState,
 ): void {
 	const logService = accessor.get(ILogService);
+	// TODO: can we map these types better
+	const hookType = message.hook_event as ChatHookType;
+
+	// #region OTel span
 	const span = state.otelHookSpans.get(message.hook_id);
 	if (span) {
 		if (message.outcome === 'error') {
@@ -336,13 +449,66 @@ export function handleHookResponse(
 		span.end();
 		state.otelHookSpans.delete(message.hook_id);
 	}
+	// #endregion
 
-	if (message.outcome === 'error') {
-		logService.warn(`[ClaudeMessageDispatch] Hook "${message.hook_name}" (${message.hook_event}) failed: ${message.stderr || message.output}`);
-		request.stream.markdown(`*${l10n.t('Hook "{0}" failed', message.hook_name)}*\n`);
-		if (message.stderr) {
-			request.stream.markdown(`\`\`\`\n${message.stderr}\n\`\`\`\n`);
+	// Cancelled — log only, no user-facing output
+	if (message.outcome === 'cancelled') {
+		logService.trace(`[ClaudeMessageDispatch] Hook "${message.hook_name}" (${message.hook_event}) was cancelled`);
+		return;
+	}
+
+	// Exit code 2 — blocking error (stderr is the message, JSON ignored)
+	if (message.exit_code === 2) {
+		const errorMessage = message.stderr || message.output;
+		logService.warn(`[ClaudeMessageDispatch] Hook "${message.hook_name}" (${message.hook_event}) blocking error: ${errorMessage}`);
+		request.stream.hookProgress(hookType, formatHookErrorMessage(errorMessage));
+		return;
+	}
+
+	// Other non-zero exit codes — non-blocking warning
+	if (message.exit_code !== undefined && message.exit_code !== 0) {
+		const warningMessage = message.stderr || message.output || (l10n.t('Exit Code: {0}', message.exit_code));
+		logService.warn(`[ClaudeMessageDispatch] Hook "${message.hook_name}" (${message.hook_event}) non-blocking error (exit ${message.exit_code}): ${warningMessage}`);
+		if (warningMessage) {
+			request.stream.hookProgress(hookType, undefined, warningMessage);
 		}
+		return;
+	}
+
+	// Outcome 'error' without a specific exit code — treat as blocking error
+	if (message.outcome === 'error') {
+		const errorMessage = message.stderr || message.output;
+		logService.warn(`[ClaudeMessageDispatch] Hook "${message.hook_name}" (${message.hook_event}) failed: ${errorMessage}`);
+		request.stream.hookProgress(hookType, formatHookErrorMessage(errorMessage));
+		return;
+	}
+
+	// Exit code 0 (or undefined with success outcome) — parse JSON from stdout
+	if (!message.stdout) {
+		return;
+	}
+
+	const parsed = parseHookJsonOutput(message.stdout);
+	if (!parsed) {
+		logService.warn(`[ClaudeMessageDispatch] Hook "${message.hook_name}" returned non-JSON output`);
+		return;
+	}
+
+	// Handle `decision: "block"` with `reason`
+	if (parsed.decision === 'block') {
+		request.stream.hookProgress(hookType, formatHookErrorMessage(parsed.reason ?? ''));
+		return;
+	}
+
+	// Handle `continue: false` with optional `stopReason`
+	if (parsed.continue === false) {
+		request.stream.hookProgress(hookType, formatHookErrorMessage(parsed.stopReason ?? ''));
+		return;
+	}
+
+	// Handle `systemMessage` — shown as a warning
+	if (parsed.systemMessage) {
+		request.stream.hookProgress(hookType, undefined, parsed.systemMessage);
 	}
 }
 
@@ -400,6 +566,10 @@ export function dispatchMessage(
 				handleHookStarted(message, accessor, sessionId, state);
 				return;
 			}
+			if (message.subtype === 'hook_progress') {
+				handleHookProgress(message, accessor, request);
+				return;
+			}
 			if (message.subtype === 'hook_response') {
 				handleHookResponse(message, accessor, request, state);
 				return;