@wingman-ai/gateway 0.2.2 → 0.2.3

package/dist/agent/tests/modelFactory.test.cjs

@@ -1,9 +1,9 @@
 "use strict";
 var __webpack_exports__ = {};
-const external_vitest_namespaceObject = require("vitest");
-const modelFactory_cjs_namespaceObject = require("../config/modelFactory.cjs");
 const anthropic_namespaceObject = require("@langchain/anthropic");
 const openai_namespaceObject = require("@langchain/openai");
+const external_vitest_namespaceObject = require("vitest");
+const modelFactory_cjs_namespaceObject = require("../config/modelFactory.cjs");
 const originalAnthropicApiKey = process.env.ANTHROPIC_API_KEY;
 (0, external_vitest_namespaceObject.beforeEach)(()=>{
     process.env.ANTHROPIC_API_KEY = "test-anthropic-api-key";
@@ -22,6 +22,10 @@ const originalAnthropicApiKey = process.env.ANTHROPIC_API_KEY;
             const model = modelFactory_cjs_namespaceObject.ModelFactory.createModel("openai:gpt-4o");
             (0, external_vitest_namespaceObject.expect)(model).toBeInstanceOf(openai_namespaceObject.ChatOpenAI);
         });
+        (0, external_vitest_namespaceObject.it)("should create a Codex model", ()=>{
+            const model = modelFactory_cjs_namespaceObject.ModelFactory.createModel("codex:codex-mini-latest");
+            (0, external_vitest_namespaceObject.expect)(model).toBeInstanceOf(openai_namespaceObject.ChatOpenAI);
+        });
         (0, external_vitest_namespaceObject.it)("should force OpenAI models onto the responses API", ()=>{
             const model = modelFactory_cjs_namespaceObject.ModelFactory.createModel("openai:gpt-5.2-codex");
             (0, external_vitest_namespaceObject.expect)(model).toBeInstanceOf(openai_namespaceObject.ChatOpenAI);
@@ -79,6 +83,7 @@ const originalAnthropicApiKey = process.env.ANTHROPIC_API_KEY;
             const validModels = [
                 "anthropic:claude-opus-4-5",
                 "openai:gpt-4o",
+                "codex:codex-mini-latest",
                 "anthropic:claude-sonnet-4-5-20250929",
                 "openrouter:openai/gpt-4o",
                 "copilot:gpt-4o",
@@ -115,14 +120,16 @@ const originalAnthropicApiKey = process.env.ANTHROPIC_API_KEY;
         (0, external_vitest_namespaceObject.it)("should accept case variations of providers", ()=>{
             const result1 = modelFactory_cjs_namespaceObject.ModelFactory.validateModelString("Anthropic:model");
             const result2 = modelFactory_cjs_namespaceObject.ModelFactory.validateModelString("OPENAI:model");
-            const result3 = modelFactory_cjs_namespaceObject.ModelFactory.validateModelString("Copilot:model");
-            const result4 = modelFactory_cjs_namespaceObject.ModelFactory.validateModelString("LMStudio:model");
-            const result5 = modelFactory_cjs_namespaceObject.ModelFactory.validateModelString("OLLAMA:model");
+            const result3 = modelFactory_cjs_namespaceObject.ModelFactory.validateModelString("CODEX:model");
+            const result4 = modelFactory_cjs_namespaceObject.ModelFactory.validateModelString("Copilot:model");
+            const result5 = modelFactory_cjs_namespaceObject.ModelFactory.validateModelString("LMStudio:model");
+            const result6 = modelFactory_cjs_namespaceObject.ModelFactory.validateModelString("OLLAMA:model");
             (0, external_vitest_namespaceObject.expect)(result1.valid).toBe(true);
             (0, external_vitest_namespaceObject.expect)(result2.valid).toBe(true);
             (0, external_vitest_namespaceObject.expect)(result3.valid).toBe(true);
             (0, external_vitest_namespaceObject.expect)(result4.valid).toBe(true);
             (0, external_vitest_namespaceObject.expect)(result5.valid).toBe(true);
+            (0, external_vitest_namespaceObject.expect)(result6.valid).toBe(true);
         });
     });
 });

package/dist/agent/tests/modelFactory.test.js

@@ -1,7 +1,7 @@
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { ModelFactory } from "../config/modelFactory.js";
 import { ChatAnthropic } from "@langchain/anthropic";
 import { ChatOpenAI } from "@langchain/openai";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { ModelFactory } from "../config/modelFactory.js";
 const originalAnthropicApiKey = process.env.ANTHROPIC_API_KEY;
 beforeEach(()=>{
     process.env.ANTHROPIC_API_KEY = "test-anthropic-api-key";
@@ -20,6 +20,10 @@ describe("ModelFactory", ()=>{
             const model = ModelFactory.createModel("openai:gpt-4o");
             expect(model).toBeInstanceOf(ChatOpenAI);
         });
+        it("should create a Codex model", ()=>{
+            const model = ModelFactory.createModel("codex:codex-mini-latest");
+            expect(model).toBeInstanceOf(ChatOpenAI);
+        });
         it("should force OpenAI models onto the responses API", ()=>{
             const model = ModelFactory.createModel("openai:gpt-5.2-codex");
             expect(model).toBeInstanceOf(ChatOpenAI);
@@ -77,6 +81,7 @@ describe("ModelFactory", ()=>{
             const validModels = [
                 "anthropic:claude-opus-4-5",
                 "openai:gpt-4o",
+                "codex:codex-mini-latest",
                 "anthropic:claude-sonnet-4-5-20250929",
                 "openrouter:openai/gpt-4o",
                 "copilot:gpt-4o",
@@ -113,14 +118,16 @@ describe("ModelFactory", ()=>{
         it("should accept case variations of providers", ()=>{
             const result1 = ModelFactory.validateModelString("Anthropic:model");
             const result2 = ModelFactory.validateModelString("OPENAI:model");
-            const result3 = ModelFactory.validateModelString("Copilot:model");
-            const result4 = ModelFactory.validateModelString("LMStudio:model");
-            const result5 = ModelFactory.validateModelString("OLLAMA:model");
+            const result3 = ModelFactory.validateModelString("CODEX:model");
+            const result4 = ModelFactory.validateModelString("Copilot:model");
+            const result5 = ModelFactory.validateModelString("LMStudio:model");
+            const result6 = ModelFactory.validateModelString("OLLAMA:model");
             expect(result1.valid).toBe(true);
             expect(result2.valid).toBe(true);
             expect(result3.valid).toBe(true);
             expect(result4.valid).toBe(true);
             expect(result5.valid).toBe(true);
+            expect(result6.valid).toBe(true);
         });
     });
 });

package/dist/cli/commands/init.cjs

@@ -41,15 +41,15 @@ __webpack_require__.d(__webpack_exports__, {
 const external_node_fs_namespaceObject = require("node:fs");
 const external_node_path_namespaceObject = require("node:path");
 const external_node_url_namespaceObject = require("node:url");
+const prompts_namespaceObject = require("@clack/prompts");
 const external_chalk_namespaceObject = require("chalk");
 var external_chalk_default = /*#__PURE__*/ __webpack_require__.n(external_chalk_namespaceObject);
-const prompts_namespaceObject = require("@clack/prompts");
-const outputManager_cjs_namespaceObject = require("../core/outputManager.cjs");
-const schema_cjs_namespaceObject = require("../config/schema.cjs");
+const modelFactory_cjs_namespaceObject = require("../../agent/config/modelFactory.cjs");
 const external_logger_cjs_namespaceObject = require("../../logger.cjs");
-const registry_cjs_namespaceObject = require("../../providers/registry.cjs");
 const credentials_cjs_namespaceObject = require("../../providers/credentials.cjs");
-const modelFactory_cjs_namespaceObject = require("../../agent/config/modelFactory.cjs");
+const registry_cjs_namespaceObject = require("../../providers/registry.cjs");
+const schema_cjs_namespaceObject = require("../config/schema.cjs");
+const outputManager_cjs_namespaceObject = require("../core/outputManager.cjs");
 const DEFAULT_AGENT_ID = "wingman";
 const DEFAULT_AGENT_DESCRIPTION = "General-purpose coding assistant for this workspace.";
 const DEFAULT_AGENT_PROMPT = "You are Wingman, a coding assistant for this repository.\nBe direct and concise. Ask clarifying questions when requirements are unclear.\nPrefer minimal diffs and safe changes. Avoid destructive actions unless asked.\nUse tools to inspect the codebase before editing.";
@@ -64,6 +64,7 @@ const DEFAULT_FS_ROOT = ".";
 const DEFAULT_MODELS = {
     anthropic: "anthropic:claude-sonnet-4-5",
     openai: "openai:gpt-4o",
+    codex: "codex:codex-mini-latest",
     openrouter: "openrouter:openai/gpt-4o",
     copilot: "copilot:gpt-4o",
     xai: "xai:grok-beta"
@@ -649,7 +650,7 @@ Options:
   --agents <list>        Copy only these bundled agents (comma-separated)
   --model <provider:model>
                          Set model for the starter agent
-  --provider <name>      Provider to configure (anthropic|openai|openrouter|copilot|xai)
+  --provider <name>      Provider to configure (anthropic|openai|codex|openrouter|copilot|xai)
   --token <token>        Save provider token (non-interactive)
   --api-key <key>        Alias for --token
   --fs-root <path>       Add fs root (default: ".")

package/dist/cli/commands/init.js

@@ -1,14 +1,14 @@
 import { copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { fileURLToPath } from "node:url";
-import chalk from "chalk";
 import { cancel, confirm as prompts_confirm, intro, isCancel, multiselect, note, outro, select as prompts_select, spinner, text as prompts_text } from "@clack/prompts";
-import { OutputManager } from "../core/outputManager.js";
-import { WingmanConfigSchema } from "../config/schema.js";
+import chalk from "chalk";
+import { ModelFactory } from "../../agent/config/modelFactory.js";
 import { createLogger, getLogFilePath } from "../../logger.js";
-import { listProviderSpecs, normalizeProviderName } from "../../providers/registry.js";
 import { getCredentialsPath, resolveProviderToken, saveProviderToken } from "../../providers/credentials.js";
-import { ModelFactory } from "../../agent/config/modelFactory.js";
+import { listProviderSpecs, normalizeProviderName } from "../../providers/registry.js";
+import { WingmanConfigSchema } from "../config/schema.js";
+import { OutputManager } from "../core/outputManager.js";
 const DEFAULT_AGENT_ID = "wingman";
 const DEFAULT_AGENT_DESCRIPTION = "General-purpose coding assistant for this workspace.";
 const DEFAULT_AGENT_PROMPT = "You are Wingman, a coding assistant for this repository.\nBe direct and concise. Ask clarifying questions when requirements are unclear.\nPrefer minimal diffs and safe changes. Avoid destructive actions unless asked.\nUse tools to inspect the codebase before editing.";
@@ -23,6 +23,7 @@ const DEFAULT_FS_ROOT = ".";
 const DEFAULT_MODELS = {
     anthropic: "anthropic:claude-sonnet-4-5",
     openai: "openai:gpt-4o",
+    codex: "codex:codex-mini-latest",
     openrouter: "openrouter:openai/gpt-4o",
     copilot: "copilot:gpt-4o",
     xai: "xai:grok-beta"
@@ -608,7 +609,7 @@ Options:
   --agents <list>        Copy only these bundled agents (comma-separated)
   --model <provider:model>
                          Set model for the starter agent
-  --provider <name>      Provider to configure (anthropic|openai|openrouter|copilot|xai)
+  --provider <name>      Provider to configure (anthropic|openai|codex|openrouter|copilot|xai)
   --token <token>        Save provider token (non-interactive)
   --api-key <key>        Alias for --token
   --fs-root <path>       Add fs root (default: ".")

package/dist/cli/commands/provider.cjs

@@ -27,11 +27,12 @@ __webpack_require__.d(__webpack_exports__, {
     executeProviderCommand: ()=>executeProviderCommand
 });
 const external_node_readline_namespaceObject = require("node:readline");
-const outputManager_cjs_namespaceObject = require("../core/outputManager.cjs");
+const external_logger_cjs_namespaceObject = require("../../logger.cjs");
+const codex_cjs_namespaceObject = require("../../providers/codex.cjs");
 const credentials_cjs_namespaceObject = require("../../providers/credentials.cjs");
-const registry_cjs_namespaceObject = require("../../providers/registry.cjs");
 const oauth_cjs_namespaceObject = require("../../providers/oauth.cjs");
-const external_logger_cjs_namespaceObject = require("../../logger.cjs");
+const registry_cjs_namespaceObject = require("../../providers/registry.cjs");
+const outputManager_cjs_namespaceObject = require("../core/outputManager.cjs");
 async function executeProviderCommand(args) {
     const outputManager = new outputManager_cjs_namespaceObject.OutputManager(args.outputMode);
     try {
@@ -82,6 +83,16 @@ async function handleLogin(outputManager, args) {
         writeLine(outputManager, `Saved ${provider.label} credentials to ${(0, credentials_cjs_namespaceObject.getCredentialsPath)()}`);
         return;
     }
+    if ("codex" === provider.name) {
+        const codexAuth = (0, codex_cjs_namespaceObject.resolveCodexAuthFromFile)();
+        if (codexAuth.accessToken) return void writeLine(outputManager, `Detected Codex login at ${codexAuth.authPath}. Wingman will use it automatically.`);
+        if ("interactive" !== outputManager.getMode()) throw new Error(`Codex login not found at ${codexAuth.authPath}. Run "codex login" or pass --token.`);
+        writeLine(outputManager, `No Codex login found at ${codexAuth.authPath}.`);
+        const resolvedToken = await promptForToken(`Enter ${provider.label} token: `);
+        (0, credentials_cjs_namespaceObject.saveProviderToken)(provider.name, resolvedToken);
+        writeLine(outputManager, `Saved ${provider.label} credentials to ${(0, credentials_cjs_namespaceObject.getCredentialsPath)()}`);
+        return;
+    }
     if ("oauth" === provider.type) {
         const credentials = await (0, oauth_cjs_namespaceObject.loginWithLocalCallback)(provider.name, {
             clientId: getOptionValue(args.options, "client-id"),
@@ -132,6 +143,7 @@ Usage:
 Examples:
   wingman provider status
   wingman provider login copilot
+  wingman provider login codex
   wingman provider login openrouter --api-key="<key>"
   wingman provider login lmstudio
   wingman provider login ollama
@@ -143,6 +155,8 @@ Options:
 Environment Variables:
   ANTHROPIC_API_KEY     Anthropic API key
   OPENAI_API_KEY        OpenAI API key
+  CODEX_ACCESS_TOKEN    OpenAI Codex ChatGPT access token
+  CHATGPT_ACCESS_TOKEN  OpenAI Codex ChatGPT access token
   OPENROUTER_API_KEY    OpenRouter API key
   GITHUB_COPILOT_TOKEN  GitHub Copilot token
   COPILOT_TOKEN         GitHub Copilot token

package/dist/cli/commands/provider.js

@@ -1,9 +1,10 @@
 import { createInterface } from "node:readline";
-import { OutputManager } from "../core/outputManager.js";
+import { createLogger, getLogFilePath } from "../../logger.js";
+import { resolveCodexAuthFromFile } from "../../providers/codex.js";
 import { deleteProviderCredentials, getCredentialsPath, resolveProviderToken, saveProviderToken, setProviderCredentials } from "../../providers/credentials.js";
-import { getProviderSpec, listProviderSpecs } from "../../providers/registry.js";
 import { loginWithLocalCallback } from "../../providers/oauth.js";
-import { createLogger, getLogFilePath } from "../../logger.js";
+import { getProviderSpec, listProviderSpecs } from "../../providers/registry.js";
+import { OutputManager } from "../core/outputManager.js";
 async function executeProviderCommand(args) {
     const outputManager = new OutputManager(args.outputMode);
     try {
@@ -54,6 +55,16 @@ async function handleLogin(outputManager, args) {
         writeLine(outputManager, `Saved ${provider.label} credentials to ${getCredentialsPath()}`);
         return;
     }
+    if ("codex" === provider.name) {
+        const codexAuth = resolveCodexAuthFromFile();
+        if (codexAuth.accessToken) return void writeLine(outputManager, `Detected Codex login at ${codexAuth.authPath}. Wingman will use it automatically.`);
+        if ("interactive" !== outputManager.getMode()) throw new Error(`Codex login not found at ${codexAuth.authPath}. Run "codex login" or pass --token.`);
+        writeLine(outputManager, `No Codex login found at ${codexAuth.authPath}.`);
+        const resolvedToken = await promptForToken(`Enter ${provider.label} token: `);
+        saveProviderToken(provider.name, resolvedToken);
+        writeLine(outputManager, `Saved ${provider.label} credentials to ${getCredentialsPath()}`);
+        return;
+    }
     if ("oauth" === provider.type) {
         const credentials = await loginWithLocalCallback(provider.name, {
             clientId: getOptionValue(args.options, "client-id"),
@@ -104,6 +115,7 @@ Usage:
 Examples:
   wingman provider status
   wingman provider login copilot
+  wingman provider login codex
   wingman provider login openrouter --api-key="<key>"
   wingman provider login lmstudio
   wingman provider login ollama
@@ -115,6 +127,8 @@ Options:
 Environment Variables:
   ANTHROPIC_API_KEY     Anthropic API key
   OPENAI_API_KEY        OpenAI API key
+  CODEX_ACCESS_TOKEN    OpenAI Codex ChatGPT access token
+  CHATGPT_ACCESS_TOKEN  OpenAI Codex ChatGPT access token
   OPENROUTER_API_KEY    OpenRouter API key
   GITHUB_COPILOT_TOKEN  GitHub Copilot token
   COPILOT_TOKEN         GitHub Copilot token

package/dist/cli/config/loader.cjs

@@ -91,6 +91,33 @@ class WingmanConfigLoader {
         return {
             logLevel: "info",
             recursionLimit: 5000,
+            summarization: {
+                enabled: true,
+                maxTokensBeforeSummary: 12000,
+                messagesToKeep: 8
+            },
+            modelRetry: {
+                enabled: true,
+                maxRetries: 2,
+                backoffFactor: 2,
+                initialDelayMs: 1000,
+                maxDelayMs: 60000,
+                jitter: true,
+                onFailure: "continue"
+            },
+            toolRetry: {
+                enabled: false,
+                maxRetries: 2,
+                backoffFactor: 2,
+                initialDelayMs: 1000,
+                maxDelayMs: 60000,
+                jitter: true,
+                onFailure: "continue"
+            },
+            humanInTheLoop: {
+                enabled: false,
+                interruptOn: {}
+            },
             search: {
                 provider: "duckduckgo",
                 maxResults: 5

package/dist/cli/config/loader.js

@@ -63,6 +63,33 @@ class WingmanConfigLoader {
         return {
             logLevel: "info",
             recursionLimit: 5000,
+            summarization: {
+                enabled: true,
+                maxTokensBeforeSummary: 12000,
+                messagesToKeep: 8
+            },
+            modelRetry: {
+                enabled: true,
+                maxRetries: 2,
+                backoffFactor: 2,
+                initialDelayMs: 1000,
+                maxDelayMs: 60000,
+                jitter: true,
+                onFailure: "continue"
+            },
+            toolRetry: {
+                enabled: false,
+                maxRetries: 2,
+                backoffFactor: 2,
+                initialDelayMs: 1000,
+                maxDelayMs: 60000,
+                jitter: true,
+                onFailure: "continue"
+            },
+            humanInTheLoop: {
+                enabled: false,
+                interruptOn: {}
+            },
             search: {
                 provider: "duckduckgo",
                 maxResults: 5

package/dist/cli/config/schema.cjs

@@ -25,11 +25,15 @@ 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");
@@ -49,6 +53,45 @@ const SkillsConfigSchema = external_zod_namespaceObject.z.object({
     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 SummarizationConfigSchema = external_zod_namespaceObject.z.object({
+    enabled: external_zod_namespaceObject.z.boolean().optional().default(true).describe("Enable conversation history summarization"),
+    maxTokensBeforeSummary: external_zod_namespaceObject.z.number().min(1000).max(1000000).optional().default(12000).describe("Token threshold before summarizing conversation history"),
+    messagesToKeep: external_zod_namespaceObject.z.number().min(2).max(100).optional().default(8).describe("How many most recent messages to keep after summarization")
+});
+const RetryOnFailureSchema = external_zod_namespaceObject.z["enum"]([
+    "continue",
+    "error"
+]);
+const BaseRetryConfigSchema = external_zod_namespaceObject.z.object({
+    enabled: external_zod_namespaceObject.z.boolean().optional().default(false).describe("Enable retry middleware"),
+    maxRetries: external_zod_namespaceObject.z.number().min(0).max(20).optional().default(2).describe("Maximum number of retry attempts"),
+    backoffFactor: external_zod_namespaceObject.z.number().min(0).max(10).optional().default(2).describe("Exponential backoff multiplier"),
+    initialDelayMs: external_zod_namespaceObject.z.number().min(0).max(120000).optional().default(1000).describe("Initial delay before first retry in milliseconds"),
+    maxDelayMs: external_zod_namespaceObject.z.number().min(0).max(300000).optional().default(60000).describe("Maximum backoff delay in milliseconds"),
+    jitter: external_zod_namespaceObject.z.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.z.array(external_zod_namespaceObject.z.string().min(1)).optional().describe("Optional list of tool names to apply retry logic to")
+});
+const AllowedDecisionSchema = external_zod_namespaceObject.z["enum"]([
+    "approve",
+    "edit",
+    "reject"
+]);
+const InterruptOnToolConfigSchema = external_zod_namespaceObject.z.union([
+    external_zod_namespaceObject.z.boolean(),
+    external_zod_namespaceObject.z.object({
+        allowedDecisions: external_zod_namespaceObject.z.array(AllowedDecisionSchema).min(1).describe("Allowed decisions for this tool"),
+        description: external_zod_namespaceObject.z.string().optional().describe("Optional custom review prompt for this tool"),
+        argsSchema: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.string(), external_zod_namespaceObject.z.any()).optional().describe("Optional argument schema for edit decisions")
+    })
+]);
+const HumanInTheLoopConfigSchema = external_zod_namespaceObject.z.object({
+    enabled: external_zod_namespaceObject.z.boolean().optional().default(false).describe("Enable human-in-the-loop tool approval"),
+    interruptOn: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.string(), InterruptOnToolConfigSchema).optional().default({}).describe("Per-tool approval policy mapping")
+});
 const GatewayAuthSchema = external_zod_namespaceObject.z.object({
     mode: external_zod_namespaceObject.z["enum"]([
         "token",
@@ -177,6 +220,33 @@ const WingmanConfigSchema = external_zod_namespaceObject.z.object({
     ]).optional().default("info"),
     defaultAgent: external_zod_namespaceObject.z.string().optional(),
     recursionLimit: external_zod_namespaceObject.z.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({
@@ -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

@@ -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>;

package/dist/cli/config/schema.js

@@ -16,6 +16,45 @@ const SkillsConfigSchema = z.object({
     githubToken: z.string().optional().describe("GitHub personal access token for higher API rate limits"),
     skillsDirectory: z.string().default("skills").describe("Directory to install skills in")
 });
+const SummarizationConfigSchema = z.object({
+    enabled: z.boolean().optional().default(true).describe("Enable conversation history summarization"),
+    maxTokensBeforeSummary: z.number().min(1000).max(1000000).optional().default(12000).describe("Token threshold before summarizing conversation history"),
+    messagesToKeep: z.number().min(2).max(100).optional().default(8).describe("How many most recent messages to keep after summarization")
+});
+const RetryOnFailureSchema = z["enum"]([
+    "continue",
+    "error"
+]);
+const BaseRetryConfigSchema = z.object({
+    enabled: z.boolean().optional().default(false).describe("Enable retry middleware"),
+    maxRetries: z.number().min(0).max(20).optional().default(2).describe("Maximum number of retry attempts"),
+    backoffFactor: z.number().min(0).max(10).optional().default(2).describe("Exponential backoff multiplier"),
+    initialDelayMs: z.number().min(0).max(120000).optional().default(1000).describe("Initial delay before first retry in milliseconds"),
+    maxDelayMs: z.number().min(0).max(300000).optional().default(60000).describe("Maximum backoff delay in milliseconds"),
+    jitter: z.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: z.array(z.string().min(1)).optional().describe("Optional list of tool names to apply retry logic to")
+});
+const AllowedDecisionSchema = z["enum"]([
+    "approve",
+    "edit",
+    "reject"
+]);
+const InterruptOnToolConfigSchema = z.union([
+    z.boolean(),
+    z.object({
+        allowedDecisions: z.array(AllowedDecisionSchema).min(1).describe("Allowed decisions for this tool"),
+        description: z.string().optional().describe("Optional custom review prompt for this tool"),
+        argsSchema: z.record(z.string(), z.any()).optional().describe("Optional argument schema for edit decisions")
+    })
+]);
+const HumanInTheLoopConfigSchema = z.object({
+    enabled: z.boolean().optional().default(false).describe("Enable human-in-the-loop tool approval"),
+    interruptOn: z.record(z.string(), InterruptOnToolConfigSchema).optional().default({}).describe("Per-tool approval policy mapping")
+});
 const GatewayAuthSchema = z.object({
     mode: z["enum"]([
         "token",
@@ -144,6 +183,33 @@ const WingmanConfigSchema = z.object({
     ]).optional().default("info"),
     defaultAgent: z.string().optional(),
     recursionLimit: z.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: HooksConfigSchema.optional().describe("Global tool hooks configuration"),
     hooks: InternalHooksConfigSchema.optional().describe("Internal hook configuration"),
     search: SearchConfigSchema.optional().default({
@@ -213,4 +279,4 @@ function validateConfig(data) {
         };
     }
 }
-export { AgentsConfigSchema, GatewayConfigSchema, SearchConfigSchema, SkillsConfigSchema, WingmanConfigSchema, validateConfig };
+export { AgentsConfigSchema, GatewayConfigSchema, HumanInTheLoopConfigSchema, ModelRetryConfigSchema, SearchConfigSchema, SkillsConfigSchema, SummarizationConfigSchema, ToolRetryConfigSchema, WingmanConfigSchema, validateConfig };