langchain 1.5.16 → 1.5.18

package/dist/agents/middleware/hitl.d.ts

@@ -1,10 +1,12 @@
 import { AgentBuiltInState, Runtime } from "../runtime.js";
 import { AgentMiddleware, ToolCallRequest } from "./types.js";
+import { Interrupt } from "../types.js";
 import { ToolCall } from "@langchain/core/messages";
 import { InferInteropZodInput } from "@langchain/core/utils/types";
-import { z } from "zod/v3";
+import { z } from "zod/v4";
+import { z as z$1 } from "zod/v3";
 //#region src/agents/middleware/hitl.d.ts
-declare const WhenFunctionSchema: z.ZodFunction<z.ZodTuple<[z.ZodType<ToolCallRequest<AgentBuiltInState, unknown>, z.ZodTypeDef, ToolCallRequest<AgentBuiltInState, unknown>>], z.ZodUnknown>, z.ZodUnion<[z.ZodBoolean, z.ZodPromise<z.ZodBoolean>]>>;
+declare const WhenFunctionSchema: z$1.ZodFunction<z$1.ZodTuple<[z$1.ZodType<ToolCallRequest<AgentBuiltInState, unknown>, z$1.ZodTypeDef, ToolCallRequest<AgentBuiltInState, unknown>>], z$1.ZodUnknown>, z$1.ZodUnion<[z$1.ZodBoolean, z$1.ZodPromise<z$1.ZodBoolean>]>>;
 /**
  * Predicate controlling whether a given tool call triggers an interrupt.
  *
@@ -13,7 +15,12 @@ declare const WhenFunctionSchema: z.ZodFunction<z.ZodTuple<[z.ZodType<ToolCallRe
  *
  * The request is constructed with `tool` set to `undefined` and `runtime` set to
  * the node-level {@link Runtime}, so it reflects the batch (`afterModel`) context
- * rather than a per-call tool execution.
+ * rather than a per-call tool execution. In `"per_call"` mode the predicate runs
+ * in `wrapToolCall` and receives the real request, with `tool` set.
+ *
+ * In both modes the predicate runs again when the run resumes, so it must return
+ * the same answer for the same call. If it returns `false` on resume, the
+ * reviewer's answer is skipped and the tool runs, even if they rejected it.
  *
  * @param request - The tool call request being evaluated
  * @returns `true` to interrupt for the tool call, `false` to auto-approve it.
@@ -28,8 +35,8 @@ declare const WhenFunctionSchema: z.ZodFunction<z.ZodTuple<[z.ZodType<ToolCallRe
  *   String(request.toolCall.args.path ?? "").startsWith("/etc");
  * ```
  */
-export type WhenPredicate = z.infer<typeof WhenFunctionSchema>;
-declare const DescriptionFunctionSchema: z.ZodFunction<z.ZodTuple<[z.ZodType<ToolCall<string, Record<string, any>>, z.ZodTypeDef, ToolCall<string, Record<string, any>>>, z.ZodType<AgentBuiltInState, z.ZodTypeDef, AgentBuiltInState>, z.ZodType<Runtime<unknown>, z.ZodTypeDef, Runtime<unknown>>], z.ZodUnknown>, z.ZodUnion<[z.ZodString, z.ZodPromise<z.ZodString>]>>;
+export type WhenPredicate = z$1.infer<typeof WhenFunctionSchema>;
+declare const DescriptionFunctionSchema: z$1.ZodFunction<z$1.ZodTuple<[z$1.ZodType<ToolCall<string, Record<string, any>>, z$1.ZodTypeDef, ToolCall<string, Record<string, any>>>, z$1.ZodType<AgentBuiltInState, z$1.ZodTypeDef, AgentBuiltInState>, z$1.ZodType<Runtime<unknown>, z$1.ZodTypeDef, Runtime<unknown>>], z$1.ZodUnknown>, z$1.ZodUnion<[z$1.ZodString, z$1.ZodPromise<z$1.ZodString>]>>;
 /**
  * Function type that dynamically generates a description for a tool call approval request.
  *
@@ -47,14 +54,14 @@ declare const DescriptionFunctionSchema: z.ZodFunction<z.ZodTuple<[z.ZodType<Too
  * };
  * ```
  */
-export type DescriptionFactory = z.infer<typeof DescriptionFunctionSchema>;
-declare const DecisionType: z.ZodEnum<["approve", "edit", "reject"]>;
-type DecisionType = z.infer<typeof DecisionType>;
-declare const InterruptOnConfigSchema: z.ZodObject<{
+export type DescriptionFactory = z$1.infer<typeof DescriptionFunctionSchema>;
+declare const DecisionType: z$1.ZodEnum<["approve", "edit", "reject", "respond"]>;
+type DecisionType = z$1.infer<typeof DecisionType>;
+declare const InterruptOnConfigSchema: z$1.ZodObject<{
   /**
    * The decisions that are allowed for this action.
    */
-  allowedDecisions: z.ZodArray<z.ZodEnum<["approve", "edit", "reject"]>, "many">;
+  allowedDecisions: z$1.ZodArray<z$1.ZodEnum<["approve", "edit", "reject", "respond"]>, "many">;
   /**
    * The description attached to the request for human input.
    * Can be either:
@@ -98,11 +105,14 @@ declare const InterruptOnConfigSchema: z.ZodObject<{
    * };
    * ```
    */
-  description: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodFunction<z.ZodTuple<[z.ZodType<ToolCall<string, Record<string, any>>, z.ZodTypeDef, ToolCall<string, Record<string, any>>>, z.ZodType<AgentBuiltInState, z.ZodTypeDef, AgentBuiltInState>, z.ZodType<Runtime<unknown>, z.ZodTypeDef, Runtime<unknown>>], z.ZodUnknown>, z.ZodUnion<[z.ZodString, z.ZodPromise<z.ZodString>]>>]>>;
+  description: z$1.ZodOptional<z$1.ZodUnion<[z$1.ZodString, z$1.ZodFunction<z$1.ZodTuple<[z$1.ZodType<ToolCall<string, Record<string, any>>, z$1.ZodTypeDef, ToolCall<string, Record<string, any>>>, z$1.ZodType<AgentBuiltInState, z$1.ZodTypeDef, AgentBuiltInState>, z$1.ZodType<Runtime<unknown>, z$1.ZodTypeDef, Runtime<unknown>>], z$1.ZodUnknown>, z$1.ZodUnion<[z$1.ZodString, z$1.ZodPromise<z$1.ZodString>]>>]>>;
   /**
    * JSON schema for the arguments associated with the action, if edits are allowed.
+   *
+   * Not used in `"per_call"` mode: an edit's `args` are checked against the tool's
+   * own schema there.
    */
-  argsSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+  argsSchema: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodAny>>;
   /**
    * Optional predicate controlling whether to interrupt for a given tool call.
    *
@@ -110,7 +120,9 @@ declare const InterruptOnConfigSchema: z.ZodObject<{
    * `false` to auto-approve the tool call.
    *
    * The request is constructed with `tool` set to `undefined` and `runtime` set
-   * to the node-level {@link Runtime}, so `request.tool` is not available.
+   * to the node-level {@link Runtime}, so `request.tool` is not available. In
+   * `"per_call"` mode the predicate runs in `wrapToolCall` and receives the real
+   * request, with `tool` set.
    *
    * @example
    * ```typescript
@@ -124,19 +136,19 @@ declare const InterruptOnConfigSchema: z.ZodObject<{
    * };
    * ```
    */
-  when: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodType<ToolCallRequest<AgentBuiltInState, unknown>, z.ZodTypeDef, ToolCallRequest<AgentBuiltInState, unknown>>], z.ZodUnknown>, z.ZodUnion<[z.ZodBoolean, z.ZodPromise<z.ZodBoolean>]>>>;
-}, "strip", z.ZodTypeAny, {
-  allowedDecisions: ("approve" | "edit" | "reject")[];
+  when: z$1.ZodOptional<z$1.ZodFunction<z$1.ZodTuple<[z$1.ZodType<ToolCallRequest<AgentBuiltInState, unknown>, z$1.ZodTypeDef, ToolCallRequest<AgentBuiltInState, unknown>>], z$1.ZodUnknown>, z$1.ZodUnion<[z$1.ZodBoolean, z$1.ZodPromise<z$1.ZodBoolean>]>>>;
+}, "strip", z$1.ZodTypeAny, {
+  allowedDecisions: ("approve" | "edit" | "reject" | "respond")[];
   description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;
   argsSchema?: Record<string, any> | undefined;
   when?: ((args_0: ToolCallRequest<AgentBuiltInState, unknown>, ...args: unknown[]) => boolean | Promise<boolean>) | undefined;
 }, {
-  allowedDecisions: ("approve" | "edit" | "reject")[];
+  allowedDecisions: ("approve" | "edit" | "reject" | "respond")[];
   description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;
   argsSchema?: Record<string, any> | undefined;
   when?: ((args_0: ToolCallRequest<AgentBuiltInState, unknown>, ...args: unknown[]) => boolean | Promise<boolean>) | undefined;
 }>;
-export type InterruptOnConfig = z.input<typeof InterruptOnConfigSchema>;
+export type InterruptOnConfig = z$1.input<typeof InterruptOnConfigSchema>;
 /**
  * Represents an action with a name and arguments.
  */
@@ -241,10 +253,20 @@ export interface RejectDecision {
    */
   message?: string;
 }
+/**
+ * Response when a human answers on behalf of the tool.
+ */
+export interface RespondDecision {
+  type: "respond";
+  /**
+   * The message sent to the model as the tool result.
+   */
+  message: string;
+}
 /**
  * Union of all possible decision types.
  */
-export type Decision = ApproveDecision | EditDecision | RejectDecision;
+export type Decision = ApproveDecision | EditDecision | RejectDecision | RespondDecision;
 /**
  * Response payload for a HITLRequest.
  */
@@ -254,20 +276,66 @@ export interface HITLResponse {
    */
   decisions: Decision[];
 }
-declare const contextSchema: z.ZodObject<{
+declare const ToolApprovalRequestSchema: z.ZodObject<{
+  type: z.ZodLiteral<"tool_approval">;
+  tool_call_id: z.ZodString;
+  name: z.ZodString;
+  args: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+  description: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Interrupt value raised once per gated tool call in `"per_call"` mode. Keys are
+ * snake_case, as in Python.
+ */
+export type ToolApprovalRequest = z.infer<typeof ToolApprovalRequestSchema>;
+/**
+ * The answers a reviewer can give to a `"per_call"` approval of tool `name`, by type.
+ *
+ * The edit can't switch tools: its `name` is pinned.
+ */
+declare const toolApprovalDecisions: (name: string, tool?: ToolCallRequest["tool"]) => {
+  approve: z.ZodObject<{
+    type: z.ZodLiteral<"approve">;
+  }, z.core.$strip>;
+  edit: z.ZodObject<{
+    type: z.ZodLiteral<"edit">;
+    edited_action: z.ZodObject<{
+      name: z.ZodLiteral<string>;
+      args: z.ZodType<Record<string, unknown>, unknown, z.core.$ZodTypeInternals<Record<string, unknown>, unknown>>;
+    }, z.core.$strip>;
+  }, z.core.$strip>;
+  reject: z.ZodObject<{
+    type: z.ZodLiteral<"reject">;
+    message: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>;
+  respond: z.ZodObject<{
+    type: z.ZodLiteral<"respond">;
+    message: z.ZodString;
+  }, z.core.$strip>;
+};
+/**
+ * A reviewer's answer to a `"per_call"` tool approval.
+ */
+export type ToolApprovalDecision = z.infer<ReturnType<typeof toolApprovalDecisions>[DecisionType]>;
+/**
+ * Whether an interrupt is a `"per_call"` tool approval, e.g.
+ * `result.__interrupt__?.filter(isToolApprovalInterrupt)`.
+ */
+export declare function isToolApprovalInterrupt(interrupt: Interrupt | undefined): interrupt is Interrupt<ToolApprovalRequest>;
+declare const contextSchema: z$1.ZodObject<{
   /**
    * Mapping of tool name to allowed reviewer responses.
    * If a tool doesn't have an entry, it's auto-approved by default.
    *
-   * - `true` -> pause for approval and allow approve/edit/reject decisions
+   * - `true` -> pause for approval and allow every decision (approve/edit/reject/respond)
    * - `false` -> auto-approve (no human review)
    * - `InterruptOnConfig` -> explicitly specify which decisions are allowed for this tool
    */
-  interruptOn: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodBoolean, z.ZodObject<{
+  interruptOn: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodUnion<[z$1.ZodBoolean, z$1.ZodObject<{
     /**
      * The decisions that are allowed for this action.
      */
-    allowedDecisions: z.ZodArray<z.ZodEnum<["approve", "edit", "reject"]>, "many">;
+    allowedDecisions: z$1.ZodArray<z$1.ZodEnum<["approve", "edit", "reject", "respond"]>, "many">;
     /**
      * The description attached to the request for human input.
      * Can be either:
@@ -311,11 +379,14 @@ declare const contextSchema: z.ZodObject<{
      * };
      * ```
      */
-    description: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodFunction<z.ZodTuple<[z.ZodType<ToolCall<string, Record<string, any>>, z.ZodTypeDef, ToolCall<string, Record<string, any>>>, z.ZodType<AgentBuiltInState, z.ZodTypeDef, AgentBuiltInState>, z.ZodType<Runtime<unknown>, z.ZodTypeDef, Runtime<unknown>>], z.ZodUnknown>, z.ZodUnion<[z.ZodString, z.ZodPromise<z.ZodString>]>>]>>;
+    description: z$1.ZodOptional<z$1.ZodUnion<[z$1.ZodString, z$1.ZodFunction<z$1.ZodTuple<[z$1.ZodType<ToolCall<string, Record<string, any>>, z$1.ZodTypeDef, ToolCall<string, Record<string, any>>>, z$1.ZodType<AgentBuiltInState, z$1.ZodTypeDef, AgentBuiltInState>, z$1.ZodType<Runtime<unknown>, z$1.ZodTypeDef, Runtime<unknown>>], z$1.ZodUnknown>, z$1.ZodUnion<[z$1.ZodString, z$1.ZodPromise<z$1.ZodString>]>>]>>;
     /**
      * JSON schema for the arguments associated with the action, if edits are allowed.
+     *
+     * Not used in `"per_call"` mode: an edit's `args` are checked against the tool's
+     * own schema there.
      */
-    argsSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    argsSchema: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodAny>>;
     /**
      * Optional predicate controlling whether to interrupt for a given tool call.
      *
@@ -323,7 +394,9 @@ declare const contextSchema: z.ZodObject<{
      * `false` to auto-approve the tool call.
      *
      * The request is constructed with `tool` set to `undefined` and `runtime` set
-     * to the node-level {@link Runtime}, so `request.tool` is not available.
+     * to the node-level {@link Runtime}, so `request.tool` is not available. In
+     * `"per_call"` mode the predicate runs in `wrapToolCall` and receives the real
+     * request, with `tool` set.
      *
      * @example
      * ```typescript
@@ -337,14 +410,14 @@ declare const contextSchema: z.ZodObject<{
      * };
      * ```
      */
-    when: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodType<ToolCallRequest<AgentBuiltInState, unknown>, z.ZodTypeDef, ToolCallRequest<AgentBuiltInState, unknown>>], z.ZodUnknown>, z.ZodUnion<[z.ZodBoolean, z.ZodPromise<z.ZodBoolean>]>>>;
-  }, "strip", z.ZodTypeAny, {
-    allowedDecisions: ("approve" | "edit" | "reject")[];
+    when: z$1.ZodOptional<z$1.ZodFunction<z$1.ZodTuple<[z$1.ZodType<ToolCallRequest<AgentBuiltInState, unknown>, z$1.ZodTypeDef, ToolCallRequest<AgentBuiltInState, unknown>>], z$1.ZodUnknown>, z$1.ZodUnion<[z$1.ZodBoolean, z$1.ZodPromise<z$1.ZodBoolean>]>>>;
+  }, "strip", z$1.ZodTypeAny, {
+    allowedDecisions: ("approve" | "edit" | "reject" | "respond")[];
     description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;
     argsSchema?: Record<string, any> | undefined;
     when?: ((args_0: ToolCallRequest<AgentBuiltInState, unknown>, ...args: unknown[]) => boolean | Promise<boolean>) | undefined;
   }, {
-    allowedDecisions: ("approve" | "edit" | "reject")[];
+    allowedDecisions: ("approve" | "edit" | "reject" | "respond")[];
     description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;
     argsSchema?: Record<string, any> | undefined;
     when?: ((args_0: ToolCallRequest<AgentBuiltInState, unknown>, ...args: unknown[]) => boolean | Promise<boolean>) | undefined;
@@ -357,10 +430,10 @@ declare const contextSchema: z.ZodObject<{
    * `description` via their {@link InterruptOnConfig}. If a tool specifies a custom
    * `description`, that per-tool text is used and this prefix is ignored.
    */
-  descriptionPrefix: z.ZodDefault<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
+  descriptionPrefix: z$1.ZodDefault<z$1.ZodString>;
+}, "strip", z$1.ZodTypeAny, {
   interruptOn?: Record<string, boolean | {
-    allowedDecisions: ("approve" | "edit" | "reject")[];
+    allowedDecisions: ("approve" | "edit" | "reject" | "respond")[];
     description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;
     argsSchema?: Record<string, any> | undefined;
     when?: ((args_0: ToolCallRequest<AgentBuiltInState, unknown>, ...args: unknown[]) => boolean | Promise<boolean>) | undefined;
@@ -368,14 +441,49 @@ declare const contextSchema: z.ZodObject<{
   descriptionPrefix: string;
 }, {
   interruptOn?: Record<string, boolean | {
-    allowedDecisions: ("approve" | "edit" | "reject")[];
+    allowedDecisions: ("approve" | "edit" | "reject" | "respond")[];
     description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;
     argsSchema?: Record<string, any> | undefined;
     when?: ((args_0: ToolCallRequest<AgentBuiltInState, unknown>, ...args: unknown[]) => boolean | Promise<boolean>) | undefined;
   }> | undefined;
   descriptionPrefix?: string | undefined;
 }>;
-export type HumanInTheLoopMiddlewareConfig = InferInteropZodInput<typeof contextSchema>;
+export type HumanInTheLoopMiddlewareConfig = InferInteropZodInput<typeof contextSchema> & {
+  /**
+   * How the middleware pauses for review. Set at construction only.
+   *
+   * - `"batched"` (default): one interrupt per model turn for all gated tool calls.
+   * - `"per_call"`: one {@link ToolApprovalRequest} interrupt per gated call, with a
+   *   typed `responseSchema`, answered with a single decision keyed by interrupt ID.
+   *
+   * In `"per_call"` mode, LangGraph checks each answer before saving it:
+   *
+   * - An edit can't switch tools, and its args must match the tool's argument
+   *   types. Args the tool doesn't declare are handled as they are when the model
+   *   sends them. For a tool without a Zod v4 object schema, any object is accepted
+   *   and the tool checks it when it runs.
+   * - An invalid answer throws a `ZodError` and isn't saved, so the same interrupt
+   *   can be answered again.
+   *
+   * If one of several answers sent together is invalid, the others' tools may
+   * already have run even if they still show as pending, and answering them again
+   * would run them twice. Check answers against `responseSchema` before sending them
+   * together, or send one at a time.
+   *
+   * The review happens as the tool call starts, inside the tool-call middleware
+   * chain. List this middleware before tool retry or error-handling middleware so it
+   * wraps them. On resume, each paused tool call runs the middleware listed before
+   * this one again up to the pause, so that middleware must not have side effects
+   * before calling `handler`. The tool itself runs only after the answer.
+   */
+  interruptMode?: "batched" | "per_call";
+  /**
+   * `"per_call"` mode only: text prepended to the result of a tool call a reviewer
+   * edited, so the model knows the call it made isn't the one that ran. Pass `null`
+   * to add nothing.
+   */
+  editNotice?: string | null;
+};
 /**
  * Creates a Human-in-the-Loop (HITL) middleware for tool approval and oversight.
  *
@@ -578,28 +686,29 @@ export type HumanInTheLoopMiddlewareConfig = InferInteropZodInput<typeof context
  * @remarks
  * - Tool calls are processed in the order they appear in the AI message
  * - Auto-approved tools execute immediately without interruption
- * - Multiple tools requiring approval are bundled into a single interrupt request
- * - The middleware operates in the `afterModel` phase, intercepting before tool execution
+ * - In the default `"batched"` mode, multiple tools requiring approval are bundled into a
+ *   single interrupt request, raised in the `afterModel` phase before any tool runs. In
+ *   `"per_call"` mode, each gated call raises its own interrupt from `wrapToolCall`
  * - Requires a checkpointer to maintain state across interruptions
  *
  * @see {@link createAgent} for agent creation
  * @see {@link Command} for resuming interrupted execution
  * @public
  */
-export declare function humanInTheLoopMiddleware(options: NonNullable<HumanInTheLoopMiddlewareConfig>): AgentMiddleware<undefined, z.ZodObject<{
+export declare function humanInTheLoopMiddleware(options: NonNullable<HumanInTheLoopMiddlewareConfig>): AgentMiddleware<undefined, z$1.ZodObject<{
   /**
    * Mapping of tool name to allowed reviewer responses.
    * If a tool doesn't have an entry, it's auto-approved by default.
    *
-   * - `true` -> pause for approval and allow approve/edit/reject decisions
+   * - `true` -> pause for approval and allow every decision (approve/edit/reject/respond)
    * - `false` -> auto-approve (no human review)
    * - `InterruptOnConfig` -> explicitly specify which decisions are allowed for this tool
    */
-  interruptOn: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodBoolean, z.ZodObject<{
+  interruptOn: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodUnion<[z$1.ZodBoolean, z$1.ZodObject<{
     /**
      * The decisions that are allowed for this action.
      */
-    allowedDecisions: z.ZodArray<z.ZodEnum<["approve", "edit", "reject"]>, "many">;
+    allowedDecisions: z$1.ZodArray<z$1.ZodEnum<["approve", "edit", "reject", "respond"]>, "many">;
     /**
      * The description attached to the request for human input.
      * Can be either:
@@ -643,11 +752,14 @@ export declare function humanInTheLoopMiddleware(options: NonNullable<HumanInThe
      * };
      * ```
      */
-    description: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodFunction<z.ZodTuple<[z.ZodType<ToolCall<string, Record<string, any>>, z.ZodTypeDef, ToolCall<string, Record<string, any>>>, z.ZodType<AgentBuiltInState, z.ZodTypeDef, AgentBuiltInState>, z.ZodType<Runtime<unknown>, z.ZodTypeDef, Runtime<unknown>>], z.ZodUnknown>, z.ZodUnion<[z.ZodString, z.ZodPromise<z.ZodString>]>>]>>;
+    description: z$1.ZodOptional<z$1.ZodUnion<[z$1.ZodString, z$1.ZodFunction<z$1.ZodTuple<[z$1.ZodType<ToolCall<string, Record<string, any>>, z$1.ZodTypeDef, ToolCall<string, Record<string, any>>>, z$1.ZodType<AgentBuiltInState, z$1.ZodTypeDef, AgentBuiltInState>, z$1.ZodType<Runtime<unknown>, z$1.ZodTypeDef, Runtime<unknown>>], z$1.ZodUnknown>, z$1.ZodUnion<[z$1.ZodString, z$1.ZodPromise<z$1.ZodString>]>>]>>;
     /**
      * JSON schema for the arguments associated with the action, if edits are allowed.
+     *
+     * Not used in `"per_call"` mode: an edit's `args` are checked against the tool's
+     * own schema there.
      */
-    argsSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    argsSchema: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodAny>>;
     /**
      * Optional predicate controlling whether to interrupt for a given tool call.
      *
@@ -655,7 +767,9 @@ export declare function humanInTheLoopMiddleware(options: NonNullable<HumanInThe
      * `false` to auto-approve the tool call.
      *
      * The request is constructed with `tool` set to `undefined` and `runtime` set
-     * to the node-level {@link Runtime}, so `request.tool` is not available.
+     * to the node-level {@link Runtime}, so `request.tool` is not available. In
+     * `"per_call"` mode the predicate runs in `wrapToolCall` and receives the real
+     * request, with `tool` set.
      *
      * @example
      * ```typescript
@@ -669,14 +783,14 @@ export declare function humanInTheLoopMiddleware(options: NonNullable<HumanInThe
      * };
      * ```
      */
-    when: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodType<ToolCallRequest<AgentBuiltInState, unknown>, z.ZodTypeDef, ToolCallRequest<AgentBuiltInState, unknown>>], z.ZodUnknown>, z.ZodUnion<[z.ZodBoolean, z.ZodPromise<z.ZodBoolean>]>>>;
-  }, "strip", z.ZodTypeAny, {
-    allowedDecisions: ("approve" | "edit" | "reject")[];
+    when: z$1.ZodOptional<z$1.ZodFunction<z$1.ZodTuple<[z$1.ZodType<ToolCallRequest<AgentBuiltInState, unknown>, z$1.ZodTypeDef, ToolCallRequest<AgentBuiltInState, unknown>>], z$1.ZodUnknown>, z$1.ZodUnion<[z$1.ZodBoolean, z$1.ZodPromise<z$1.ZodBoolean>]>>>;
+  }, "strip", z$1.ZodTypeAny, {
+    allowedDecisions: ("approve" | "edit" | "reject" | "respond")[];
     description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;
     argsSchema?: Record<string, any> | undefined;
     when?: ((args_0: ToolCallRequest<AgentBuiltInState, unknown>, ...args: unknown[]) => boolean | Promise<boolean>) | undefined;
   }, {
-    allowedDecisions: ("approve" | "edit" | "reject")[];
+    allowedDecisions: ("approve" | "edit" | "reject" | "respond")[];
     description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;
     argsSchema?: Record<string, any> | undefined;
     when?: ((args_0: ToolCallRequest<AgentBuiltInState, unknown>, ...args: unknown[]) => boolean | Promise<boolean>) | undefined;
@@ -689,10 +803,10 @@ export declare function humanInTheLoopMiddleware(options: NonNullable<HumanInThe
    * `description` via their {@link InterruptOnConfig}. If a tool specifies a custom
    * `description`, that per-tool text is used and this prefix is ignored.
    */
-  descriptionPrefix: z.ZodDefault<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
+  descriptionPrefix: z$1.ZodDefault<z$1.ZodString>;
+}, "strip", z$1.ZodTypeAny, {
   interruptOn?: Record<string, boolean | {
-    allowedDecisions: ("approve" | "edit" | "reject")[];
+    allowedDecisions: ("approve" | "edit" | "reject" | "respond")[];
     description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;
     argsSchema?: Record<string, any> | undefined;
     when?: ((args_0: ToolCallRequest<AgentBuiltInState, unknown>, ...args: unknown[]) => boolean | Promise<boolean>) | undefined;
@@ -700,7 +814,7 @@ export declare function humanInTheLoopMiddleware(options: NonNullable<HumanInThe
   descriptionPrefix: string;
 }, {
   interruptOn?: Record<string, boolean | {
-    allowedDecisions: ("approve" | "edit" | "reject")[];
+    allowedDecisions: ("approve" | "edit" | "reject" | "respond")[];
     description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;
     argsSchema?: Record<string, any> | undefined;
     when?: ((args_0: ToolCallRequest<AgentBuiltInState, unknown>, ...args: unknown[]) => boolean | Promise<boolean>) | undefined;
@@ -708,7 +822,7 @@ export declare function humanInTheLoopMiddleware(options: NonNullable<HumanInThe
   descriptionPrefix?: string | undefined;
 }>, {
   interruptOn?: Record<string, boolean | {
-    allowedDecisions: ("approve" | "edit" | "reject")[];
+    allowedDecisions: ("approve" | "edit" | "reject" | "respond")[];
     description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;
     argsSchema?: Record<string, any> | undefined;
     when?: ((args_0: ToolCallRequest<AgentBuiltInState, unknown>, ...args: unknown[]) => boolean | Promise<boolean>) | undefined;

package/dist/agents/middleware/hitl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hitl.d.ts","names":["_$__types_js0.AgentMiddleware"],"sources":["../../../src/agents/middleware/hitl.ts"],"mappings":";;;;;;cAcM,oBAAkB,EAAA,YAAA,EAAA,UAAA,EAAA,QAAA,gBAAA,6BAAA,EAAA,YAAA,gBAAA,+BAAA,EAAA,aAAA,EAAA,UAAA,EAAA,YAAA,EAAA,WAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;YA4BZ,gBAAgB,EAAE,aAAa;cAErC,2BAAyB,EAAA,YAAA,EAAA,UAAA,EAAA,QAAA,iBAAA,sBAAA,EAAA,YAAA,iBAAA,uBAAA,EAAA,QAAA,mBAAA,EAAA,YAAA,oBAAA,EAAA,QAAA,kBAAA,EAAA,YAAA,oBAAA,EAAA,aAAA,EAAA,UAAA,EAAA,WAAA,EAAA,WAAA,EAAA;;;;;;;;;;;;;;;;;;YA0BnB,qBAAqB,EAAE,aAAa;cAM1C,cAAY,EAAA;KACN,eAAe,EAAE,aAAa;cAEpC,yBAAuB,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YA4EjB,oBAAoB,EAAE,aAAa;;;;iBAK9B;;;;EAIf;;;;EAIA,MAAM;;;;;iBAMS;;;;EAIf;;;;EAIA,MAAM;;;;EAIN;;;;;iBAMe;;;;EAIf;;;;EAIA,kBAAkB;;;;EAIlB,aAAa;;;;;;;;;;;;;;;;;;;;;;iBAuBE;;;;EAIf,gBAAgB;;;;EAIhB,eAAe;;;;;iBAMA;EACf;;;;;iBAMe;EACf;;;;;EAKA,cAAc;;;;;iBAMC;EACf;;;;EAIA;;;;;YAMU,WAAW,kBAAkB,eAAe;;;;iBAKvC;;;;EAIf,WAAW;;cAGP,eAAa,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAsBP,iCAAiC,4BACpC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAqNO,yBACd,SAAS,YAAY,6DAA+B,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6CAqVrD,6CAAA"}
+{"version":3,"file":"hitl.d.ts","names":["z","z4","_$__types_js0.AgentMiddleware"],"sources":["../../../src/agents/middleware/hitl.ts"],"mappings":";;;;;;;;cAkBM,oBAAkBA,IAAA,YAAAA,IAAA,UAAAA,IAAA,QAAA,gBAAA,6BAAAA,IAAA,YAAA,gBAAA,+BAAAA,IAAA,aAAAA,IAAA,UAAAA,IAAA,YAAAA,IAAA,WAAAA,IAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAiCZ,gBAAgBA,IAAE,aAAa;cAErC,2BAAyBA,IAAA,YAAAA,IAAA,UAAAA,IAAA,QAAA,iBAAA,sBAAAA,IAAA,YAAA,iBAAA,uBAAAA,IAAA,QAAA,mBAAAA,IAAA,YAAA,oBAAAA,IAAA,QAAA,kBAAAA,IAAA,YAAA,oBAAAA,IAAA,aAAAA,IAAA,UAAAA,IAAA,WAAAA,IAAA,WAAAA,IAAA;;;;;;;;;;;;;;;;;;YA0BnB,qBAAqBA,IAAE,aAAa;cAM1C,cAAYA,IAAA;KACN,eAAeA,IAAE,aAAa;cAEpC,yBAAuBA,IAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAiFjB,oBAAoBA,IAAE,aAAa;;;;iBAK9B;;;;EAIf;;;;EAIA,MAAM;;;;;iBAMS;;;;EAIf;;;;EAIA,MAAM;;;;EAIN;;;;;iBAMe;;;;EAIf;;;;EAIA,kBAAkB;;;;EAIlB,aAAa;;;;;;;;;;;;;;;;;;;;;;iBAuBE;;;;EAIf,gBAAgB;;;;EAIhB,eAAe;;;;;iBAMA;EACf;;;;;iBAMe;EACf;;;;;EAKA,cAAc;;;;;iBAMC;EACf;;;;EAIA;;;;;iBAMe;EACf;;;;EAIA;;;;;YAMU,WACR,kBACA,eACA,iBACA;;;;iBAKa;;;;EAIf,WAAW;;cAGP,2BAAyBC,EAAA;;;;;;GAW7BA,EAAA,KAAA;;;;;YAMU,sBAAsBA,EAAG,aAAa;;;;;;cAyB5C,wBAAqB,cACb,OACL;EAEP,SAAOA,EAAA;;;EACP,MAAIA,EAAA;;;;;;;EAOJ,QAAMA,EAAA;;;;EAIN,SAAOA,EAAA;;;;;;;;YASG,uBAAuBA,EAAG,MACpC,kBAAkB,uBAAuB;;;;;wBAO3B,wBACd,WAAW,wBACV,aAAa,UAAU;cAwBpB,eAAaD,IAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAsBP,iCAAiC,4BACpC;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6BP;;;;;;EAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAkTc,yBACd,SAAS,YAAY,6DAA+BA,IAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6CAkdrD,6CAAA"}