@yielded/agent 0.1.0-beta.173 → 0.1.0-beta.174

package/src/capabilities/Budget.ts

@@ -262,6 +262,11 @@ const pruneRetiredHierarchy = (
   return nodes;
 };
 
+/** Internal lifetime misuse remains a defect, with an Error message and stack. */
+class RetiredBudgetHandle extends Schema.TaggedError<RetiredBudgetHandle>()("RetiredBudgetHandle", {
+  message: Schema.String,
+}) {}
+
 const makeNode = (
   ledger: Ref.Ref<BudgetLedger>,
   key: string,
@@ -273,7 +278,9 @@ const makeNode = (
 
   const retiredDefect = () =>
     Effect.die(
-      new Error(`Usage budget handle ${config.level}:${config.id} was used after retirement`),
+      RetiredBudgetHandle.make({
+        message: `Usage budget handle ${config.level}:${config.id} was used after retirement`,
+      }),
     );
 
   const liveHierarchy = (state: BudgetLedger): ReadonlyArray<LedgerNode> | undefined => {

package/src/capabilities/CodeMode.ts

@@ -300,11 +300,16 @@ const renderJsonSchemaType = (
   indent: string,
 ): string => {
   if (depth > MAX_RENDER_DEPTH) {
+    // oxlint-disable-next-line effect/no-untyped-throw, effect/no-native-error -- CodeMode.make synchronously bounds recursive Schema declaration rendering before creating the Tool.
     throw new Error("Code Mode declaration rendering exceeded its depth bound");
   }
   if (!isJsonSchemaRecord(schema)) {
+    // oxlint-disable-next-line effect/no-untyped-throw, effect/no-native-error -- CodeMode.make synchronously rejects unsupported JSON Schema declaration fragments.
     throw new Error(`Code Mode cannot render the JSON schema fragment ${JSON.stringify(schema)}`);
   }
+  // An empty schema is explicitly unconstrained, including Schema.Json's array items.
+  // This is a faithful declaration; unrecognized nonempty fragments still fail below.
+  if (Object.keys(schema).length === 0) return "unknown";
   const reference = schema.$ref;
 
   if (typeof reference === "string") {
@@ -314,6 +319,7 @@ const renderJsonSchemaType = (
     const resolved = key === undefined ? undefined : defs[key];
 
     if (resolved === undefined) {
+      // oxlint-disable-next-line effect/no-untyped-throw, effect/no-native-error -- CodeMode.make synchronously rejects unresolved declaration references.
       throw new Error(`Code Mode cannot resolve the JSON schema reference ${reference}`);
     }
 
@@ -353,6 +359,7 @@ const renderJsonSchemaType = (
     }
     case "array": {
       if (!("items" in schema)) {
+        // oxlint-disable-next-line effect/no-untyped-throw, effect/no-native-error -- CodeMode.make synchronously requires item schemas for array declarations.
         throw new Error("Code Mode cannot render an array schema without items");
       }
 
@@ -398,6 +405,7 @@ const renderJsonSchemaType = (
       break;
     }
   }
+  // oxlint-disable-next-line effect/no-untyped-throw, effect/no-native-error -- CodeMode.make synchronously rejects declaration schemas it cannot faithfully render.
   throw new Error(
     `Code Mode cannot render the JSON schema fragment ${JSON.stringify(schema).slice(0, 200)}; fix or simplify the Tool's Schema`,
   );
@@ -420,8 +428,26 @@ interface ResolvedMethod {
   readonly tool: Tool.Any;
 }
 
-const renderDeclarations = (methods: ReadonlyArray<ResolvedMethod>): string => {
-  const namespaces = new Map<string, Array<ResolvedMethod>>();
+interface RenderedMethod extends ResolvedMethod {
+  readonly declaration: string;
+}
+
+/** Render once at the synchronous construction boundary; describe only selects frozen declarations. */
+const renderMethodDeclaration = (method: string, tool: Tool.Any): string => {
+  const parameters = renderTopLevel(Tool.getJsonSchema(tool), "  ");
+  const success = renderTopLevel(Tool.getJsonSchemaFromSchema(tool.successSchema), "  ");
+
+  // A description is arbitrary text: newlines and comment terminators
+  // must not be able to break out of the documentation comment.
+  const safeDescription = tool.description?.replaceAll("*/", "*\\/").replaceAll(/\s*\n\s*/g, " ");
+
+  const description = safeDescription === undefined ? "" : `  /** ${safeDescription} */\n`;
+
+  return `${description}  ${method}(input: ${parameters}): Promise<${success}>;`;
+};
+
+const renderDeclarations = (methods: ReadonlyArray<RenderedMethod>): string => {
+  const namespaces = new Map<string, Array<RenderedMethod>>();
 
   for (const method of methods) {
     const existing = namespaces.get(method.namespace) ?? [];
@@ -431,20 +457,7 @@ const renderDeclarations = (methods: ReadonlyArray<ResolvedMethod>): string => {
   }
 
   const blocks = [...namespaces.entries()].map(([namespace, members]) => {
-    const lines = members.map((member) => {
-      const parameters = renderTopLevel(Tool.getJsonSchema(member.tool), "  ");
-      const success = renderTopLevel(Tool.getJsonSchemaFromSchema(member.tool.successSchema), "  ");
-
-      // A description is arbitrary text: newlines and comment terminators
-      // must not be able to break out of the documentation comment.
-      const safeDescription = member.tool.description
-        ?.replaceAll("*/", "*\\/")
-        .replaceAll(/\s*\n\s*/g, " ");
-
-      const description = safeDescription === undefined ? "" : `  /** ${safeDescription} */\n`;
-
-      return `${description}  ${member.method}(input: ${parameters}): Promise<${success}>;`;
-    });
+    const lines = members.map((member) => member.declaration);
 
     return `declare const ${namespace}: {\n${lines.join("\n")}\n};`;
   });
@@ -581,6 +594,7 @@ const make = <
     maxEgressBytes < 256 ||
     maxEgressBytes > 4 * 1024 * 1024
   ) {
+    // oxlint-disable-next-line effect/no-untyped-throw, effect/no-native-error -- CodeMode.make synchronously rejects invalid egress bounds before creating the Tool.
     throw new Error(
       `Code Mode maxEgressBytes must be an integer between 256 and ${4 * 1024 * 1024}; received ${String(maxEgressBytes)}`,
     );
@@ -593,15 +607,18 @@ const make = <
 
   for (const [namespace, namespaceMethods] of Object.entries(options.tools)) {
     if (Option.isNone(decodeIdentifier(namespace))) {
+      // oxlint-disable-next-line effect/no-untyped-throw, effect/no-native-error -- CodeMode.make synchronously requires valid JavaScript namespace identifiers.
       throw new Error(`Code Mode namespace ${namespace} is not a valid JavaScript identifier`);
     }
     const entries = Object.entries(namespaceMethods);
 
     if (entries.length === 0) {
+      // oxlint-disable-next-line effect/no-untyped-throw, effect/no-native-error -- CodeMode.make synchronously rejects namespaces without callable methods.
       throw new Error(`Code Mode namespace ${namespace} declares no methods`);
     }
     for (const [method, tool] of entries) {
       if (Option.isNone(decodeIdentifier(method))) {
+        // oxlint-disable-next-line effect/no-untyped-throw, effect/no-native-error -- CodeMode.make synchronously requires valid JavaScript method identifiers.
         throw new Error(
           `Code Mode method ${namespace}.${method} is not a valid JavaScript identifier`,
         );
@@ -609,6 +626,7 @@ const make = <
       const approval = tool.needsApproval;
 
       if (approval !== undefined && approval !== false) {
+        // oxlint-disable-next-line effect/no-untyped-throw, effect/no-native-error -- CodeMode.make synchronously rejects approval-requiring Tools from its programmatic allowlist.
         throw new Error(
           `Code Mode rejects Tool ${tool.name} (${namespace}.${method}): approval-requiring Tools cannot be invoked programmatically in the ephemeral slice`,
         );
@@ -616,6 +634,7 @@ const make = <
       const existing = toolsByName.get(tool.name);
 
       if (existing !== undefined && existing !== tool) {
+        // oxlint-disable-next-line effect/no-untyped-throw, effect/no-native-error -- CodeMode.make synchronously rejects conflicting Tools sharing one name.
         throw new Error(
           `Code Mode selected two different Tools named ${tool.name}; Tool names must identify one Tool`,
         );
@@ -626,15 +645,21 @@ const make = <
     }
   }
   if (methods.length === 0) {
+    // oxlint-disable-next-line effect/no-untyped-throw, effect/no-native-error -- CodeMode.make synchronously requires a nonempty Tool allowlist.
     throw new Error("Code Mode requires at least one allowlisted Tool");
   }
 
   // Declarations derive from the encoded Schemas and fail construction closed
   // on anything the renderer cannot express.
-  const declarations = renderDeclarations(methods);
+  const renderedMethods = methods.map((method): RenderedMethod => ({
+    ...method,
+    declaration: renderMethodDeclaration(method.method, method.tool),
+  }));
+
+  const declarations = renderDeclarations(renderedMethods);
 
   const methodsByPath = new Map(
-    methods.map((method) => [`${method.namespace}.${method.method}`, method]),
+    renderedMethods.map((method) => [`${method.namespace}.${method.method}`, method]),
   );
 
   const describe = Effect.fnUntraced(function* (
@@ -662,7 +687,7 @@ const make = <
       ),
     );
 
-    const selectedMethods: Array<ResolvedMethod> = [];
+    const selectedMethods: Array<RenderedMethod> = [];
 
     for (const path of paths) {
       const method = methodsByPath.get(path);
@@ -799,7 +824,13 @@ const make = <
     });
 
   const build = Effect.gen(function* () {
-    const captured = yield* Effect.context<never>();
+    const captured =
+      yield* Effect.context<
+        Tool.HandlerServices<
+          CodeModeSelectedRecord<Namespaces>[keyof CodeModeSelectedRecord<Namespaces>]
+        >
+      >();
+
     const redactionServices = yield* Effect.context<Exclude<RedactionRequirements, Scope.Scope>>();
     const configuredRedactor = options.redactEgress;
 
@@ -975,20 +1006,10 @@ const make = <
         );
       }).pipe(
         Effect.scoped,
-        // The live engine broker is re-provided innermost so a Layer built
-        // inside another Run can never shadow it; the captured construction
-        // context supplies the selected handlers' services (same idiom as
-        // Subagent.layer). TypeScript cannot reduce the deferred Exclude
-        // over the generic namespace record, so the same private-assertion
-        // contract as the engine's provideHookServices pins the identity
-        // that providing the captured Context leaves no requirements; it
-        // never bypasses validation.
+        // Keep invocation authority innermost while restoring the declared handler services.
         Effect.provideService(ToolBroker, broker),
-        Effect.provideContext(captured),
-      ) as Effect.Effect<
-        CodeExecutionResult,
-        CodeExecutionError | ToolBrokerUnavailableError | ToolBrokerConfigurationError
-      >;
+        Effect.updateContext((current: Context.Context<never>) => Context.merge(current, captured)),
+      );
 
       return yield* execution.pipe(
         Effect.catch((error) => failureEgress(error).pipe(Effect.flatMap(Effect.fail))),
@@ -1052,6 +1073,9 @@ const make = <
       never,
       | CodeExecutor
       | Tool.HandlersFor<CodeModeSelectedRecord<Namespaces>>
+      | Tool.HandlerServices<
+          CodeModeSelectedRecord<Namespaces>[keyof CodeModeSelectedRecord<Namespaces>]
+        >
       | Exclude<RedactionRequirements, Scope.Scope>
     >,
   ) as unknown as Layer.Layer<

package/src/capabilities/McpClient.ts

@@ -141,8 +141,8 @@ const isNotificationTag = (tag: string): boolean => tag.startsWith("notification
 const isRpcClientError = Schema.is(RpcClientError.RpcClientError);
 
 const protocolDefect = (message: string, cause?: unknown): RpcClientError.RpcClientError =>
-  new RpcClientError.RpcClientError({
-    reason: new RpcClientError.RpcClientDefect({ message, cause }),
+  RpcClientError.RpcClientError.make({
+    reason: RpcClientError.RpcClientDefect.make({ message, cause }),
   });
 
 const InitializeProtocolVersion = Schema.Struct({ protocolVersion: Schema.String });

package/src/capabilities/Messaging.ts

@@ -41,47 +41,46 @@ const host: Effect.Effect<MessagingHost["Service"], MessagingError, MessagingHos
     ),
   );
 
-const dispatch = <Name extends string, Input extends Schema.Top>(
+const dispatch = Effect.fnUntraced(function* <Name extends string, Input extends Schema.Top>(
   declaration: Peer<Name, Input>,
   input: Input["Type"],
   options: { readonly idempotencyKey: IdempotencyKey; readonly inReplyTo?: MessageRef },
   operation: "send" | "reply",
-) =>
-  Effect.gen(function* () {
-    const service = yield* host;
-    const invalid = () => MessagingError.make({ operation, reason: "invalid-input" });
-
-    const idempotencyKey = yield* Schema.decodeEffect(IdempotencyKey)(options.idempotencyKey).pipe(
-      Effect.mapError(invalid),
-    );
-
-    const encodedInput = yield* Schema.encodeEffect(declaration.target.input)(input).pipe(
-      Effect.mapError(invalid),
-    );
-
-    const inReplyTo =
-      options.inReplyTo === undefined
-        ? undefined
-        : yield* Schema.decodeEffect(MessageRef)(options.inReplyTo).pipe(Effect.mapError(invalid));
-
-    const request = {
-      ...declaration,
-      encodedInput,
-      idempotencyKey,
-      ...(inReplyTo === undefined ? {} : { inReplyTo }),
-    };
-
-    const result =
-      operation === "reply"
-        ? inReplyTo === undefined
-          ? yield* invalid()
-          : yield* service.reply({ ...request, inReplyTo })
-        : yield* service.send(request);
-
-    return yield* Schema.decodeEffect(MessageStatus)(result).pipe(
-      Effect.mapError(() => MessagingError.make({ operation, reason: "corrupt" })),
-    );
-  });
+) {
+  const service = yield* host;
+  const invalid = () => MessagingError.make({ operation, reason: "invalid-input" });
+
+  const idempotencyKey = yield* Schema.decodeEffect(IdempotencyKey)(options.idempotencyKey).pipe(
+    Effect.mapError(invalid),
+  );
+
+  const encodedInput = yield* Schema.encodeEffect(declaration.target.input)(input).pipe(
+    Effect.mapError(invalid),
+  );
+
+  const inReplyTo =
+    options.inReplyTo === undefined
+      ? undefined
+      : yield* Schema.decodeEffect(MessageRef)(options.inReplyTo).pipe(Effect.mapError(invalid));
+
+  const request = {
+    ...declaration,
+    encodedInput,
+    idempotencyKey,
+    ...(inReplyTo === undefined ? {} : { inReplyTo }),
+  };
+
+  const result =
+    operation === "reply"
+      ? inReplyTo === undefined
+        ? yield* invalid()
+        : yield* service.reply({ ...request, inReplyTo })
+      : yield* service.send(request);
+
+  return yield* Schema.decodeEffect(MessageStatus)(result).pipe(
+    Effect.mapError(() => MessagingError.make({ operation, reason: "corrupt" })),
+  );
+});
 
 /** Retain a durable message. Its status distinguishes outbound retention from destination acceptance. */
 export const send = <Name extends string, Input extends Schema.Top>(
@@ -99,36 +98,33 @@ export const reply = <Name extends string, Input extends Schema.Top>(
 ) => dispatch(declaration, input, { ...options, inReplyTo }, "reply");
 
 /** Return bounded provenance for messages from this peer, without granting permission to reply. */
-export const inbox = <Name extends string, Input extends Schema.Top>(
+export const inbox = Effect.fnUntraced(function* <Name extends string, Input extends Schema.Top>(
   declaration: Peer<Name, Input>,
   options: { readonly after?: number; readonly limit?: number } = {},
-) =>
-  Effect.gen(function* () {
-    const service = yield* host;
+) {
+  const service = yield* host;
 
-    return yield* service.inbox({ ...declaration, ...options, limit: options.limit ?? 20 });
-  });
+  return yield* service.inbox({ ...declaration, ...options, limit: options.limit ?? 20 });
+});
 
-export const inspect = <Name extends string, Input extends Schema.Top>(
+export const inspect = Effect.fnUntraced(function* <Name extends string, Input extends Schema.Top>(
   declaration: Peer<Name, Input>,
   message: MessageRef,
-) =>
-  Effect.gen(function* () {
-    const service = yield* host;
+) {
+  const service = yield* host;
 
-    return yield* service.inspect({ ...declaration, message });
-  });
+  return yield* service.inspect({ ...declaration, message });
+});
 
 /** Explicitly renew a parked delivery's bounded retry budget, retaining its complete frozen envelope. */
-export const retry = <Name extends string, Input extends Schema.Top>(
+export const retry = Effect.fnUntraced(function* <Name extends string, Input extends Schema.Top>(
   declaration: Peer<Name, Input>,
   message: MessageRef,
-) =>
-  Effect.gen(function* () {
-    const service = yield* host;
+) {
+  const service = yield* host;
 
-    return yield* service.retry({ ...declaration, message });
-  });
+  return yield* service.retry({ ...declaration, message });
+});
 
 const modelKey = Effect.fnUntraced(function* () {
   const source = yield* (yield* host).context;

package/src/capabilities/ModelContext.ts

@@ -177,8 +177,10 @@ export const prepareModelContext = <
 >(
   snapshot: ThreadSnapshot,
   transforms?: { readonly [Index in keyof Requirements]: ContextTransform<Requirements[Index]> },
-): Effect.Effect<PreparedModelContext, ContextTransformError, Requirements[number]> =>
-  (transforms ?? [])
+): Effect.Effect<PreparedModelContext, ContextTransformError, Requirements[number]> => {
+  const declared: ReadonlyArray<ContextTransform<Requirements[number]>> = transforms ?? [];
+
+  return declared
     .reduce<
       Effect.Effect<ReadonlyArray<ModelContextMessage>, ContextTransformError, Requirements[number]>
     >(
@@ -198,6 +200,7 @@ export const prepareModelContext = <
         }),
       ),
     );
+};
 
 const exactSourceRange = (
   snapshot: ThreadSnapshot,

package/src/capabilities/Redaction.ts

@@ -35,28 +35,67 @@ interface RedactionCounter {
   nodes: number;
 }
 
-const redactValue = (value: unknown, depth: number, counter: RedactionCounter): Schema.Json => {
+const encodingFailure = () =>
+  RedactionError.make({
+    reason: "encoding-failed",
+    message: "Could not encode the structurally redacted preview",
+  });
+
+const redactValue = Effect.fnUntraced(function* (
+  value: unknown,
+  depth: number,
+  counter: RedactionCounter,
+): Effect.fn.Return<Schema.Json, RedactionError> {
   if (depth > MAX_REDACTION_DEPTH) {
-    throw RedactionError.make({
+    return yield* RedactionError.make({
       reason: "input-too-deep",
       message: `Decoded value exceeds redaction depth ${MAX_REDACTION_DEPTH}`,
     });
   }
   counter.nodes += 1;
   if (counter.nodes > MAX_REDACTION_NODES) {
-    throw RedactionError.make({
+    return yield* RedactionError.make({
       reason: "input-too-large",
       message: `Decoded value exceeds redaction node count ${MAX_REDACTION_NODES}`,
     });
   }
-  if (Array.isArray(value)) {
-    return value.map((item) => redactValue(item, depth + 1, counter));
+
+  const collection = yield* Effect.try({
+    try: () => {
+      if (Array.isArray(value)) {
+        const redacted: Array<Schema.Json> = [];
+
+        redacted.length = value.length;
+
+        return { _tag: "Array" as const, values: value, redacted };
+      }
+
+      return value !== null && typeof value === "object"
+        ? { _tag: "Object" as const, entries: Object.entries(value) }
+        : undefined;
+    },
+    catch: encodingFailure,
+  });
+
+  if (collection?._tag === "Array") {
+    const { redacted } = collection;
+
+    for (let index = 0; index < redacted.length; index += 1) {
+      const item = yield* Effect.try({
+        try: () => (index in collection.values ? { value: collection.values[index] } : undefined),
+        catch: encodingFailure,
+      });
+
+      if (item !== undefined) redacted[index] = yield* redactValue(item.value, depth + 1, counter);
+    }
+
+    return redacted;
   }
-  if (value !== null && typeof value === "object") {
+  if (collection?._tag === "Object") {
     const redacted: Record<string, Schema.Json> = {};
 
-    for (const [key, item] of Object.entries(value)) {
-      redacted[key] = redactValue(item, depth + 1, counter);
+    for (const [key, item] of collection.entries) {
+      redacted[key] = yield* redactValue(item, depth + 1, counter);
     }
 
     return redacted;
@@ -72,7 +111,7 @@ const redactValue = (value: unknown, depth: number, counter: RedactionCounter):
   if (typeof value === "boolean") return "[REDACTED:boolean]";
 
   return "[REDACTED:unsupported]";
-};
+});
 
 const truncateUtf8 = (value: string, maxBytes: number): string => {
   if (utf8ByteLength(value) <= maxBytes) {
@@ -128,30 +167,21 @@ export const redactedTranscript = (
  * Tool-specific Layers may expose explicitly reviewed fields instead.
  */
 export const StructuralRedactorLive = Layer.succeed(Redactor)({
-  redact: (decodedValue) =>
-    Effect.try({
-      try: () => {
-        const structurallyRedacted = redactValue(decodedValue, 0, { nodes: 0 });
-
-        return truncateUtf8(JSON.stringify(structurallyRedacted), MAX_REDACTED_PREVIEW_BYTES);
-      },
-      catch: (cause) =>
-        Schema.is(RedactionError)(cause)
-          ? cause
-          : RedactionError.make({
-              reason: "encoding-failed",
-              message: "Could not encode the structurally redacted preview",
-            }),
-    }).pipe(
-      Effect.flatMap((preview) =>
-        Schema.decodeEffect(RedactedPreview)(preview).pipe(
-          Effect.mapError(() =>
-            RedactionError.make({
-              reason: "encoding-failed",
-              message: "Redacted preview did not satisfy its bounded schema",
-            }),
-          ),
-        ),
+  redact: Effect.fnUntraced(function* (decodedValue) {
+    const structurallyRedacted = yield* redactValue(decodedValue, 0, { nodes: 0 });
+
+    const preview = yield* Effect.try({
+      try: () => truncateUtf8(JSON.stringify(structurallyRedacted), MAX_REDACTED_PREVIEW_BYTES),
+      catch: encodingFailure,
+    });
+
+    return yield* Schema.decodeEffect(RedactedPreview)(preview).pipe(
+      Effect.mapError(() =>
+        RedactionError.make({
+          reason: "encoding-failed",
+          message: "Redacted preview did not satisfy its bounded schema",
+        }),
       ),
-    ),
+    );
+  }),
 });

package/src/capabilities/RunHooks.ts

@@ -82,70 +82,67 @@ export const toRunApprovalHook = (
   | RedactionError,
   ApprovalResolver | ApprovalAudit | Redactor
 > => ({
-  request: (engineRequest) =>
-    Effect.gen(function* () {
-      const validatedPolicy = yield* Schema.decodeEffect(RunApprovalAdapterPolicySchema)(
-        policy,
-      ).pipe(
-        Effect.mapError((error) =>
-          ApprovalAdapterError.make({
-            message: `Approval adapter policy is invalid: ${error.message}`,
-          }),
-        ),
-      );
+  request: Effect.fnUntraced(function* (engineRequest) {
+    const validatedPolicy = yield* Schema.decodeEffect(RunApprovalAdapterPolicySchema)(policy).pipe(
+      Effect.mapError((error) =>
+        ApprovalAdapterError.make({
+          message: `Approval adapter policy is invalid: ${error.message}`,
+        }),
+      ),
+    );
 
-      const now = yield* Clock.currentTimeMillis;
+    const now = yield* Clock.currentTimeMillis;
 
-      const metadata = yield* Effect.try({
-        try: () => ({
-          actionSummary: policy.actionSummary(engineRequest),
-          resourceTargets: policy.resourceTargets(engineRequest),
+    const metadata = yield* Effect.try({
+      try: () => ({
+        actionSummary: policy.actionSummary(engineRequest),
+        resourceTargets: policy.resourceTargets(engineRequest),
+      }),
+      catch: () =>
+        ApprovalAdapterError.make({
+          message: "Approval policy failed while describing the native Tool request",
         }),
-        catch: () =>
-          ApprovalAdapterError.make({
-            message: "Approval policy failed while describing the native Tool request",
-          }),
-      });
-
-      const draft = yield* Schema.decodeEffect(ApprovalRequestDraft)({
-        requestId: engineRequest.request.approvalId,
-        runId: engineRequest.runId,
-        threadId: engineRequest.threadId,
-        toolCallId: engineRequest.toolCallId,
-        toolName: engineRequest.toolName,
-        actionSummary: metadata.actionSummary,
-        resourceTargets: metadata.resourceTargets,
-        risk: validatedPolicy.risk,
-        expiresAt: DateTime.formatIso(
-          DateTime.toUtc(DateTime.makeUnsafe(now + validatedPolicy.expiresInMillis)),
-        ),
-        denial: validatedPolicy.denial,
-      }).pipe(
-        Effect.mapError((error) =>
-          ApprovalAdapterError.make({
-            message: `Approval adapter policy is invalid: ${error.message}`,
-          }),
-        ),
-      );
+    });
 
-      const request = yield* makeApprovalRequest(draft, engineRequest.parameters);
-      const decision = yield* requestApproval(request);
+    const draft = yield* Schema.decodeEffect(ApprovalRequestDraft)({
+      requestId: engineRequest.request.approvalId,
+      runId: engineRequest.runId,
+      threadId: engineRequest.threadId,
+      toolCallId: engineRequest.toolCallId,
+      toolName: engineRequest.toolName,
+      actionSummary: metadata.actionSummary,
+      resourceTargets: metadata.resourceTargets,
+      risk: validatedPolicy.risk,
+      expiresAt: DateTime.formatIso(
+        DateTime.toUtc(DateTime.makeUnsafe(now + validatedPolicy.expiresInMillis)),
+      ),
+      denial: validatedPolicy.denial,
+    }).pipe(
+      Effect.mapError((error) =>
+        ApprovalAdapterError.make({
+          message: `Approval adapter policy is invalid: ${error.message}`,
+        }),
+      ),
+    );
 
-      if (decision._tag === "ApprovalApproved") {
-        return { _tag: "approved" as const };
-      }
-      if (decision.timedOut && request.denial === "recoverable") {
-        return {
-          _tag: "unresolved" as const,
-          reason: decision.reason,
-        };
-      }
+    const request = yield* makeApprovalRequest(draft, engineRequest.parameters);
+    const decision = yield* requestApproval(request);
 
+    if (decision._tag === "ApprovalApproved") {
+      return { _tag: "approved" as const };
+    }
+    if (decision.timedOut && request.denial === "recoverable") {
       return {
-        _tag: "denied" as const,
+        _tag: "unresolved" as const,
         reason: decision.reason,
       };
-    }),
+    }
+
+    return {
+      _tag: "denied" as const,
+      reason: decision.reason,
+    };
+  }),
 });
 
 /**