@fitchmultz/pi-subagents 0.44.7 → 0.45.0

package/src/runs/shared/child-execution-cwd.ts

@@ -1,91 +1,162 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
+import {
+  hasErrorCode,
+  errorMessage as errorText,
+  isRecord as isObject,
+} from "../../shared/unknown.ts";
+import { nonempty } from "./child-presence.ts";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 
 const RESOLVE_CWD = "pi-change-working-dir:resolve-execution-cwd";
 const SET_CWD = "pi-change-working-dir:set-execution-cwd";
 const intentPath = (sessionFile: string): string => `${sessionFile}.subagent-cwd-init`;
-type CwdIntent = { cwd?: string };
-type CwdRequest = { sessionManager: ExtensionContext["sessionManager"]; path?: string; result?: { cwd: string; error?: string } };
+type CwdIntent = { readonly cwd?: string };
+type CwdRequest = {
+  sessionManager: ExtensionContext["sessionManager"];
+  path?: string;
+  result?: { cwd: string; error?: string };
+};
 
 /** Call once for a new fork or explicit resume override; undo only if launch fails before starting. */
 export function requestChildExecutionCwd(sessionFile: string, cwd?: string): () => void {
-	if (cwd !== undefined && !path.isAbsolute(cwd)) throw new Error("Child execution cwd must be absolute.");
-	const previous = readIntent(sessionFile);
-	fs.writeFileSync(intentPath(sessionFile), JSON.stringify({ cwd }), { mode: 0o600 });
-	return () => {
-		if (previous) fs.writeFileSync(intentPath(sessionFile), JSON.stringify(previous), { mode: 0o600 });
-		else fs.unlinkSync(intentPath(sessionFile));
-	};
+  if (cwd !== undefined && !path.isAbsolute(cwd)) {
+    throw new Error("Child execution cwd must be absolute.");
+  }
+  const previous = readIntent(sessionFile);
+  fs.writeFileSync(intentPath(sessionFile), JSON.stringify({ cwd }), { mode: 0o600 });
+  return () => {
+    if (previous) {
+      fs.writeFileSync(intentPath(sessionFile), JSON.stringify(previous), { mode: 0o600 });
+    } else {
+      fs.unlinkSync(intentPath(sessionFile));
+    }
+  };
 }
 
 function readIntent(sessionFile: string): CwdIntent | undefined {
-	let raw: string;
-	try {
-		raw = fs.readFileSync(intentPath(sessionFile), "utf8");
-	} catch (error) {
-		if ((error as NodeJS.ErrnoException).code === "ENOENT") return undefined;
-		throw error;
-	}
-	const value: unknown = JSON.parse(raw);
-	if (!value || typeof value !== "object" || Array.isArray(value)
-		|| ("cwd" in value && (typeof value.cwd !== "string" || !path.isAbsolute(value.cwd)))) {
-		throw new Error("Invalid child execution cwd initialization request.");
-	}
-	return value as CwdIntent;
+  let raw: string;
+  try {
+    raw = fs.readFileSync(intentPath(sessionFile), "utf8");
+  } catch (error) {
+    if (hasErrorCode(error, "ENOENT")) {
+      return undefined;
+    }
+    throw error;
+  }
+  const value: unknown = JSON.parse(raw);
+  if (
+    !isObject(value) ||
+    ("cwd" in value && (typeof value.cwd !== "string" || !path.isAbsolute(value.cwd)))
+  ) {
+    throw new Error("Invalid child execution cwd initialization request.");
+  }
+  return { cwd: "cwd" in value && typeof value.cwd === "string" ? value.cwd : undefined };
 }
 
 /** Freeze the new fork's requested directory once the actual launch cwd is known. */
 export function prepareChildExecutionCwd(sessionFile: string, cwd?: string): void {
-	const intent = readIntent(sessionFile);
-	if (intent && intent.cwd === undefined) {
-		if (!cwd) throw new Error("New fork execution cwd was not supplied.");
-		requestChildExecutionCwd(sessionFile, cwd);
-	}
+  const intent = readIntent(sessionFile);
+  if (intent && intent.cwd === undefined) {
+    if (!nonempty(cwd)) {
+      throw new Error("New fork execution cwd was not supplied.");
+    }
+    requestChildExecutionCwd(sessionFile, cwd);
+  }
 }
 
-export function hasExecutionCwdOwner(pi: Pick<ExtensionAPI, "getAllTools" | "getCommands">): boolean {
-	// excludeTools can hide change_dir while the owner's /cwd command remains loaded.
-	const fromOwner = ({ sourceInfo }: { sourceInfo: { source: string; path: string } }) =>
-		/(?:^|[/\\:@])(?:pi-)?change-working-dir(?:[/\\@:.>]|$)/.test(`${sourceInfo.source}/${sourceInfo.path}`);
-	return pi.getAllTools().some((tool) => tool.name === "change_dir" || fromOwner(tool))
-		|| pi.getCommands().some((command) => command.source === "extension" && (/^cwd(?::\d+)?$/.test(command.name) || fromOwner(command)));
+export function hasExecutionCwdOwner(
+  pi: Pick<ExtensionAPI, "getAllTools" | "getCommands">,
+): boolean {
+  // excludeTools can hide change_dir while the owner's /cwd command remains loaded.
+  const fromOwner = ({
+    sourceInfo,
+  }: {
+    readonly sourceInfo: { readonly source: string; readonly path: string };
+  }) =>
+    /(?:^|[/\\:@])(?:pi-)?change-working-dir(?:[/\\@:.>]|$)/.test(
+      `${sourceInfo.source}/${sourceInfo.path}`,
+    );
+  return (
+    pi.getAllTools().some((tool) => tool.name === "change_dir" || fromOwner(tool)) ||
+    pi
+      .getCommands()
+      .some(
+        (command) =>
+          command.source === "extension" &&
+          (/^cwd(?::\d+)?$/.test(command.name) || fromOwner(command)),
+      )
+  );
+}
+
+function initializeCwd(pi: ExtensionAPI, ctx: ExtensionContext, cwd: string, owned: boolean): void {
+  if (!owned) {
+    if (fs.realpathSync(ctx.cwd) !== fs.realpathSync(cwd)) {
+      throw new Error("Native child directory does not match the requested execution cwd.");
+    }
+    return;
+  }
+  const selection: CwdRequest = { sessionManager: ctx.sessionManager, path: cwd };
+  pi.events.emit(SET_CWD, selection);
+  if (!selection.result) {
+    throw new Error(
+      "The loaded directory extension did not initialize the child directory. Update pi-change-working-dir and ensure session startup has completed.",
+    );
+  }
+  if (nonempty(selection.result.error)) {
+    throw new Error(selection.result.error);
+  }
+  if (fs.realpathSync(selection.result.cwd) !== fs.realpathSync(cwd)) {
+    throw new Error("The directory extension selected a different child directory.");
+  }
+}
+
+function resolveCwdOwnership(pi: ExtensionAPI, ctx: ExtensionContext): boolean {
+  const request: CwdRequest = { sessionManager: ctx.sessionManager };
+  pi.events.emit(RESOLVE_CWD, request);
+  if (nonempty(request.result?.error)) {
+    throw new Error(request.result.error);
+  }
+  const owned = request.result !== undefined || hasExecutionCwdOwner(pi);
+  if (owned && !nonempty(request.result?.cwd)) {
+    throw new Error(
+      "The loaded directory extension did not resolve the child directory. Update pi-change-working-dir and ensure session startup has completed.",
+    );
+  }
+  return owned;
+}
+function initializeOnInput(pi: ExtensionAPI, ctx: ExtensionContext): void {
+  const sessionFile = ctx.sessionManager.getSessionFile();
+  const intent = nonempty(sessionFile) ? readIntent(sessionFile) : undefined;
+  const owned = resolveCwdOwnership(pi, ctx);
+  if (!intent) {
+    return;
+  }
+  if (!nonempty(intent.cwd)) {
+    throw new Error("New fork execution cwd was not prepared before startup.");
+  }
+  initializeCwd(pi, ctx, intent.cwd, owned);
+  // This is a launch intent, not another directory store. Only the owner persists selection.
+  if (sessionFile !== undefined) {
+    fs.unlinkSync(intentPath(sessionFile));
+  }
 }
 
 export function registerChildExecutionCwd(pi: ExtensionAPI): void {
-	let initialized = false;
-	pi.on("input", (_event, ctx) => {
-		if (initialized) return;
-		try {
-			const sessionFile = ctx.sessionManager.getSessionFile();
-			const intent = sessionFile ? readIntent(sessionFile) : undefined;
-			const request: CwdRequest = { sessionManager: ctx.sessionManager };
-			pi.events.emit(RESOLVE_CWD, request);
-			if (request.result?.error) throw new Error(request.result.error);
-			const owned = Boolean(request.result) || hasExecutionCwdOwner(pi);
-			if (owned && !request.result?.cwd) throw new Error("The loaded directory extension did not resolve the child directory. Update pi-change-working-dir and ensure session startup has completed.");
-			if (!intent) {
-				initialized = true;
-				return;
-			}
-			if (!intent.cwd) throw new Error("New fork execution cwd was not prepared before startup.");
-			if (owned) {
-				const selection: CwdRequest = { sessionManager: ctx.sessionManager, path: intent.cwd };
-				pi.events.emit(SET_CWD, selection);
-				if (!selection.result) throw new Error("The loaded directory extension did not initialize the child directory. Update pi-change-working-dir and ensure session startup has completed.");
-				if (selection.result.error) throw new Error(selection.result.error);
-				if (fs.realpathSync(selection.result.cwd) !== fs.realpathSync(intent.cwd)) throw new Error("The directory extension selected a different child directory.");
-			} else if (fs.realpathSync(ctx.cwd) !== fs.realpathSync(intent.cwd)) {
-				throw new Error("Native child directory does not match the requested execution cwd.");
-			}
-			// This is a launch intent, not another directory store. Only the owner persists selection.
-			fs.unlinkSync(intentPath(sessionFile!));
-			initialized = true;
-		} catch (error) {
-			console.error(`Subagent directory initialization failed: ${error instanceof Error ? error.message : String(error)}`);
-			process.exitCode = 1;
-			// Native hook exceptions are swallowed. Handled input stops before provider/tool dispatch.
-			return { action: "handled" };
-		}
-	});
+  let initialized = false;
+  pi.on("input", (_event, ctx) => {
+    if (initialized) {
+      return;
+    }
+    try {
+      initializeOnInput(pi, ctx);
+      initialized = true;
+      return;
+    } catch (error) {
+      console.error(`Subagent directory initialization failed: ${errorText(error)}`);
+      process.exitCode = 1;
+      // Native hook exceptions are swallowed. Handled input stops before provider/tool dispatch.
+      return { action: "handled" };
+    }
+  });
 }

package/src/runs/shared/child-execution-outcome.ts

@@ -0,0 +1,103 @@
+import type { ReadonlyInput } from "../../shared/types.ts";
+import type { ChildAttemptOptions, ChildAttemptResult } from "./child-attempt-types.ts";
+import { readFinalizationReport } from "./acceptance.ts";
+import { readStructuredOutput } from "./structured-output.ts";
+import { nonempty } from "./child-presence.ts";
+
+interface OutcomeInput {
+  readonly result: ReadonlyInput<ChildAttemptResult>;
+  readonly options: ReadonlyInput<ChildAttemptOptions>;
+  readonly code: number | null;
+  readonly signal?: NodeJS.Signals | null;
+  readonly spawnError?: Readonly<Error>;
+  readonly stopping: boolean;
+  readonly settledCleanup: boolean;
+  readonly cleanAssistantStop: boolean;
+  readonly assistantError?: string;
+}
+
+function processExitCode(input: OutcomeInput, drainedSuccess: boolean): number {
+  const result = input.result;
+  if (result.timedOut === true) {
+    return 124;
+  }
+  if (result.resourceLimitExceeded || result.terminalFailure === true) {
+    return 1;
+  }
+  if (result.interrupted === true || drainedSuccess) {
+    return 0;
+  }
+  return input.code ?? (input.stopping || nonempty(input.signal) ? 1 : 0);
+}
+
+function completedOutput(input: OutcomeInput): { completed: boolean; report: boolean } {
+  const runtime = input.options.nativeFinalization?.reportRuntime ?? input.options.reportRuntime;
+  const report = runtime
+    ? readFinalizationReport([...input.result.messages], runtime).output
+    : undefined;
+  const structured = input.options.structuredOutput
+    ? readStructuredOutput(input.options.structuredOutput)
+    : undefined;
+  return {
+    completed:
+      input.cleanAssistantStop ||
+      nonempty(report) ||
+      (structured !== undefined && !nonempty(structured.error)),
+    report: nonempty(report),
+  };
+}
+
+function drainedNativeSuccess(
+  input: OutcomeInput,
+  report: boolean,
+  error: string | undefined,
+): boolean {
+  return input.settledCleanup && (input.cleanAssistantStop || report) && !nonempty(error);
+}
+function processDiagnostic(code: number | null, stderr: string): string | undefined {
+  const diagnostics = stderr.trim();
+  if (code === 143) {
+    // Keep startup diagnostics without hiding the terminated process's actual exit status.
+    return `Child process exited with code 143.${diagnostics.length > 0 ? `\n${diagnostics}` : ""}`;
+  }
+  return diagnostics.length > 0 ? diagnostics : undefined;
+}
+function executionError(
+  input: OutcomeInput,
+  report: boolean,
+): { error?: string; drainedSuccess: boolean } {
+  let error =
+    input.result.error ?? (report ? undefined : input.assistantError) ?? input.spawnError?.message;
+  const drainedSuccess = drainedNativeSuccess(input, report, error);
+  if (
+    input.code !== 0 &&
+    !nonempty(error) &&
+    !drainedSuccess &&
+    input.result.interrupted !== true
+  ) {
+    error = processDiagnostic(input.code, input.result.stderr);
+  }
+  return { error, drainedSuccess };
+}
+
+/** Keep process cleanup distinct from completed native work and owner interruption. */
+export function childExecutionOutcome(
+  input: OutcomeInput,
+): Pick<ChildAttemptResult, "error" | "exitCode" | "terminalFailure"> {
+  const completion = completedOutput(input);
+  const { error, drainedSuccess } = executionError(input, completion.report);
+  const exitCode = processExitCode(input, drainedSuccess);
+  if (input.result.interrupted === true) {
+    return { error: undefined, exitCode, terminalFailure: input.result.terminalFailure };
+  }
+  if (exitCode === 0 && !nonempty(error) && !completion.completed) {
+    return {
+      error: input.options.nativeFinalization
+        ? "Native self-review boundary did not return a result."
+        : "Child exit was observed, but no completed assistant result was returned.",
+      exitCode: 1,
+      terminalFailure: true,
+    };
+  }
+  return { error, exitCode, terminalFailure: input.result.terminalFailure };
+}

package/src/runs/shared/child-invocation.ts

@@ -0,0 +1,74 @@
+import {
+  applyIntercomBridgeToAgent,
+  resolveIntercomBridge,
+} from "../../intercom/intercom-bridge.ts";
+import type { ReadonlyInput } from "../../shared/types.ts";
+import { applyThinkingSuffix, buildPiArgs } from "./pi-args.ts";
+import type { BuildPiArgsInput, BuildPiArgsResult } from "./pi-launch-input.ts";
+import {
+  buildClaudeCodeInvocation,
+  isClaudeCodeModel,
+  type ClaudeCodeInvocation,
+} from "./claude-code.ts";
+import { nativeFinalizationLaunch, type NativeFinalizationConfig } from "./native-finalization.ts";
+import { nonempty } from "./child-presence.ts";
+
+type ChildInvocationInput = ReadonlyInput<
+  Omit<BuildPiArgsInput, "baseArgs"> & { readonly nativeFinalization?: NativeFinalizationConfig }
+>;
+export type ChildInvocation = BuildPiArgsResult & { claudeCodeInvocation?: ClaudeCodeInvocation };
+
+function bridgedInput(input: ChildInvocationInput): ChildInvocationInput {
+  if (!nonempty(input.orchestratorIntercomTarget)) {
+    return input;
+  }
+  const bridged = applyIntercomBridgeToAgent(
+    { systemPrompt: input.systemPrompt ?? "", tools: input.tools, extensions: input.extensions },
+    resolveIntercomBridge(input.orchestratorIntercomTarget),
+  );
+  return {
+    ...input,
+    systemPrompt: bridged.systemPrompt,
+    tools: bridged.tools,
+    extensions: bridged.extensions,
+  };
+}
+
+function finalizedPiInvocation(input: ChildInvocationInput): BuildPiArgsResult {
+  const built = buildPiArgs({
+    ...bridgedInput(input),
+    structuredOutput: input.nativeFinalization ? undefined : input.structuredOutput,
+    baseArgs: ["--mode", "json", "-p"],
+  });
+  if (!input.nativeFinalization) {
+    return built;
+  }
+  const runtime = nativeFinalizationLaunch(input.nativeFinalization);
+  built.args.push("--extension", runtime.extension);
+  Object.assign(built.env, runtime.env);
+  const tools = built.args.indexOf("--tools");
+  const names = tools >= 0 ? built.args.at(tools + 1) : undefined;
+  if (names !== undefined && !names.split(",").includes("structured_output")) {
+    built.args[tools + 1] = `${names},structured_output`;
+  }
+  return built;
+}
+
+export function buildChildInvocation(input: ChildInvocationInput): ChildInvocation {
+  const model = applyThinkingSuffix(input.model, input.thinking);
+  if (!nonempty(model) || !isClaudeCodeModel(model)) {
+    return finalizedPiInvocation(input);
+  }
+  const invocation = buildClaudeCodeInvocation({
+    ...input,
+    model,
+    systemPrompt: input.systemPrompt ?? undefined,
+    sessionName: input.intercomSessionName,
+    outputSchema: input.structuredOutput?.schema,
+  });
+  return {
+    args: [...invocation.args],
+    env: { ...invocation.env },
+    claudeCodeInvocation: invocation,
+  };
+}

package/src/runs/shared/child-message-validation.ts

@@ -0,0 +1,233 @@
+import type {
+  ObservedContent,
+  ObservedMessage,
+  ObservedUsage,
+} from "../../shared/types/messages.ts";
+import { isRecord as isObject } from "../../shared/unknown.ts";
+
+export function optionalString(value: unknown, label: string): string | undefined {
+  if (value === undefined) {
+    return;
+  }
+  if (typeof value !== "string") {
+    throw new SyntaxError(`Invalid ${label}`);
+  }
+  return value;
+}
+
+export function optionalNumber(value: unknown, label: string): number | undefined {
+  if (value === undefined) {
+    return;
+  }
+  if (typeof value !== "number") {
+    throw new SyntaxError(`Invalid ${label}`);
+  }
+  return value;
+}
+
+export function optionalBoolean(value: unknown, label: string): boolean | undefined {
+  if (value === undefined) {
+    return;
+  }
+  if (typeof value !== "boolean") {
+    throw new SyntaxError(`Invalid ${label}`);
+  }
+  return value;
+}
+
+export function requiredString(value: unknown, label: string): string {
+  const text = optionalString(value, label);
+  if (text === undefined) {
+    throw new SyntaxError(`Missing ${label}`);
+  }
+  return text;
+}
+
+function isObservedUsage(value: unknown): value is ObservedUsage {
+  if (!isObject(value)) {
+    return false;
+  }
+  for (const key of [
+    "input",
+    "output",
+    "cacheRead",
+    "cacheWrite",
+    "totalTokens",
+    "reasoning",
+    "cacheWrite1h",
+  ]) {
+    optionalNumber(value[key], `usage.${key}`);
+  }
+  if (value.cost !== undefined) {
+    if (!isObject(value.cost)) {
+      return false;
+    }
+    for (const key of ["input", "output", "cacheRead", "cacheWrite", "total"]) {
+      optionalNumber(value.cost[key], `cost.${key}`);
+    }
+  }
+  return true;
+}
+export function observedUsage(value: unknown): ObservedUsage | undefined {
+  if (value === undefined) {
+    return;
+  }
+  if (!isObservedUsage(value)) {
+    throw new SyntaxError("Invalid native usage");
+  }
+  return value;
+}
+
+function observedContent(value: unknown): ObservedContent {
+  if (!isObject(value)) {
+    throw new SyntaxError("Invalid native message content");
+  }
+  switch (value.type) {
+    case "text":
+      return {
+        ...value,
+        type: "text",
+        text: requiredString(value.text, "content.text"),
+        textSignature: optionalString(value.textSignature, "textSignature"),
+      };
+    case "thinking":
+      return {
+        ...value,
+        type: "thinking",
+        thinking: optionalString(value.thinking, "content.thinking") ?? "",
+        thinkingSignature: optionalString(value.thinkingSignature, "thinkingSignature"),
+      };
+    case "image":
+      return {
+        ...value,
+        type: "image",
+        data: optionalString(value.data, "image.data") ?? "",
+        mimeType: requiredString(value.mimeType, "image.mimeType"),
+      };
+    case "toolCall":
+      if (!isObject(value.arguments)) {
+        throw new SyntaxError("Invalid tool call arguments");
+      }
+      return {
+        ...value,
+        type: "toolCall",
+        id: requiredString(value.id, "toolCall.id"),
+        name: requiredString(value.name, "toolCall.name"),
+        arguments: value.arguments,
+      };
+    default:
+      throw new SyntaxError("Unsupported native message content");
+  }
+}
+
+function contentArray(value: unknown): ObservedContent[] {
+  if (!Array.isArray(value)) {
+    throw new SyntaxError("Invalid native message content array");
+  }
+  return value.map((part: unknown) => observedContent(part));
+}
+
+function assistant(value: Readonly<Record<string, unknown>>): ObservedMessage {
+  return {
+    ...value,
+    role: "assistant",
+    content: contentArray(value.content),
+    timestamp: optionalNumber(value.timestamp, "timestamp"),
+    api: optionalString(value.api, "api"),
+    provider: optionalString(value.provider, "provider"),
+    model: optionalString(value.model, "model"),
+    responseModel: optionalString(value.responseModel, "responseModel"),
+    responseId: optionalString(value.responseId, "responseId"),
+    usage: observedUsage(value.usage),
+    stopReason: optionalString(value.stopReason, "stopReason"),
+    errorMessage: optionalString(value.errorMessage, "errorMessage"),
+  };
+}
+
+function otherMessage(
+  value: Readonly<Record<string, unknown>>,
+  timestamp: number | undefined,
+): ObservedMessage {
+  switch (value.role) {
+    case "custom":
+      return {
+        ...value,
+        role: "custom",
+        timestamp,
+        customType: requiredString(value.customType, "customType"),
+        content: typeof value.content === "string" ? value.content : contentArray(value.content),
+        display: optionalBoolean(value.display, "display"),
+      };
+    case "bashExecution":
+      return {
+        ...value,
+        role: "bashExecution",
+        timestamp,
+        command: requiredString(value.command, "command"),
+        output: requiredString(value.output, "output"),
+        exitCode: optionalNumber(value.exitCode, "exitCode"),
+        cancelled: optionalBoolean(value.cancelled, "cancelled"),
+        truncated: optionalBoolean(value.truncated, "truncated"),
+        fullOutputPath: optionalString(value.fullOutputPath, "fullOutputPath"),
+        excludeFromContext: optionalBoolean(value.excludeFromContext, "excludeFromContext"),
+      };
+    case "branchSummary":
+      return {
+        ...value,
+        role: "branchSummary",
+        timestamp,
+        summary: requiredString(value.summary, "summary"),
+        fromId: value.fromId === null ? null : requiredString(value.fromId, "fromId"),
+      };
+    case "compactionSummary": {
+      const tokensBefore = optionalNumber(value.tokensBefore, "tokensBefore");
+      if (tokensBefore === undefined) {
+        throw new SyntaxError("Missing tokensBefore");
+      }
+      return {
+        ...value,
+        role: "compactionSummary",
+        timestamp,
+        summary: requiredString(value.summary, "summary"),
+        tokensBefore,
+      };
+    }
+    default:
+      throw new SyntaxError("Unsupported native message role");
+  }
+}
+
+export function observedMessage(value: unknown): ObservedMessage {
+  if (!isObject(value)) {
+    throw new SyntaxError("Invalid native message");
+  }
+  if (value.role === "assistant") {
+    return assistant(value);
+  }
+  const timestamp = optionalNumber(value.timestamp, "timestamp");
+  if (value.role === "toolResult") {
+    if (value.isError !== undefined && typeof value.isError !== "boolean") {
+      throw new SyntaxError("Invalid tool result isError");
+    }
+    return {
+      ...value,
+      role: "toolResult",
+      content: contentArray(value.content),
+      timestamp,
+      toolCallId: requiredString(value.toolCallId, "toolCallId"),
+      toolName: requiredString(value.toolName, "toolName"),
+      isError: value.isError,
+      observedExitCode: optionalNumber(value.observedExitCode, "observedExitCode"),
+      usage: observedUsage(value.usage),
+    };
+  }
+  if (value.role === "user" || value.role === "system") {
+    return {
+      ...value,
+      role: value.role,
+      timestamp,
+      content: typeof value.content === "string" ? value.content : contentArray(value.content),
+    };
+  }
+  return otherMessage(value, timestamp);
+}