langchain 1.5.16 → 1.5.18

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

@@ -1,8 +1,10 @@
 import { AgentBuiltInState, Runtime } from "../runtime.cjs";
 import { AgentMiddleware, ToolCallRequest } from "./types.cjs";
+import { Interrupt } from "../types.cjs";
 import { ToolCall } from "@langchain/core/messages";
 import { InferInteropZodInput } from "@langchain/core/utils/types";
 import { z } from "zod/v3";
+import { z as z$1 } from "zod/v4";
 //#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>]>>;
 /**
@@ -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.
@@ -48,13 +55,13 @@ 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"]>;
+declare const DecisionType: z.ZodEnum<["approve", "edit", "reject", "respond"]>;
 type DecisionType = z.infer<typeof DecisionType>;
 declare const InterruptOnConfigSchema: z.ZodObject<{
   /**
    * The decisions that are allowed for this action.
    */
-  allowedDecisions: z.ZodArray<z.ZodEnum<["approve", "edit", "reject"]>, "many">;
+  allowedDecisions: z.ZodArray<z.ZodEnum<["approve", "edit", "reject", "respond"]>, "many">;
   /**
    * The description attached to the request for human input.
    * Can be either:
@@ -101,6 +108,9 @@ 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>]>>]>>;
   /**
    * 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>>;
   /**
@@ -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
@@ -126,12 +138,12 @@ 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")[];
+  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;
@@ -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,12 +276,58 @@ export interface HITLResponse {
    */
   decisions: Decision[];
 }
+declare const ToolApprovalRequestSchema: z$1.ZodObject<{
+  type: z$1.ZodLiteral<"tool_approval">;
+  tool_call_id: z$1.ZodString;
+  name: z$1.ZodString;
+  args: z$1.ZodRecord<z$1.ZodString, z$1.ZodUnknown>;
+  description: z$1.ZodString;
+}, z$1.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$1.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$1.ZodObject<{
+    type: z$1.ZodLiteral<"approve">;
+  }, z$1.core.$strip>;
+  edit: z$1.ZodObject<{
+    type: z$1.ZodLiteral<"edit">;
+    edited_action: z$1.ZodObject<{
+      name: z$1.ZodLiteral<string>;
+      args: z$1.ZodType<Record<string, unknown>, unknown, z$1.core.$ZodTypeInternals<Record<string, unknown>, unknown>>;
+    }, z$1.core.$strip>;
+  }, z$1.core.$strip>;
+  reject: z$1.ZodObject<{
+    type: z$1.ZodLiteral<"reject">;
+    message: z$1.ZodOptional<z$1.ZodString>;
+  }, z$1.core.$strip>;
+  respond: z$1.ZodObject<{
+    type: z$1.ZodLiteral<"respond">;
+    message: z$1.ZodString;
+  }, z$1.core.$strip>;
+};
+/**
+ * A reviewer's answer to a `"per_call"` tool approval.
+ */
+export type ToolApprovalDecision = z$1.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.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
    */
@@ -267,7 +335,7 @@ declare const contextSchema: z.ZodObject<{
     /**
      * The decisions that are allowed for this action.
      */
-    allowedDecisions: z.ZodArray<z.ZodEnum<["approve", "edit", "reject"]>, "many">;
+    allowedDecisions: z.ZodArray<z.ZodEnum<["approve", "edit", "reject", "respond"]>, "many">;
     /**
      * The description attached to the request for human input.
      * Can be either:
@@ -314,6 +382,9 @@ 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>]>>]>>;
     /**
      * 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>>;
     /**
@@ -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
@@ -339,12 +412,12 @@ 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")[];
+    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;
@@ -360,7 +433,7 @@ declare const contextSchema: z.ZodObject<{
   descriptionPrefix: z.ZodDefault<z.ZodString>;
 }, "strip", z.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,8 +686,9 @@ 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
@@ -591,7 +700,7 @@ export declare function humanInTheLoopMiddleware(options: NonNullable<HumanInThe
    * 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
    */
@@ -599,7 +708,7 @@ export declare function humanInTheLoopMiddleware(options: NonNullable<HumanInThe
     /**
      * The decisions that are allowed for this action.
      */
-    allowedDecisions: z.ZodArray<z.ZodEnum<["approve", "edit", "reject"]>, "many">;
+    allowedDecisions: z.ZodArray<z.ZodEnum<["approve", "edit", "reject", "respond"]>, "many">;
     /**
      * The description attached to the request for human input.
      * Can be either:
@@ -646,6 +755,9 @@ 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>]>>]>>;
     /**
      * 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>>;
     /**
@@ -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
@@ -671,12 +785,12 @@ 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")[];
+    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;
@@ -692,7 +806,7 @@ export declare function humanInTheLoopMiddleware(options: NonNullable<HumanInThe
   descriptionPrefix: z.ZodDefault<z.ZodString>;
 }, "strip", z.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.cts.map

@@ -1 +1 @@
-{"version":3,"file":"hitl.d.cts","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.cts","names":["z4","_$__types_js0.AgentMiddleware"],"sources":["../../../src/agents/middleware/hitl.ts"],"mappings":";;;;;;;;cAkBM,oBAAkB,EAAA,YAAA,EAAA,UAAA,EAAA,QAAA,gBAAA,6BAAA,EAAA,YAAA,gBAAA,+BAAA,EAAA,aAAA,EAAA,UAAA,EAAA,YAAA,EAAA,WAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAiCZ,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAiFjB,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;;;;;iBAMe;EACf;;;;EAIA;;;;;YAMU,WACR,kBACA,eACA,iBACA;;;;iBAKa;;;;EAIf,WAAW;;cAGP,2BAAyBA,IAAA;;;;;;GAW7BA,IAAA,KAAA;;;;;YAMU,sBAAsBA,IAAG,aAAa;;;;;;cAyB5C,wBAAqB,cACb,OACL;EAEP,SAAOA,IAAA;;;EACP,MAAIA,IAAA;;;;;;;EAOJ,QAAMA,IAAA;;;;EAIN,SAAOA,IAAA;;;;;;;;YASG,uBAAuBA,IAAG,MACpC,kBAAkB,uBAAuB;;;;;wBAO3B,wBACd,WAAW,wBACV,aAAa,UAAU;cAwBpB,eAAa,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAsBP,iCAAiC,4BACpC;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6BP;;;;;;EAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAkTc,yBACd,SAAS,YAAY,6DAA+B,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6CAkdrD,6CAAA"}