@wingman-ai/gateway 0.2.2 → 0.2.4

package/dist/cli/config/schema.cjs

@@ -25,67 +25,110 @@ var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     SearchConfigSchema: ()=>SearchConfigSchema,
-    SkillsConfigSchema: ()=>SkillsConfigSchema,
+    HumanInTheLoopConfigSchema: ()=>HumanInTheLoopConfigSchema,
     AgentsConfigSchema: ()=>AgentsConfigSchema,
+    GatewayConfigSchema: ()=>GatewayConfigSchema,
+    SkillsConfigSchema: ()=>SkillsConfigSchema,
+    SummarizationConfigSchema: ()=>SummarizationConfigSchema,
+    ModelRetryConfigSchema: ()=>ModelRetryConfigSchema,
     WingmanConfigSchema: ()=>WingmanConfigSchema,
     validateConfig: ()=>validateConfig,
-    GatewayConfigSchema: ()=>GatewayConfigSchema
+    ToolRetryConfigSchema: ()=>ToolRetryConfigSchema
 });
 const external_zod_namespaceObject = require("zod");
 const types_cjs_namespaceObject = require("../../agent/middleware/hooks/types.cjs");
 const external_gateway_hooks_types_cjs_namespaceObject = require("../../gateway/hooks/types.cjs");
 const mcp_cjs_namespaceObject = require("../../types/mcp.cjs");
 const voice_cjs_namespaceObject = require("../../types/voice.cjs");
-const SearchConfigSchema = external_zod_namespaceObject.z.object({
-    provider: external_zod_namespaceObject.z["enum"]([
+const SearchConfigSchema = external_zod_namespaceObject.object({
+    provider: external_zod_namespaceObject["enum"]([
         "duckduckgo",
         "perplexity"
     ]).default("duckduckgo").describe("Search provider to use"),
-    maxResults: external_zod_namespaceObject.z.number().min(1).max(20).optional().default(5).describe("Maximum number of search results to return")
+    maxResults: external_zod_namespaceObject.number().min(1).max(20).optional().default(5).describe("Maximum number of search results to return")
+});
+const SkillsConfigSchema = external_zod_namespaceObject.object({
+    repositoryOwner: external_zod_namespaceObject.string().default("anthropics").describe("GitHub repository owner for skills"),
+    repositoryName: external_zod_namespaceObject.string().default("skills").describe("GitHub repository name for skills"),
+    githubToken: external_zod_namespaceObject.string().optional().describe("GitHub personal access token for higher API rate limits"),
+    skillsDirectory: external_zod_namespaceObject.string().default("skills").describe("Directory to install skills in")
+});
+const SummarizationConfigSchema = external_zod_namespaceObject.object({
+    enabled: external_zod_namespaceObject.boolean().optional().default(true).describe("Enable conversation history summarization"),
+    maxTokensBeforeSummary: external_zod_namespaceObject.number().min(1000).max(1000000).optional().default(12000).describe("Token threshold before summarizing conversation history"),
+    messagesToKeep: external_zod_namespaceObject.number().min(2).max(100).optional().default(8).describe("How many most recent messages to keep after summarization")
+});
+const RetryOnFailureSchema = external_zod_namespaceObject["enum"]([
+    "continue",
+    "error"
+]);
+const BaseRetryConfigSchema = external_zod_namespaceObject.object({
+    enabled: external_zod_namespaceObject.boolean().optional().default(false).describe("Enable retry middleware"),
+    maxRetries: external_zod_namespaceObject.number().min(0).max(20).optional().default(2).describe("Maximum number of retry attempts"),
+    backoffFactor: external_zod_namespaceObject.number().min(0).max(10).optional().default(2).describe("Exponential backoff multiplier"),
+    initialDelayMs: external_zod_namespaceObject.number().min(0).max(120000).optional().default(1000).describe("Initial delay before first retry in milliseconds"),
+    maxDelayMs: external_zod_namespaceObject.number().min(0).max(300000).optional().default(60000).describe("Maximum backoff delay in milliseconds"),
+    jitter: external_zod_namespaceObject.boolean().optional().default(true).describe("Add randomized jitter to retry delays"),
+    onFailure: RetryOnFailureSchema.optional().default("continue").describe("Behavior when retries are exhausted")
+});
+const ModelRetryConfigSchema = BaseRetryConfigSchema;
+const ToolRetryConfigSchema = BaseRetryConfigSchema.extend({
+    tools: external_zod_namespaceObject.array(external_zod_namespaceObject.string().min(1)).optional().describe("Optional list of tool names to apply retry logic to")
 });
-const SkillsConfigSchema = external_zod_namespaceObject.z.object({
-    repositoryOwner: external_zod_namespaceObject.z.string().default("anthropics").describe("GitHub repository owner for skills"),
-    repositoryName: external_zod_namespaceObject.z.string().default("skills").describe("GitHub repository name for skills"),
-    githubToken: external_zod_namespaceObject.z.string().optional().describe("GitHub personal access token for higher API rate limits"),
-    skillsDirectory: external_zod_namespaceObject.z.string().default("skills").describe("Directory to install skills in")
+const AllowedDecisionSchema = external_zod_namespaceObject["enum"]([
+    "approve",
+    "edit",
+    "reject"
+]);
+const InterruptOnToolConfigSchema = external_zod_namespaceObject.union([
+    external_zod_namespaceObject.boolean(),
+    external_zod_namespaceObject.object({
+        allowedDecisions: external_zod_namespaceObject.array(AllowedDecisionSchema).min(1).describe("Allowed decisions for this tool"),
+        description: external_zod_namespaceObject.string().optional().describe("Optional custom review prompt for this tool"),
+        argsSchema: external_zod_namespaceObject.record(external_zod_namespaceObject.string(), external_zod_namespaceObject.any()).optional().describe("Optional argument schema for edit decisions")
+    })
+]);
+const HumanInTheLoopConfigSchema = external_zod_namespaceObject.object({
+    enabled: external_zod_namespaceObject.boolean().optional().default(false).describe("Enable human-in-the-loop tool approval"),
+    interruptOn: external_zod_namespaceObject.record(external_zod_namespaceObject.string(), InterruptOnToolConfigSchema).optional().default({}).describe("Per-tool approval policy mapping")
 });
-const GatewayAuthSchema = external_zod_namespaceObject.z.object({
-    mode: external_zod_namespaceObject.z["enum"]([
+const GatewayAuthSchema = external_zod_namespaceObject.object({
+    mode: external_zod_namespaceObject["enum"]([
         "token",
         "password",
         "none"
     ]).default("none"),
-    token: external_zod_namespaceObject.z.string().optional(),
-    password: external_zod_namespaceObject.z.string().optional(),
-    allowTailscale: external_zod_namespaceObject.z.boolean().optional().default(false)
+    token: external_zod_namespaceObject.string().optional(),
+    password: external_zod_namespaceObject.string().optional(),
+    allowTailscale: external_zod_namespaceObject.boolean().optional().default(false)
 }).default({
     mode: "none",
     allowTailscale: false
 });
-const GatewayControlUiSchema = external_zod_namespaceObject.z.object({
-    enabled: external_zod_namespaceObject.z.boolean().default(true),
-    port: external_zod_namespaceObject.z.number().min(1).max(65535).default(18790),
-    pairingRequired: external_zod_namespaceObject.z.boolean().default(true),
-    allowInsecureAuth: external_zod_namespaceObject.z.boolean().default(false)
+const GatewayControlUiSchema = external_zod_namespaceObject.object({
+    enabled: external_zod_namespaceObject.boolean().default(true),
+    port: external_zod_namespaceObject.number().min(1).max(65535).default(18790),
+    pairingRequired: external_zod_namespaceObject.boolean().default(true),
+    allowInsecureAuth: external_zod_namespaceObject.boolean().default(false)
 }).default({
     enabled: true,
     port: 18790,
     pairingRequired: true,
     allowInsecureAuth: false
 });
-const DiscordAdapterSchema = external_zod_namespaceObject.z.object({
-    enabled: external_zod_namespaceObject.z.boolean().default(false),
-    token: external_zod_namespaceObject.z.string().optional(),
-    mentionOnly: external_zod_namespaceObject.z.boolean().default(true),
-    allowBots: external_zod_namespaceObject.z.boolean().default(false),
-    allowedGuilds: external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.string()).default([]),
-    allowedChannels: external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.string()).default([]),
-    channelSessions: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.string(), external_zod_namespaceObject.z.string()).default({}),
-    sessionCommand: external_zod_namespaceObject.z.string().default("!session"),
-    gatewayUrl: external_zod_namespaceObject.z.string().optional(),
-    gatewayToken: external_zod_namespaceObject.z.string().optional(),
-    gatewayPassword: external_zod_namespaceObject.z.string().optional(),
-    responseChunkSize: external_zod_namespaceObject.z.number().min(500).max(2000).default(1900)
+const DiscordAdapterSchema = external_zod_namespaceObject.object({
+    enabled: external_zod_namespaceObject.boolean().default(false),
+    token: external_zod_namespaceObject.string().optional(),
+    mentionOnly: external_zod_namespaceObject.boolean().default(true),
+    allowBots: external_zod_namespaceObject.boolean().default(false),
+    allowedGuilds: external_zod_namespaceObject.array(external_zod_namespaceObject.string()).default([]),
+    allowedChannels: external_zod_namespaceObject.array(external_zod_namespaceObject.string()).default([]),
+    channelSessions: external_zod_namespaceObject.record(external_zod_namespaceObject.string(), external_zod_namespaceObject.string()).default({}),
+    sessionCommand: external_zod_namespaceObject.string().default("!session"),
+    gatewayUrl: external_zod_namespaceObject.string().optional(),
+    gatewayToken: external_zod_namespaceObject.string().optional(),
+    gatewayPassword: external_zod_namespaceObject.string().optional(),
+    responseChunkSize: external_zod_namespaceObject.number().min(500).max(2000).default(1900)
 }).default({
     enabled: false,
     mentionOnly: true,
@@ -96,14 +139,14 @@ const DiscordAdapterSchema = external_zod_namespaceObject.z.object({
     sessionCommand: "!session",
     responseChunkSize: 1900
 });
-const GatewayAdaptersSchema = external_zod_namespaceObject.z.object({
+const GatewayAdaptersSchema = external_zod_namespaceObject.object({
     discord: DiscordAdapterSchema.optional()
 }).default({});
-const GatewayConfigSchema = external_zod_namespaceObject.z.object({
-    host: external_zod_namespaceObject.z.string().default("127.0.0.1"),
-    port: external_zod_namespaceObject.z.number().min(1).max(65535).default(18789),
-    stateDir: external_zod_namespaceObject.z.string().optional(),
-    fsRoots: external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.string()).optional().default([]),
+const GatewayConfigSchema = external_zod_namespaceObject.object({
+    host: external_zod_namespaceObject.string().default("127.0.0.1"),
+    port: external_zod_namespaceObject.number().min(1).max(65535).default(18789),
+    stateDir: external_zod_namespaceObject.string().optional(),
+    fsRoots: external_zod_namespaceObject.array(external_zod_namespaceObject.string()).optional().default([]),
     auth: GatewayAuthSchema.optional().default({
         mode: "none",
         allowTailscale: false
@@ -114,7 +157,7 @@ const GatewayConfigSchema = external_zod_namespaceObject.z.object({
         pairingRequired: true,
         allowInsecureAuth: false
     }),
-    dynamicUiEnabled: external_zod_namespaceObject.z.boolean().optional().default(true),
+    dynamicUiEnabled: external_zod_namespaceObject.boolean().optional().default(true),
     adapters: GatewayAdaptersSchema.optional().default({})
 }).default({
     host: "127.0.0.1",
@@ -133,50 +176,77 @@ const GatewayConfigSchema = external_zod_namespaceObject.z.object({
     dynamicUiEnabled: true,
     adapters: {}
 });
-const AgentListItemSchema = external_zod_namespaceObject.z.object({
-    id: external_zod_namespaceObject.z.string().min(1),
-    name: external_zod_namespaceObject.z.string().optional(),
-    default: external_zod_namespaceObject.z.boolean().optional(),
-    workspace: external_zod_namespaceObject.z.string().optional(),
-    agentDir: external_zod_namespaceObject.z.string().optional(),
-    model: external_zod_namespaceObject.z.string().optional()
+const AgentListItemSchema = external_zod_namespaceObject.object({
+    id: external_zod_namespaceObject.string().min(1),
+    name: external_zod_namespaceObject.string().optional(),
+    default: external_zod_namespaceObject.boolean().optional(),
+    workspace: external_zod_namespaceObject.string().optional(),
+    agentDir: external_zod_namespaceObject.string().optional(),
+    model: external_zod_namespaceObject.string().optional()
 });
-const BindingPeerSchema = external_zod_namespaceObject.z.object({
-    kind: external_zod_namespaceObject.z["enum"]([
+const BindingPeerSchema = external_zod_namespaceObject.object({
+    kind: external_zod_namespaceObject["enum"]([
         "dm",
         "group",
         "channel"
     ]),
-    id: external_zod_namespaceObject.z.string().min(1)
+    id: external_zod_namespaceObject.string().min(1)
 });
-const BindingMatchSchema = external_zod_namespaceObject.z.object({
-    channel: external_zod_namespaceObject.z.string().min(1),
-    accountId: external_zod_namespaceObject.z.string().optional(),
-    guildId: external_zod_namespaceObject.z.string().optional(),
-    teamId: external_zod_namespaceObject.z.string().optional(),
+const BindingMatchSchema = external_zod_namespaceObject.object({
+    channel: external_zod_namespaceObject.string().min(1),
+    accountId: external_zod_namespaceObject.string().optional(),
+    guildId: external_zod_namespaceObject.string().optional(),
+    teamId: external_zod_namespaceObject.string().optional(),
     peer: BindingPeerSchema.optional()
 });
-const BindingSchema = external_zod_namespaceObject.z.object({
-    agentId: external_zod_namespaceObject.z.string().min(1),
+const BindingSchema = external_zod_namespaceObject.object({
+    agentId: external_zod_namespaceObject.string().min(1),
     match: BindingMatchSchema
 });
-const AgentsConfigSchema = external_zod_namespaceObject.z.object({
-    list: external_zod_namespaceObject.z.array(AgentListItemSchema).default([]),
-    bindings: external_zod_namespaceObject.z.array(BindingSchema).default([])
+const AgentsConfigSchema = external_zod_namespaceObject.object({
+    list: external_zod_namespaceObject.array(AgentListItemSchema).default([]),
+    bindings: external_zod_namespaceObject.array(BindingSchema).default([])
 }).default({
     list: [],
     bindings: []
 });
-const WingmanConfigSchema = external_zod_namespaceObject.z.object({
-    logLevel: external_zod_namespaceObject.z["enum"]([
+const WingmanConfigSchema = external_zod_namespaceObject.object({
+    logLevel: external_zod_namespaceObject["enum"]([
         "debug",
         "info",
         "warn",
         "error",
         "silent"
     ]).optional().default("info"),
-    defaultAgent: external_zod_namespaceObject.z.string().optional(),
-    recursionLimit: external_zod_namespaceObject.z.number().min(1).max(1000000).optional().default(5000),
+    defaultAgent: external_zod_namespaceObject.string().optional(),
+    recursionLimit: external_zod_namespaceObject.number().min(1).max(1000000).optional().default(5000),
+    summarization: SummarizationConfigSchema.optional().default({
+        enabled: true,
+        maxTokensBeforeSummary: 12000,
+        messagesToKeep: 8
+    }),
+    modelRetry: ModelRetryConfigSchema.optional().default({
+        enabled: true,
+        maxRetries: 2,
+        backoffFactor: 2,
+        initialDelayMs: 1000,
+        maxDelayMs: 60000,
+        jitter: true,
+        onFailure: "continue"
+    }),
+    toolRetry: ToolRetryConfigSchema.optional().default({
+        enabled: false,
+        maxRetries: 2,
+        backoffFactor: 2,
+        initialDelayMs: 1000,
+        maxDelayMs: 60000,
+        jitter: true,
+        onFailure: "continue"
+    }),
+    humanInTheLoop: HumanInTheLoopConfigSchema.optional().default({
+        enabled: false,
+        interruptOn: {}
+    }),
     toolHooks: types_cjs_namespaceObject.HooksConfigSchema.optional().describe("Global tool hooks configuration"),
     hooks: external_gateway_hooks_types_cjs_namespaceObject.InternalHooksConfigSchema.optional().describe("Internal hook configuration"),
     search: SearchConfigSchema.optional().default({
@@ -189,9 +259,9 @@ const WingmanConfigSchema = external_zod_namespaceObject.z.object({
         webSpeech: {},
         elevenlabs: {}
     }),
-    cli: external_zod_namespaceObject.z.object({
-        theme: external_zod_namespaceObject.z.string().default("default"),
-        outputMode: external_zod_namespaceObject.z["enum"]([
+    cli: external_zod_namespaceObject.object({
+        theme: external_zod_namespaceObject.string().default("default"),
+        outputMode: external_zod_namespaceObject["enum"]([
             "auto",
             "interactive",
             "json"
@@ -236,7 +306,7 @@ function validateConfig(data) {
             data: validated
         };
     } catch (error) {
-        if (error instanceof external_zod_namespaceObject.z.ZodError) return {
+        if (error instanceof external_zod_namespaceObject.ZodError) return {
             success: false,
             error: error.issues.map((e)=>`${e.path.join(".")}: ${e.message}`).join(", ")
         };
@@ -248,15 +318,23 @@ function validateConfig(data) {
 }
 exports.AgentsConfigSchema = __webpack_exports__.AgentsConfigSchema;
 exports.GatewayConfigSchema = __webpack_exports__.GatewayConfigSchema;
+exports.HumanInTheLoopConfigSchema = __webpack_exports__.HumanInTheLoopConfigSchema;
+exports.ModelRetryConfigSchema = __webpack_exports__.ModelRetryConfigSchema;
 exports.SearchConfigSchema = __webpack_exports__.SearchConfigSchema;
 exports.SkillsConfigSchema = __webpack_exports__.SkillsConfigSchema;
+exports.SummarizationConfigSchema = __webpack_exports__.SummarizationConfigSchema;
+exports.ToolRetryConfigSchema = __webpack_exports__.ToolRetryConfigSchema;
 exports.WingmanConfigSchema = __webpack_exports__.WingmanConfigSchema;
 exports.validateConfig = __webpack_exports__.validateConfig;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "AgentsConfigSchema",
     "GatewayConfigSchema",
+    "HumanInTheLoopConfigSchema",
+    "ModelRetryConfigSchema",
     "SearchConfigSchema",
     "SkillsConfigSchema",
+    "SummarizationConfigSchema",
+    "ToolRetryConfigSchema",
     "WingmanConfigSchema",
     "validateConfig"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];

package/dist/cli/config/schema.d.ts

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import * as z from "zod";
 export declare const SearchConfigSchema: z.ZodObject<{
     provider: z.ZodDefault<z.ZodEnum<{
         duckduckgo: "duckduckgo";
@@ -14,6 +14,52 @@ export declare const SkillsConfigSchema: z.ZodObject<{
     skillsDirectory: z.ZodDefault<z.ZodString>;
 }, z.core.$strip>;
 export type SkillsConfig = z.infer<typeof SkillsConfigSchema>;
+export declare const SummarizationConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    maxTokensBeforeSummary: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    messagesToKeep: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, z.core.$strip>;
+export type SummarizationConfig = z.infer<typeof SummarizationConfigSchema>;
+export declare const ModelRetryConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    maxRetries: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    backoffFactor: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    initialDelayMs: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    maxDelayMs: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    jitter: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    onFailure: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        error: "error";
+        continue: "continue";
+    }>>>;
+}, z.core.$strip>;
+export type ModelRetryConfig = z.infer<typeof ModelRetryConfigSchema>;
+export declare const ToolRetryConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    maxRetries: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    backoffFactor: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    initialDelayMs: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    maxDelayMs: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    jitter: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    onFailure: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        error: "error";
+        continue: "continue";
+    }>>>;
+    tools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type ToolRetryConfig = z.infer<typeof ToolRetryConfigSchema>;
+export declare const HumanInTheLoopConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    interruptOn: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+        allowedDecisions: z.ZodArray<z.ZodEnum<{
+            approve: "approve";
+            edit: "edit";
+            reject: "reject";
+        }>>;
+        description: z.ZodOptional<z.ZodString>;
+        argsSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    }, z.core.$strip>]>>>>;
+}, z.core.$strip>;
+export type HumanInTheLoopConfig = z.infer<typeof HumanInTheLoopConfigSchema>;
 export declare const GatewayConfigSchema: z.ZodDefault<z.ZodObject<{
     host: z.ZodDefault<z.ZodString>;
     port: z.ZodDefault<z.ZodNumber>;
@@ -92,6 +138,48 @@ export declare const WingmanConfigSchema: z.ZodObject<{
     }>>>;
     defaultAgent: z.ZodOptional<z.ZodString>;
     recursionLimit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    summarization: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        maxTokensBeforeSummary: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        messagesToKeep: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    }, z.core.$strip>>>;
+    modelRetry: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        maxRetries: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        backoffFactor: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        initialDelayMs: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        maxDelayMs: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        jitter: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        onFailure: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+            error: "error";
+            continue: "continue";
+        }>>>;
+    }, z.core.$strip>>>;
+    toolRetry: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        maxRetries: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        backoffFactor: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        initialDelayMs: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        maxDelayMs: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        jitter: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        onFailure: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+            error: "error";
+            continue: "continue";
+        }>>>;
+        tools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
+    humanInTheLoop: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        interruptOn: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+            allowedDecisions: z.ZodArray<z.ZodEnum<{
+                approve: "approve";
+                edit: "edit";
+                reject: "reject";
+            }>>;
+            description: z.ZodOptional<z.ZodString>;
+            argsSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        }, z.core.$strip>]>>>>;
+    }, z.core.$strip>>>;
     toolHooks: z.ZodOptional<z.ZodObject<{
         PreToolUse: z.ZodOptional<z.ZodArray<z.ZodObject<{
             matcher: z.ZodOptional<z.ZodString>;