git-coco 0.16.2 → 0.17.0

package/dist/index.esm.mjs

@@ -18,22 +18,22 @@ import prettyMilliseconds from 'pretty-ms';
 import { ChatAnthropic } from '@langchain/anthropic';
 import { ChatOllama } from '@langchain/ollama';
 import { ChatOpenAI } from '@langchain/openai';
-import { StructuredOutputParser, BaseOutputParser } from '@langchain/core/output_parsers';
+import { StructuredOutputParser, BaseOutputParser, OutputParserException, StringOutputParser } from '@langchain/core/output_parsers';
 import { simpleGit } from 'simple-git';
-import pQueue from 'p-queue';
-import { Document, BaseDocumentTransformer } from '@langchain/core/documents';
+import { BaseLangChain, BaseLanguageModel } from '@langchain/core/language_models/base';
+import { ensureConfig, Runnable } from '@langchain/core/runnables';
 import { RUN_KEY } from '@langchain/core/outputs';
 import { CallbackManager, parseCallbackConfigArg } from '@langchain/core/callbacks/manager';
-import { ensureConfig, Runnable } from '@langchain/core/runnables';
-import { BaseLangChain, BaseLanguageModel } from '@langchain/core/language_models/base';
+import '@langchain/core/utils/json_patch';
+import pQueue from 'p-queue';
+import { Document, BaseDocumentTransformer } from '@langchain/core/documents';
+import { createTwoFilesPatch } from 'diff';
 import '@langchain/core/messages';
 import '@langchain/core/memory';
 import '@langchain/core/chat_history';
 import '@langchain/core/utils/tiktoken';
 import '@langchain/core/utils/async_caller';
 import '@langchain/core/utils/env';
-import '@langchain/core/utils/json_patch';
-import { createTwoFilesPatch } from 'diff';
 import { minimatch } from 'minimatch';
 import { encoding_for_model } from 'tiktoken';
 import { exec } from 'child_process';
@@ -46,7 +46,7 @@ import * as readline from 'readline';
 /**
  * Current build version from package.json
  */
-const BUILD_VERSION = "0.16.2";
+const BUILD_VERSION = "0.17.0";
 
 const isInteractive = (config) => {
     return config?.mode === 'interactive' || !!config?.interactive;
@@ -173,51 +173,175 @@ const SUMMARIZE_PROMPT = new PromptTemplate({
     template: template$5,
 });
 
+/**
+ * Base class for all LangChain-related errors
+ */
+class LangChainError extends Error {
+    constructor(message, context) {
+        super(message);
+        this.context = context;
+        this.name = this.constructor.name;
+    }
+}
+/**
+ * Configuration-related errors (invalid service configs, missing settings, etc.)
+ */
+class LangChainConfigurationError extends LangChainError {
+    constructor(message, context) {
+        super(message, context);
+    }
+}
+/**
+ * Input validation errors (missing required parameters, invalid types, etc.)
+ */
+class LangChainValidationError extends LangChainError {
+    constructor(message, context) {
+        super(message, context);
+    }
+}
+/**
+ * Runtime execution errors (LLM failures, parsing errors, etc.)
+ */
+class LangChainExecutionError extends LangChainError {
+    constructor(message, context) {
+        super(message, context);
+    }
+}
+/**
+ * Authentication-related errors (missing API keys, invalid credentials, etc.)
+ */
+class LangChainAuthenticationError extends LangChainError {
+    constructor(message, context) {
+        super(message, context);
+    }
+}
+
+/**
+ * Validates that a required parameter is not null or undefined
+ */
+function validateRequired(value, paramName, functionName) {
+    if (value === null || value === undefined) {
+        throw new LangChainValidationError(`${functionName ? `${functionName}: ` : ''}Required parameter '${paramName}' is missing`, { paramName, functionName, value });
+    }
+}
+/**
+ * Validates that a string parameter is not empty
+ */
+function validateNonEmptyString(value, paramName, functionName) {
+    validateRequired(value, paramName, functionName);
+    if (typeof value !== 'string' || value.trim() === '') {
+        throw new LangChainValidationError(`${functionName ? `${functionName}: ` : ''}Parameter '${paramName}' must be a non-empty string`, { paramName, functionName, value, type: typeof value });
+    }
+}
+/**
+ * Validates that an array parameter is not empty
+ */
+function validateNonEmptyArray(value, paramName, functionName) {
+    validateRequired(value, paramName, functionName);
+    if (!Array.isArray(value) || value.length === 0) {
+        throw new LangChainValidationError(`${functionName ? `${functionName}: ` : ''}Parameter '${paramName}' must be a non-empty array`, { paramName, functionName, value, isArray: Array.isArray(value), length: Array.isArray(value) ? value.length : undefined });
+    }
+}
+/**
+ * Validates that a provider is supported
+ */
+function validateProvider(provider, functionName) {
+    const validProviders = ['openai', 'anthropic', 'ollama'];
+    if (!validProviders.includes(provider)) {
+        throw new LangChainConfigurationError(`${functionName ? `${functionName}: ` : ''}Invalid provider '${provider}'. Supported providers: ${validProviders.join(', ')}`, { provider, validProviders, functionName });
+    }
+}
+/**
+ * Validates that a model is valid for the given provider
+ */
+function validateModel(model, provider, functionName) {
+    validateRequired(model, 'model', functionName);
+    if (typeof model !== 'string' || model.trim() === '') {
+        throw new LangChainValidationError(`${functionName ? `${functionName}: ` : ''}Model must be a non-empty string`, { model, provider, functionName });
+    }
+    // Additional provider-specific validation could be added here
+    // For now, we trust the TypeScript types
+}
+/**
+ * Validates that a service configuration is complete and valid
+ */
+function validateServiceConfig(service, functionName) {
+    validateRequired(service, 'service', functionName);
+    if (typeof service !== 'object') {
+        throw new LangChainConfigurationError(`${functionName ? `${functionName}: ` : ''}Service configuration must be an object`, { service, functionName });
+    }
+    const serviceObj = service;
+    validateProvider(serviceObj.provider, functionName);
+    validateModel(serviceObj.model, serviceObj.provider, functionName);
+    // Validate authentication
+    if (!serviceObj.authentication || typeof serviceObj.authentication !== 'object') {
+        throw new LangChainConfigurationError(`${functionName ? `${functionName}: ` : ''}Service configuration must include authentication`, { service, functionName });
+    }
+}
+
 /**
  * Retrieves the provider and model from the given configuration object.
  * @param config The configuration object.
  * @returns An object containing the provider and model.
- * @throws Error if the configuration is invalid or missing required properties.
+ * @throws LangChainConfigurationError if the configuration is invalid or missing required properties.
  */
 function getModelAndProviderFromConfig(config) {
+    validateRequired(config, 'config', 'getModelAndProviderFromConfig');
     if (!config.service) {
-        throw new Error('Invalid service: undefined');
+        throw new LangChainConfigurationError('getModelAndProviderFromConfig: Service configuration is missing', { config });
     }
+    validateServiceConfig(config.service, 'getModelAndProviderFromConfig');
     const { provider, model } = config.service;
-    if (!model || !provider) {
-        throw new Error(`Invalid service: ${config.service}`);
-    }
     return { provider, model };
 }
 /**
  * Retrieve appropriate API key based on selected model
- * @param service
- * @param options
- * @returns API Key
+ * @param config The configuration object
+ * @returns API Key or empty string if no authentication required
+ * @throws LangChainAuthenticationError if authentication is required but missing
  */
 function getApiKeyForModel(config) {
-    const { provider } = getModelAndProviderFromConfig(config);
-    switch (provider) {
-        case 'openai':
-            return getDefaultServiceApiKey(config);
-        default:
-            return getDefaultServiceApiKey(config);
-    }
+    validateRequired(config, 'config', 'getApiKeyForModel');
+    // This function now simply delegates to getDefaultServiceApiKey
+    // The switch statement was unnecessary since all providers use the same logic
+    return getDefaultServiceApiKey(config);
 }
 /**
  * Retrieves the default service API key from the given configuration.
  * @param config The configuration object.
- * @returns The default service API key.
+ * @returns The default service API key or empty string for services that don't require authentication.
+ * @throws LangChainAuthenticationError if authentication is required but invalid.
  */
 function getDefaultServiceApiKey(config) {
+    validateRequired(config, 'config', 'getDefaultServiceApiKey');
+    validateServiceConfig(config.service, 'getDefaultServiceApiKey');
     const service = config.service;
+    const { provider } = service;
+    // Check if authentication is required for this provider
+    const requiresAuth = provider === 'openai' || provider === 'anthropic';
     if (service.authentication.type === 'APIKey') {
-        return service.authentication.credentials?.apiKey;
+        const apiKey = service.authentication.credentials?.apiKey;
+        if (requiresAuth && (!apiKey || apiKey.trim() === '')) {
+            throw new LangChainAuthenticationError(`getDefaultServiceApiKey: API key is required for ${provider} provider but not provided`, { provider, authenticationType: service.authentication.type });
+        }
+        return apiKey || '';
+    }
+    if (service.authentication.type === 'OAuth') {
+        const token = service.authentication.credentials?.token;
+        if (requiresAuth && (!token || token.trim() === '')) {
+            throw new LangChainAuthenticationError(`getDefaultServiceApiKey: OAuth token is required for ${provider} provider but not provided`, { provider, authenticationType: service.authentication.type });
+        }
+        return token || '';
     }
-    else if (service.authentication.type === 'OAuth') {
-        return service.authentication.credentials?.token;
+    if (service.authentication.type === 'None') {
+        if (requiresAuth) {
+            throw new LangChainAuthenticationError(`getDefaultServiceApiKey: ${provider} provider requires authentication but 'None' was configured`, { provider, authenticationType: service.authentication.type });
+        }
+        return '';
     }
-    return '';
+    // This should never be reached due to TypeScript type checking, but included for safety
+    const authType = service.authentication.type;
+    throw new LangChainConfigurationError(`getDefaultServiceApiKey: Unknown authentication type '${authType}'`, { provider, authentication: service.authentication });
 }
 const DEFAULT_OPENAI_LLM_SERVICE = {
     provider: 'openai',
@@ -231,6 +355,17 @@ const DEFAULT_OPENAI_LLM_SERVICE = {
         },
     },
 };
+const DEFAULT_ANTHROPIC_LLM_SERVICE = {
+    provider: 'anthropic',
+    model: 'claude-3-5-sonnet-20240620',
+    temperature: 0.32,
+    authentication: {
+        type: 'APIKey',
+        credentials: {
+            apiKey: '',
+        },
+    },
+};
 const DEFAULT_OLLAMA_LLM_SERVICE = {
     provider: 'ollama',
     model: 'llama3',
@@ -238,24 +373,33 @@ const DEFAULT_OLLAMA_LLM_SERVICE = {
     maxConcurrent: 1,
     tokenLimit: 2024,
     temperature: 0.4,
+    maxParsingAttempts: 3,
     authentication: {
         type: 'None',
         credentials: undefined,
     },
 };
 /**
- * Retrieves the default service configuration based on the provided alias and optional model.
- * @param provider - The alias of the service.
- * @param model - The optional model to be used.
- * @returns The default service configuration.
- * @throws Error if the alias is invalid or undefined.
+ * Retrieves the default service configuration based on the provided provider and optional model.
+ * @param provider - The LLM provider (openai, anthropic, ollama).
+ * @param model - The optional model to be used. If not provided, uses the default model for the provider.
+ * @returns The default service configuration for the specified provider.
+ * @throws LangChainConfigurationError if the provider is invalid or unsupported.
  */
 function getDefaultServiceConfigFromAlias(provider, model) {
+    validateRequired(provider, 'provider', 'getDefaultServiceConfigFromAlias');
+    // Validate model if provided
+    if (model !== undefined) {
+        validateRequired(model, 'model', 'getDefaultServiceConfigFromAlias');
+        if (typeof model !== 'string' || model.trim() === '') {
+            throw new LangChainConfigurationError('getDefaultServiceConfigFromAlias: Model must be a non-empty string when provided', { provider, model });
+        }
+    }
     switch (provider) {
         case 'anthropic':
             return {
-                ...DEFAULT_OPENAI_LLM_SERVICE,
-                model: model || DEFAULT_OPENAI_LLM_SERVICE.model,
+                ...DEFAULT_ANTHROPIC_LLM_SERVICE,
+                model: model || DEFAULT_ANTHROPIC_LLM_SERVICE.model,
             };
         case 'ollama':
             return {
@@ -263,11 +407,12 @@ function getDefaultServiceConfigFromAlias(provider, model) {
                 model: model || DEFAULT_OLLAMA_LLM_SERVICE.model,
             };
         case 'openai':
-        default:
             return {
                 ...DEFAULT_OPENAI_LLM_SERVICE,
                 model: model || DEFAULT_OPENAI_LLM_SERVICE.model,
             };
+        default:
+            throw new LangChainConfigurationError(`getDefaultServiceConfigFromAlias: Unsupported provider '${provider}'. Supported providers: openai, anthropic, ollama`, { provider, supportedProviders: ['openai', 'anthropic', 'ollama'] });
     }
 }
 
@@ -893,6 +1038,11 @@ const schema$1 = {
                         }
                     },
                     "additionalProperties": false
+                },
+                "maxParsingAttempts": {
+                    "type": "number",
+                    "description": "The maximum number of attempts for schema parsing with retry logic.",
+                    "default": 3
                 }
             },
             "required": [
@@ -983,6 +1133,9 @@ const schema$1 = {
         "OllamaModel": {
             "type": "string",
             "enum": [
+                "deepseek-r1:1.5b",
+                "deepseek-r1:8b",
+                "deepseek-r1:32b",
                 "codegemma:2b",
                 "codegemma:7b-code",
                 "codegemma",
@@ -1014,9 +1167,11 @@ const schema$1 = {
                 "llama3.2:latest",
                 "llama3.2:1b",
                 "llama3.2:3b",
-                "llama3.2:1b-instruct-fp16",
-                "llama3.2:1b-instruct-q3_K_M",
                 "llama3",
+                "llava-llama3:latest",
+                "dolphin-llama3:latest",
+                "dolphin-llama3:8b",
+                "dolphin-llama3:70b",
                 "mistral:7b",
                 "mistral:latest",
                 "mistral:text",
@@ -1032,18 +1187,28 @@ const schema$1 = {
                 "qwen2:1.5b",
                 "qwen2:72b-text",
                 "qwen2:72b",
-                "qwen2"
+                "qwen2",
+                "qwen2.5-coder:latest",
+                "qwen2.5-coder:0.5b",
+                "qwen2.5-coder:1.5b",
+                "qwen2.5-coder:3b",
+                "qwen2.5-coder:7b",
+                "qwen2.5-coder:14b",
+                "qwen2.5-coder:32b"
             ]
         },
         "AnthropicModel": {
             "type": "string",
             "enum": [
+                "claude-sonnet-4-0",
+                "claude-3-7-sonnet-latest",
+                "claude-3-5-haiku-latest",
+                "claude-3-5-sonnet-latest",
+                "claude-3-5-sonnet-20241022",
                 "claude-3-5-sonnet-20240620",
                 "claude-3-opus-20240229",
                 "claude-3-sonnet-20240229",
-                "claude-3-haiku-20240307",
-                "claude-2.1",
-                "claude-2.0"
+                "claude-3-haiku-20240307"
             ]
         },
         "Callbacks": {
@@ -1488,6 +1653,11 @@ const schema$1 = {
                         }
                     },
                     "additionalProperties": false
+                },
+                "maxParsingAttempts": {
+                    "type": "number",
+                    "description": "The maximum number of attempts for schema parsing with retry logic.",
+                    "default": 3
                 }
             },
             "required": [
@@ -1634,6 +1804,11 @@ const schema$1 = {
                         }
                     },
                     "additionalProperties": false
+                },
+                "maxParsingAttempts": {
+                    "type": "number",
+                    "description": "The maximum number of attempts for schema parsing with retry logic.",
+                    "default": 3
                 }
             },
             "required": [
@@ -1853,7 +2028,7 @@ function commandExecutor(handler) {
 
 var util;
 (function (util) {
-    util.assertEqual = (val) => val;
+    util.assertEqual = (_) => { };
     function assertIs(_arg) { }
     util.assertIs = assertIs;
     function assertNever(_x) {
@@ -1900,11 +2075,9 @@ var util;
     };
     util.isInteger = typeof Number.isInteger === "function"
         ? (val) => Number.isInteger(val) // eslint-disable-line ban/ban
-        : (val) => typeof val === "number" && isFinite(val) && Math.floor(val) === val;
+        : (val) => typeof val === "number" && Number.isFinite(val) && Math.floor(val) === val;
     function joinValues(array, separator = " | ") {
-        return array
-            .map((val) => (typeof val === "string" ? `'${val}'` : val))
-            .join(separator);
+        return array.map((val) => (typeof val === "string" ? `'${val}'` : val)).join(separator);
     }
     util.joinValues = joinValues;
     util.jsonStringifyReplacer = (_, value) => {
@@ -1953,7 +2126,7 @@ const getParsedType = (data) => {
         case "string":
             return ZodParsedType.string;
         case "number":
-            return isNaN(data) ? ZodParsedType.nan : ZodParsedType.number;
+            return Number.isNaN(data) ? ZodParsedType.nan : ZodParsedType.number;
         case "boolean":
             return ZodParsedType.boolean;
         case "function":
@@ -1969,10 +2142,7 @@ const getParsedType = (data) => {
             if (data === null) {
                 return ZodParsedType.null;
             }
-            if (data.then &&
-                typeof data.then === "function" &&
-                data.catch &&
-                typeof data.catch === "function") {
+            if (data.then && typeof data.then === "function" && data.catch && typeof data.catch === "function") {
                 return ZodParsedType.promise;
             }
             if (typeof Map !== "undefined" && data instanceof Map) {
@@ -2008,10 +2178,6 @@ const ZodIssueCode = util.arrayToEnum([
     "not_multiple_of",
     "not_finite",
 ]);
-const quotelessJson = (obj) => {
-    const json = JSON.stringify(obj, null, 2);
-    return json.replace(/"([^"]+)":/g, "$1:");
-};
 class ZodError extends Error {
     get errors() {
         return this.issues;
@@ -2104,8 +2270,9 @@ class ZodError extends Error {
         const formErrors = [];
         for (const sub of this.issues) {
             if (sub.path.length > 0) {
-                fieldErrors[sub.path[0]] = fieldErrors[sub.path[0]] || [];
-                fieldErrors[sub.path[0]].push(mapper(sub));
+                const firstEl = sub.path[0];
+                fieldErrors[firstEl] = fieldErrors[firstEl] || [];
+                fieldErrors[firstEl].push(mapper(sub));
             }
             else {
                 formErrors.push(mapper(sub));
@@ -2188,17 +2355,11 @@ const errorMap = (issue, _ctx) => {
             else if (issue.type === "string")
                 message = `String must contain ${issue.exact ? "exactly" : issue.inclusive ? `at least` : `over`} ${issue.minimum} character(s)`;
             else if (issue.type === "number")
-                message = `Number must be ${issue.exact
-                    ? `exactly equal to `
-                    : issue.inclusive
-                        ? `greater than or equal to `
-                        : `greater than `}${issue.minimum}`;
+                message = `Number must be ${issue.exact ? `exactly equal to ` : issue.inclusive ? `greater than or equal to ` : `greater than `}${issue.minimum}`;
+            else if (issue.type === "bigint")
+                message = `Number must be ${issue.exact ? `exactly equal to ` : issue.inclusive ? `greater than or equal to ` : `greater than `}${issue.minimum}`;
             else if (issue.type === "date")
-                message = `Date must be ${issue.exact
-                    ? `exactly equal to `
-                    : issue.inclusive
-                        ? `greater than or equal to `
-                        : `greater than `}${new Date(Number(issue.minimum))}`;
+                message = `Date must be ${issue.exact ? `exactly equal to ` : issue.inclusive ? `greater than or equal to ` : `greater than `}${new Date(Number(issue.minimum))}`;
             else
                 message = "Invalid input";
             break;
@@ -2208,23 +2369,11 @@ const errorMap = (issue, _ctx) => {
             else if (issue.type === "string")
                 message = `String must contain ${issue.exact ? `exactly` : issue.inclusive ? `at most` : `under`} ${issue.maximum} character(s)`;
             else if (issue.type === "number")
-                message = `Number must be ${issue.exact
-                    ? `exactly`
-                    : issue.inclusive
-                        ? `less than or equal to`
-                        : `less than`} ${issue.maximum}`;
+                message = `Number must be ${issue.exact ? `exactly` : issue.inclusive ? `less than or equal to` : `less than`} ${issue.maximum}`;
             else if (issue.type === "bigint")
-                message = `BigInt must be ${issue.exact
-                    ? `exactly`
-                    : issue.inclusive
-                        ? `less than or equal to`
-                        : `less than`} ${issue.maximum}`;
+                message = `BigInt must be ${issue.exact ? `exactly` : issue.inclusive ? `less than or equal to` : `less than`} ${issue.maximum}`;
             else if (issue.type === "date")
-                message = `Date must be ${issue.exact
-                    ? `exactly`
-                    : issue.inclusive
-                        ? `smaller than or equal to`
-                        : `smaller than`} ${new Date(Number(issue.maximum))}`;
+                message = `Date must be ${issue.exact ? `exactly` : issue.inclusive ? `smaller than or equal to` : `smaller than`} ${new Date(Number(issue.maximum))}`;
             else
                 message = "Invalid input";
             break;
@@ -2246,11 +2395,9 @@ const errorMap = (issue, _ctx) => {
     }
     return { message };
 };
+var defaultErrorMap = errorMap;
 
-let overrideErrorMap = errorMap;
-function setErrorMap(map) {
-    overrideErrorMap = map;
-}
+let overrideErrorMap = defaultErrorMap;
 function getErrorMap() {
     return overrideErrorMap;
 }
@@ -2283,7 +2430,6 @@ const makeIssue = (params) => {
         message: errorMessage,
     };
 };
-const EMPTY_PATH = [];
 function addIssueToContext(ctx, issueData) {
     const overrideMap = getErrorMap();
     const issue = makeIssue({
@@ -2294,7 +2440,7 @@ function addIssueToContext(ctx, issueData) {
             ctx.common.contextualErrorMap, // contextual error map is first priority
             ctx.schemaErrorMap, // then schema-bound map if available
             overrideMap, // then global override map
-            overrideMap === errorMap ? undefined : errorMap, // then global default map
+            overrideMap === defaultErrorMap ? undefined : defaultErrorMap, // then global default map
         ].filter((x) => !!x),
     });
     ctx.common.issues.push(issue);
@@ -2346,8 +2492,7 @@ class ParseStatus {
                 status.dirty();
             if (value.status === "dirty")
                 status.dirty();
-            if (key.value !== "__proto__" &&
-                (typeof value.value !== "undefined" || pair.alwaysSet)) {
+            if (key.value !== "__proto__" && (typeof value.value !== "undefined" || pair.alwaysSet)) {
                 finalObject[key.value] = value.value;
             }
         }
@@ -2364,46 +2509,13 @@ const isDirty = (x) => x.status === "dirty";
 const isValid = (x) => x.status === "valid";
 const isAsync = (x) => typeof Promise !== "undefined" && x instanceof Promise;
 
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-
-function __classPrivateFieldGet(receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-}
-
-function __classPrivateFieldSet(receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-}
-
-typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-};
-
 var errorUtil;
 (function (errorUtil) {
     errorUtil.errToObj = (message) => typeof message === "string" ? { message } : message || {};
-    errorUtil.toString = (message) => typeof message === "string" ? message : message === null || message === void 0 ? void 0 : message.message;
+    // biome-ignore lint:
+    errorUtil.toString = (message) => typeof message === "string" ? message : message?.message;
 })(errorUtil || (errorUtil = {}));
 
-var _ZodEnum_cache, _ZodNativeEnum_cache;
 class ParseInputLazyPath {
     constructor(parent, value, path, key) {
         this._cachedPath = [];
@@ -2414,7 +2526,7 @@ class ParseInputLazyPath {
     }
     get path() {
         if (!this._cachedPath.length) {
-            if (this._key instanceof Array) {
+            if (Array.isArray(this._key)) {
                 this._cachedPath.push(...this._path, ...this._key);
             }
             else {
@@ -2454,17 +2566,16 @@ function processCreateParams(params) {
     if (errorMap)
         return { errorMap: errorMap, description };
     const customMap = (iss, ctx) => {
-        var _a, _b;
         const { message } = params;
         if (iss.code === "invalid_enum_value") {
-            return { message: message !== null && message !== void 0 ? message : ctx.defaultError };
+            return { message: message ?? ctx.defaultError };
         }
         if (typeof ctx.data === "undefined") {
-            return { message: (_a = message !== null && message !== void 0 ? message : required_error) !== null && _a !== void 0 ? _a : ctx.defaultError };
+            return { message: message ?? required_error ?? ctx.defaultError };
         }
         if (iss.code !== "invalid_type")
             return { message: ctx.defaultError };
-        return { message: (_b = message !== null && message !== void 0 ? message : invalid_type_error) !== null && _b !== void 0 ? _b : ctx.defaultError };
+        return { message: message ?? invalid_type_error ?? ctx.defaultError };
     };
     return { errorMap: customMap, description };
 }
@@ -2516,14 +2627,13 @@ class ZodType {
         throw result.error;
     }
     safeParse(data, params) {
-        var _a;
         const ctx = {
             common: {
                 issues: [],
-                async: (_a = params === null || params === void 0 ? void 0 : params.async) !== null && _a !== void 0 ? _a : false,
-                contextualErrorMap: params === null || params === void 0 ? void 0 : params.errorMap,
+                async: params?.async ?? false,
+                contextualErrorMap: params?.errorMap,
             },
-            path: (params === null || params === void 0 ? void 0 : params.path) || [],
+            path: params?.path || [],
             schemaErrorMap: this._def.errorMap,
             parent: null,
             data,
@@ -2533,7 +2643,6 @@ class ZodType {
         return handleResult$1(ctx, result);
     }
     "~validate"(data) {
-        var _a, _b;
         const ctx = {
             common: {
                 issues: [],
@@ -2557,7 +2666,7 @@ class ZodType {
                     };
             }
             catch (err) {
-                if ((_b = (_a = err === null || err === void 0 ? void 0 : err.message) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === null || _b === void 0 ? void 0 : _b.includes("encountered")) {
+                if (err?.message?.toLowerCase()?.includes("encountered")) {
                     this["~standard"].async = true;
                 }
                 ctx.common = {
@@ -2584,19 +2693,17 @@ class ZodType {
         const ctx = {
             common: {
                 issues: [],
-                contextualErrorMap: params === null || params === void 0 ? void 0 : params.errorMap,
+                contextualErrorMap: params?.errorMap,
                 async: true,
             },
-            path: (params === null || params === void 0 ? void 0 : params.path) || [],
+            path: params?.path || [],
             schemaErrorMap: this._def.errorMap,
             parent: null,
             data,
             parsedType: getParsedType(data),
         };
         const maybeAsyncResult = this._parse({ data, path: ctx.path, parent: ctx });
-        const result = await (isAsync(maybeAsyncResult)
-            ? maybeAsyncResult
-            : Promise.resolve(maybeAsyncResult));
+        const result = await (isAsync(maybeAsyncResult) ? maybeAsyncResult : Promise.resolve(maybeAsyncResult));
         return handleResult$1(ctx, result);
     }
     refine(check, message) {
@@ -2640,9 +2747,7 @@ class ZodType {
     refinement(check, refinementData) {
         return this._refinement((val, ctx) => {
             if (!check(val)) {
-                ctx.addIssue(typeof refinementData === "function"
-                    ? refinementData(val, ctx)
-                    : refinementData);
+                ctx.addIssue(typeof refinementData === "function" ? refinementData(val, ctx) : refinementData);
                 return false;
             }
             else {
@@ -2814,15 +2919,15 @@ const base64urlRegex = /^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)|([0-9a-zA-Z
 const dateRegexSource = `((\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-((0[13578]|1[02])-(0[1-9]|[12]\\d|3[01])|(0[469]|11)-(0[1-9]|[12]\\d|30)|(02)-(0[1-9]|1\\d|2[0-8])))`;
 const dateRegex = new RegExp(`^${dateRegexSource}$`);
 function timeRegexSource(args) {
-    // let regex = `\\d{2}:\\d{2}:\\d{2}`;
-    let regex = `([01]\\d|2[0-3]):[0-5]\\d:[0-5]\\d`;
+    let secondsRegexSource = `[0-5]\\d`;
     if (args.precision) {
-        regex = `${regex}\\.\\d{${args.precision}}`;
+        secondsRegexSource = `${secondsRegexSource}\\.\\d{${args.precision}}`;
     }
     else if (args.precision == null) {
-        regex = `${regex}(\\.\\d+)?`;
+        secondsRegexSource = `${secondsRegexSource}(\\.\\d+)?`;
     }
-    return regex;
+    const secondsQuantifier = args.precision ? "+" : "?"; // require seconds if precision is nonzero
+    return `([01]\\d|2[0-3]):[0-5]\\d(:${secondsRegexSource})${secondsQuantifier}`;
 }
 function timeRegex(args) {
     return new RegExp(`^${timeRegexSource(args)}$`);
@@ -2851,6 +2956,8 @@ function isValidJWT(jwt, alg) {
         return false;
     try {
         const [header] = jwt.split(".");
+        if (!header)
+            return false;
         // Convert base64url to base64
         const base64 = header
             .replace(/-/g, "+")
@@ -2859,13 +2966,15 @@ function isValidJWT(jwt, alg) {
         const decoded = JSON.parse(atob(base64));
         if (typeof decoded !== "object" || decoded === null)
             return false;
-        if (!decoded.typ || !decoded.alg)
+        if ("typ" in decoded && decoded?.typ !== "JWT")
+            return false;
+        if (!decoded.alg)
             return false;
         if (alg && decoded.alg !== alg)
             return false;
         return true;
     }
-    catch (_a) {
+    catch {
         return false;
     }
 }
@@ -3036,7 +3145,7 @@ class ZodString extends ZodType {
                 try {
                     new URL(input.data);
                 }
-                catch (_a) {
+                catch {
                     ctx = this._getOrReturnCtx(input, ctx);
                     addIssueToContext(ctx, {
                         validation: "url",
@@ -3266,7 +3375,6 @@ class ZodString extends ZodType {
         return this._addCheck({ kind: "cidr", ...errorUtil.errToObj(options) });
     }
     datetime(options) {
-        var _a, _b;
         if (typeof options === "string") {
             return this._addCheck({
                 kind: "datetime",
@@ -3278,10 +3386,10 @@ class ZodString extends ZodType {
         }
         return this._addCheck({
             kind: "datetime",
-            precision: typeof (options === null || options === void 0 ? void 0 : options.precision) === "undefined" ? null : options === null || options === void 0 ? void 0 : options.precision,
-            offset: (_a = options === null || options === void 0 ? void 0 : options.offset) !== null && _a !== void 0 ? _a : false,
-            local: (_b = options === null || options === void 0 ? void 0 : options.local) !== null && _b !== void 0 ? _b : false,
-            ...errorUtil.errToObj(options === null || options === void 0 ? void 0 : options.message),
+            precision: typeof options?.precision === "undefined" ? null : options?.precision,
+            offset: options?.offset ?? false,
+            local: options?.local ?? false,
+            ...errorUtil.errToObj(options?.message),
         });
     }
     date(message) {
@@ -3297,8 +3405,8 @@ class ZodString extends ZodType {
         }
         return this._addCheck({
             kind: "time",
-            precision: typeof (options === null || options === void 0 ? void 0 : options.precision) === "undefined" ? null : options === null || options === void 0 ? void 0 : options.precision,
-            ...errorUtil.errToObj(options === null || options === void 0 ? void 0 : options.message),
+            precision: typeof options?.precision === "undefined" ? null : options?.precision,
+            ...errorUtil.errToObj(options?.message),
         });
     }
     duration(message) {
@@ -3315,8 +3423,8 @@ class ZodString extends ZodType {
         return this._addCheck({
             kind: "includes",
             value: value,
-            position: options === null || options === void 0 ? void 0 : options.position,
-            ...errorUtil.errToObj(options === null || options === void 0 ? void 0 : options.message),
+            position: options?.position,
+            ...errorUtil.errToObj(options?.message),
         });
     }
     startsWith(value, message) {
@@ -3449,11 +3557,10 @@ class ZodString extends ZodType {
     }
 }
 ZodString.create = (params) => {
-    var _a;
     return new ZodString({
         checks: [],
         typeName: ZodFirstPartyTypeKind.ZodString,
-        coerce: (_a = params === null || params === void 0 ? void 0 : params.coerce) !== null && _a !== void 0 ? _a : false,
+        coerce: params?.coerce ?? false,
         ...processCreateParams(params),
     });
 };
@@ -3462,9 +3569,9 @@ function floatSafeRemainder(val, step) {
     const valDecCount = (val.toString().split(".")[1] || "").length;
     const stepDecCount = (step.toString().split(".")[1] || "").length;
     const decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount;
-    const valInt = parseInt(val.toFixed(decCount).replace(".", ""));
-    const stepInt = parseInt(step.toFixed(decCount).replace(".", ""));
-    return (valInt % stepInt) / Math.pow(10, decCount);
+    const valInt = Number.parseInt(val.toFixed(decCount).replace(".", ""));
+    const stepInt = Number.parseInt(step.toFixed(decCount).replace(".", ""));
+    return (valInt % stepInt) / 10 ** decCount;
 }
 class ZodNumber extends ZodType {
     constructor() {
@@ -3503,9 +3610,7 @@ class ZodNumber extends ZodType {
                 }
             }
             else if (check.kind === "min") {
-                const tooSmall = check.inclusive
-                    ? input.data < check.value
-                    : input.data <= check.value;
+                const tooSmall = check.inclusive ? input.data < check.value : input.data <= check.value;
                 if (tooSmall) {
                     ctx = this._getOrReturnCtx(input, ctx);
                     addIssueToContext(ctx, {
@@ -3520,9 +3625,7 @@ class ZodNumber extends ZodType {
                 }
             }
             else if (check.kind === "max") {
-                const tooBig = check.inclusive
-                    ? input.data > check.value
-                    : input.data >= check.value;
+                const tooBig = check.inclusive ? input.data > check.value : input.data >= check.value;
                 if (tooBig) {
                     ctx = this._getOrReturnCtx(input, ctx);
                     addIssueToContext(ctx, {
@@ -3680,15 +3783,13 @@ class ZodNumber extends ZodType {
         return max;
     }
     get isInt() {
-        return !!this._def.checks.find((ch) => ch.kind === "int" ||
-            (ch.kind === "multipleOf" && util.isInteger(ch.value)));
+        return !!this._def.checks.find((ch) => ch.kind === "int" || (ch.kind === "multipleOf" && util.isInteger(ch.value)));
     }
     get isFinite() {
-        let max = null, min = null;
+        let max = null;
+        let min = null;
         for (const ch of this._def.checks) {
-            if (ch.kind === "finite" ||
-                ch.kind === "int" ||
-                ch.kind === "multipleOf") {
+            if (ch.kind === "finite" || ch.kind === "int" || ch.kind === "multipleOf") {
                 return true;
             }
             else if (ch.kind === "min") {
@@ -3707,7 +3808,7 @@ ZodNumber.create = (params) => {
     return new ZodNumber({
         checks: [],
         typeName: ZodFirstPartyTypeKind.ZodNumber,
-        coerce: (params === null || params === void 0 ? void 0 : params.coerce) || false,
+        coerce: params?.coerce || false,
         ...processCreateParams(params),
     });
 };
@@ -3722,7 +3823,7 @@ class ZodBigInt extends ZodType {
             try {
                 input.data = BigInt(input.data);
             }
-            catch (_a) {
+            catch {
                 return this._getInvalidInput(input);
             }
         }
@@ -3734,9 +3835,7 @@ class ZodBigInt extends ZodType {
         const status = new ParseStatus();
         for (const check of this._def.checks) {
             if (check.kind === "min") {
-                const tooSmall = check.inclusive
-                    ? input.data < check.value
-                    : input.data <= check.value;
+                const tooSmall = check.inclusive ? input.data < check.value : input.data <= check.value;
                 if (tooSmall) {
                     ctx = this._getOrReturnCtx(input, ctx);
                     addIssueToContext(ctx, {
@@ -3750,9 +3849,7 @@ class ZodBigInt extends ZodType {
                 }
             }
             else if (check.kind === "max") {
-                const tooBig = check.inclusive
-                    ? input.data > check.value
-                    : input.data >= check.value;
+                const tooBig = check.inclusive ? input.data > check.value : input.data >= check.value;
                 if (tooBig) {
                     ctx = this._getOrReturnCtx(input, ctx);
                     addIssueToContext(ctx, {
@@ -3884,11 +3981,10 @@ class ZodBigInt extends ZodType {
     }
 }
 ZodBigInt.create = (params) => {
-    var _a;
     return new ZodBigInt({
         checks: [],
         typeName: ZodFirstPartyTypeKind.ZodBigInt,
-        coerce: (_a = params === null || params === void 0 ? void 0 : params.coerce) !== null && _a !== void 0 ? _a : false,
+        coerce: params?.coerce ?? false,
         ...processCreateParams(params),
     });
 };
@@ -3913,7 +4009,7 @@ class ZodBoolean extends ZodType {
 ZodBoolean.create = (params) => {
     return new ZodBoolean({
         typeName: ZodFirstPartyTypeKind.ZodBoolean,
-        coerce: (params === null || params === void 0 ? void 0 : params.coerce) || false,
+        coerce: params?.coerce || false,
         ...processCreateParams(params),
     });
 };
@@ -3932,7 +4028,7 @@ class ZodDate extends ZodType {
             });
             return INVALID;
         }
-        if (isNaN(input.data.getTime())) {
+        if (Number.isNaN(input.data.getTime())) {
             const ctx = this._getOrReturnCtx(input);
             addIssueToContext(ctx, {
                 code: ZodIssueCode.invalid_date,
@@ -4023,7 +4119,7 @@ class ZodDate extends ZodType {
 ZodDate.create = (params) => {
     return new ZodDate({
         checks: [],
-        coerce: (params === null || params === void 0 ? void 0 : params.coerce) || false,
+        coerce: params?.coerce || false,
         typeName: ZodFirstPartyTypeKind.ZodDate,
         ...processCreateParams(params),
     });
@@ -4345,7 +4441,8 @@ class ZodObject extends ZodType {
             return this._cached;
         const shape = this._def.shape();
         const keys = util.objectKeys(shape);
-        return (this._cached = { shape, keys });
+        this._cached = { shape, keys };
+        return this._cached;
     }
     _parse(input) {
         const parsedType = this._getType(input);
@@ -4361,8 +4458,7 @@ class ZodObject extends ZodType {
         const { status, ctx } = this._processInputParams(input);
         const { shape, keys: shapeKeys } = this._getCached();
         const extraKeys = [];
-        if (!(this._def.catchall instanceof ZodNever &&
-            this._def.unknownKeys === "strip")) {
+        if (!(this._def.catchall instanceof ZodNever && this._def.unknownKeys === "strip")) {
             for (const key in ctx.data) {
                 if (!shapeKeys.includes(key)) {
                     extraKeys.push(key);
@@ -4450,11 +4546,10 @@ class ZodObject extends ZodType {
             ...(message !== undefined
                 ? {
                     errorMap: (issue, ctx) => {
-                        var _a, _b, _c, _d;
-                        const defaultError = (_c = (_b = (_a = this._def).errorMap) === null || _b === void 0 ? void 0 : _b.call(_a, issue, ctx).message) !== null && _c !== void 0 ? _c : ctx.defaultError;
+                        const defaultError = this._def.errorMap?.(issue, ctx).message ?? ctx.defaultError;
                         if (issue.code === "unrecognized_keys")
                             return {
-                                message: (_d = errorUtil.errToObj(message).message) !== null && _d !== void 0 ? _d : defaultError,
+                                message: errorUtil.errToObj(message).message ?? defaultError,
                             };
                         return {
                             message: defaultError,
@@ -4586,11 +4681,11 @@ class ZodObject extends ZodType {
     }
     pick(mask) {
         const shape = {};
-        util.objectKeys(mask).forEach((key) => {
+        for (const key of util.objectKeys(mask)) {
             if (mask[key] && this.shape[key]) {
                 shape[key] = this.shape[key];
             }
-        });
+        }
         return new ZodObject({
             ...this._def,
             shape: () => shape,
@@ -4598,11 +4693,11 @@ class ZodObject extends ZodType {
     }
     omit(mask) {
         const shape = {};
-        util.objectKeys(this.shape).forEach((key) => {
+        for (const key of util.objectKeys(this.shape)) {
             if (!mask[key]) {
                 shape[key] = this.shape[key];
             }
-        });
+        }
         return new ZodObject({
             ...this._def,
             shape: () => shape,
@@ -4616,7 +4711,7 @@ class ZodObject extends ZodType {
     }
     partial(mask) {
         const newShape = {};
-        util.objectKeys(this.shape).forEach((key) => {
+        for (const key of util.objectKeys(this.shape)) {
             const fieldSchema = this.shape[key];
             if (mask && !mask[key]) {
                 newShape[key] = fieldSchema;
@@ -4624,7 +4719,7 @@ class ZodObject extends ZodType {
             else {
                 newShape[key] = fieldSchema.optional();
             }
-        });
+        }
         return new ZodObject({
             ...this._def,
             shape: () => newShape,
@@ -4632,7 +4727,7 @@ class ZodObject extends ZodType {
     }
     required(mask) {
         const newShape = {};
-        util.objectKeys(this.shape).forEach((key) => {
+        for (const key of util.objectKeys(this.shape)) {
             if (mask && !mask[key]) {
                 newShape[key] = this.shape[key];
             }
@@ -4644,7 +4739,7 @@ class ZodObject extends ZodType {
                 }
                 newShape[key] = newField;
             }
-        });
+        }
         return new ZodObject({
             ...this._def,
             shape: () => newShape,
@@ -4777,137 +4872,6 @@ ZodUnion.create = (types, params) => {
         ...processCreateParams(params),
     });
 };
-/////////////////////////////////////////////////////
-/////////////////////////////////////////////////////
-//////////                                 //////////
-//////////      ZodDiscriminatedUnion      //////////
-//////////                                 //////////
-/////////////////////////////////////////////////////
-/////////////////////////////////////////////////////
-const getDiscriminator = (type) => {
-    if (type instanceof ZodLazy) {
-        return getDiscriminator(type.schema);
-    }
-    else if (type instanceof ZodEffects) {
-        return getDiscriminator(type.innerType());
-    }
-    else if (type instanceof ZodLiteral) {
-        return [type.value];
-    }
-    else if (type instanceof ZodEnum) {
-        return type.options;
-    }
-    else if (type instanceof ZodNativeEnum) {
-        // eslint-disable-next-line ban/ban
-        return util.objectValues(type.enum);
-    }
-    else if (type instanceof ZodDefault) {
-        return getDiscriminator(type._def.innerType);
-    }
-    else if (type instanceof ZodUndefined) {
-        return [undefined];
-    }
-    else if (type instanceof ZodNull) {
-        return [null];
-    }
-    else if (type instanceof ZodOptional) {
-        return [undefined, ...getDiscriminator(type.unwrap())];
-    }
-    else if (type instanceof ZodNullable) {
-        return [null, ...getDiscriminator(type.unwrap())];
-    }
-    else if (type instanceof ZodBranded) {
-        return getDiscriminator(type.unwrap());
-    }
-    else if (type instanceof ZodReadonly) {
-        return getDiscriminator(type.unwrap());
-    }
-    else if (type instanceof ZodCatch) {
-        return getDiscriminator(type._def.innerType);
-    }
-    else {
-        return [];
-    }
-};
-class ZodDiscriminatedUnion extends ZodType {
-    _parse(input) {
-        const { ctx } = this._processInputParams(input);
-        if (ctx.parsedType !== ZodParsedType.object) {
-            addIssueToContext(ctx, {
-                code: ZodIssueCode.invalid_type,
-                expected: ZodParsedType.object,
-                received: ctx.parsedType,
-            });
-            return INVALID;
-        }
-        const discriminator = this.discriminator;
-        const discriminatorValue = ctx.data[discriminator];
-        const option = this.optionsMap.get(discriminatorValue);
-        if (!option) {
-            addIssueToContext(ctx, {
-                code: ZodIssueCode.invalid_union_discriminator,
-                options: Array.from(this.optionsMap.keys()),
-                path: [discriminator],
-            });
-            return INVALID;
-        }
-        if (ctx.common.async) {
-            return option._parseAsync({
-                data: ctx.data,
-                path: ctx.path,
-                parent: ctx,
-            });
-        }
-        else {
-            return option._parseSync({
-                data: ctx.data,
-                path: ctx.path,
-                parent: ctx,
-            });
-        }
-    }
-    get discriminator() {
-        return this._def.discriminator;
-    }
-    get options() {
-        return this._def.options;
-    }
-    get optionsMap() {
-        return this._def.optionsMap;
-    }
-    /**
-     * The constructor of the discriminated union schema. Its behaviour is very similar to that of the normal z.union() constructor.
-     * However, it only allows a union of objects, all of which need to share a discriminator property. This property must
-     * have a different value for each object in the union.
-     * @param discriminator the name of the discriminator property
-     * @param types an array of object schemas
-     * @param params
-     */
-    static create(discriminator, options, params) {
-        // Get all the valid discriminator values
-        const optionsMap = new Map();
-        // try {
-        for (const type of options) {
-            const discriminatorValues = getDiscriminator(type.shape[discriminator]);
-            if (!discriminatorValues.length) {
-                throw new Error(`A discriminator value for key \`${discriminator}\` could not be extracted from all schema options`);
-            }
-            for (const value of discriminatorValues) {
-                if (optionsMap.has(value)) {
-                    throw new Error(`Discriminator property ${String(discriminator)} has duplicate value ${String(value)}`);
-                }
-                optionsMap.set(value, type);
-            }
-        }
-        return new ZodDiscriminatedUnion({
-            typeName: ZodFirstPartyTypeKind.ZodDiscriminatedUnion,
-            discriminator,
-            options,
-            optionsMap,
-            ...processCreateParams(params),
-        });
-    }
-}
 function mergeValues(a, b) {
     const aType = getParsedType(a);
     const bType = getParsedType(b);
@@ -4916,9 +4880,7 @@ function mergeValues(a, b) {
     }
     else if (aType === ZodParsedType.object && bType === ZodParsedType.object) {
         const bKeys = util.objectKeys(b);
-        const sharedKeys = util
-            .objectKeys(a)
-            .filter((key) => bKeys.indexOf(key) !== -1);
+        const sharedKeys = util.objectKeys(a).filter((key) => bKeys.indexOf(key) !== -1);
         const newObj = { ...a, ...b };
         for (const key of sharedKeys) {
             const sharedValue = mergeValues(a[key], b[key]);
@@ -4945,9 +4907,7 @@ function mergeValues(a, b) {
         }
         return { valid: true, data: newArray };
     }
-    else if (aType === ZodParsedType.date &&
-        bType === ZodParsedType.date &&
-        +a === +b) {
+    else if (aType === ZodParsedType.date && bType === ZodParsedType.date && +a === +b) {
         return { valid: true, data: a };
     }
     else {
@@ -5008,6 +4968,7 @@ ZodIntersection.create = (left, right, params) => {
         ...processCreateParams(params),
     });
 };
+// type ZodTupleItems = [ZodTypeAny, ...ZodTypeAny[]];
 class ZodTuple extends ZodType {
     _parse(input) {
         const { status, ctx } = this._processInputParams(input);
@@ -5078,60 +5039,6 @@ ZodTuple.create = (schemas, params) => {
         ...processCreateParams(params),
     });
 };
-class ZodRecord extends ZodType {
-    get keySchema() {
-        return this._def.keyType;
-    }
-    get valueSchema() {
-        return this._def.valueType;
-    }
-    _parse(input) {
-        const { status, ctx } = this._processInputParams(input);
-        if (ctx.parsedType !== ZodParsedType.object) {
-            addIssueToContext(ctx, {
-                code: ZodIssueCode.invalid_type,
-                expected: ZodParsedType.object,
-                received: ctx.parsedType,
-            });
-            return INVALID;
-        }
-        const pairs = [];
-        const keyType = this._def.keyType;
-        const valueType = this._def.valueType;
-        for (const key in ctx.data) {
-            pairs.push({
-                key: keyType._parse(new ParseInputLazyPath(ctx, key, ctx.path, key)),
-                value: valueType._parse(new ParseInputLazyPath(ctx, ctx.data[key], ctx.path, key)),
-                alwaysSet: key in ctx.data,
-            });
-        }
-        if (ctx.common.async) {
-            return ParseStatus.mergeObjectAsync(status, pairs);
-        }
-        else {
-            return ParseStatus.mergeObjectSync(status, pairs);
-        }
-    }
-    get element() {
-        return this._def.valueType;
-    }
-    static create(first, second, third) {
-        if (second instanceof ZodType) {
-            return new ZodRecord({
-                keyType: first,
-                valueType: second,
-                typeName: ZodFirstPartyTypeKind.ZodRecord,
-                ...processCreateParams(third),
-            });
-        }
-        return new ZodRecord({
-            keyType: ZodString.create(),
-            valueType: first,
-            typeName: ZodFirstPartyTypeKind.ZodRecord,
-            ...processCreateParams(second),
-        });
-    }
-}
 class ZodMap extends ZodType {
     get keySchema() {
         return this._def.keyType;
@@ -5285,159 +5192,31 @@ ZodSet.create = (valueType, params) => {
         ...processCreateParams(params),
     });
 };
-class ZodFunction extends ZodType {
-    constructor() {
-        super(...arguments);
-        this.validate = this.implement;
+class ZodLazy extends ZodType {
+    get schema() {
+        return this._def.getter();
     }
     _parse(input) {
         const { ctx } = this._processInputParams(input);
-        if (ctx.parsedType !== ZodParsedType.function) {
+        const lazySchema = this._def.getter();
+        return lazySchema._parse({ data: ctx.data, path: ctx.path, parent: ctx });
+    }
+}
+ZodLazy.create = (getter, params) => {
+    return new ZodLazy({
+        getter: getter,
+        typeName: ZodFirstPartyTypeKind.ZodLazy,
+        ...processCreateParams(params),
+    });
+};
+class ZodLiteral extends ZodType {
+    _parse(input) {
+        if (input.data !== this._def.value) {
+            const ctx = this._getOrReturnCtx(input);
             addIssueToContext(ctx, {
-                code: ZodIssueCode.invalid_type,
-                expected: ZodParsedType.function,
-                received: ctx.parsedType,
-            });
-            return INVALID;
-        }
-        function makeArgsIssue(args, error) {
-            return makeIssue({
-                data: args,
-                path: ctx.path,
-                errorMaps: [
-                    ctx.common.contextualErrorMap,
-                    ctx.schemaErrorMap,
-                    getErrorMap(),
-                    errorMap,
-                ].filter((x) => !!x),
-                issueData: {
-                    code: ZodIssueCode.invalid_arguments,
-                    argumentsError: error,
-                },
-            });
-        }
-        function makeReturnsIssue(returns, error) {
-            return makeIssue({
-                data: returns,
-                path: ctx.path,
-                errorMaps: [
-                    ctx.common.contextualErrorMap,
-                    ctx.schemaErrorMap,
-                    getErrorMap(),
-                    errorMap,
-                ].filter((x) => !!x),
-                issueData: {
-                    code: ZodIssueCode.invalid_return_type,
-                    returnTypeError: error,
-                },
-            });
-        }
-        const params = { errorMap: ctx.common.contextualErrorMap };
-        const fn = ctx.data;
-        if (this._def.returns instanceof ZodPromise) {
-            // Would love a way to avoid disabling this rule, but we need
-            // an alias (using an arrow function was what caused 2651).
-            // eslint-disable-next-line @typescript-eslint/no-this-alias
-            const me = this;
-            return OK(async function (...args) {
-                const error = new ZodError([]);
-                const parsedArgs = await me._def.args
-                    .parseAsync(args, params)
-                    .catch((e) => {
-                    error.addIssue(makeArgsIssue(args, e));
-                    throw error;
-                });
-                const result = await Reflect.apply(fn, this, parsedArgs);
-                const parsedReturns = await me._def.returns._def.type
-                    .parseAsync(result, params)
-                    .catch((e) => {
-                    error.addIssue(makeReturnsIssue(result, e));
-                    throw error;
-                });
-                return parsedReturns;
-            });
-        }
-        else {
-            // Would love a way to avoid disabling this rule, but we need
-            // an alias (using an arrow function was what caused 2651).
-            // eslint-disable-next-line @typescript-eslint/no-this-alias
-            const me = this;
-            return OK(function (...args) {
-                const parsedArgs = me._def.args.safeParse(args, params);
-                if (!parsedArgs.success) {
-                    throw new ZodError([makeArgsIssue(args, parsedArgs.error)]);
-                }
-                const result = Reflect.apply(fn, this, parsedArgs.data);
-                const parsedReturns = me._def.returns.safeParse(result, params);
-                if (!parsedReturns.success) {
-                    throw new ZodError([makeReturnsIssue(result, parsedReturns.error)]);
-                }
-                return parsedReturns.data;
-            });
-        }
-    }
-    parameters() {
-        return this._def.args;
-    }
-    returnType() {
-        return this._def.returns;
-    }
-    args(...items) {
-        return new ZodFunction({
-            ...this._def,
-            args: ZodTuple.create(items).rest(ZodUnknown.create()),
-        });
-    }
-    returns(returnType) {
-        return new ZodFunction({
-            ...this._def,
-            returns: returnType,
-        });
-    }
-    implement(func) {
-        const validatedFunc = this.parse(func);
-        return validatedFunc;
-    }
-    strictImplement(func) {
-        const validatedFunc = this.parse(func);
-        return validatedFunc;
-    }
-    static create(args, returns, params) {
-        return new ZodFunction({
-            args: (args
-                ? args
-                : ZodTuple.create([]).rest(ZodUnknown.create())),
-            returns: returns || ZodUnknown.create(),
-            typeName: ZodFirstPartyTypeKind.ZodFunction,
-            ...processCreateParams(params),
-        });
-    }
-}
-class ZodLazy extends ZodType {
-    get schema() {
-        return this._def.getter();
-    }
-    _parse(input) {
-        const { ctx } = this._processInputParams(input);
-        const lazySchema = this._def.getter();
-        return lazySchema._parse({ data: ctx.data, path: ctx.path, parent: ctx });
-    }
-}
-ZodLazy.create = (getter, params) => {
-    return new ZodLazy({
-        getter: getter,
-        typeName: ZodFirstPartyTypeKind.ZodLazy,
-        ...processCreateParams(params),
-    });
-};
-class ZodLiteral extends ZodType {
-    _parse(input) {
-        if (input.data !== this._def.value) {
-            const ctx = this._getOrReturnCtx(input);
-            addIssueToContext(ctx, {
-                received: ctx.data,
-                code: ZodIssueCode.invalid_literal,
-                expected: this._def.value,
+                received: ctx.data,
+                code: ZodIssueCode.invalid_literal,
+                expected: this._def.value,
             });
             return INVALID;
         }
@@ -5462,10 +5241,6 @@ function createZodEnum(values, params) {
     });
 }
 class ZodEnum extends ZodType {
-    constructor() {
-        super(...arguments);
-        _ZodEnum_cache.set(this, void 0);
-    }
     _parse(input) {
         if (typeof input.data !== "string") {
             const ctx = this._getOrReturnCtx(input);
@@ -5477,10 +5252,10 @@ class ZodEnum extends ZodType {
             });
             return INVALID;
         }
-        if (!__classPrivateFieldGet(this, _ZodEnum_cache, "f")) {
-            __classPrivateFieldSet(this, _ZodEnum_cache, new Set(this._def.values), "f");
+        if (!this._cache) {
+            this._cache = new Set(this._def.values);
         }
-        if (!__classPrivateFieldGet(this, _ZodEnum_cache, "f").has(input.data)) {
+        if (!this._cache.has(input.data)) {
             const ctx = this._getOrReturnCtx(input);
             const expectedValues = this._def.values;
             addIssueToContext(ctx, {
@@ -5529,18 +5304,12 @@ class ZodEnum extends ZodType {
         });
     }
 }
-_ZodEnum_cache = new WeakMap();
 ZodEnum.create = createZodEnum;
 class ZodNativeEnum extends ZodType {
-    constructor() {
-        super(...arguments);
-        _ZodNativeEnum_cache.set(this, void 0);
-    }
     _parse(input) {
         const nativeEnumValues = util.getValidEnumValues(this._def.values);
         const ctx = this._getOrReturnCtx(input);
-        if (ctx.parsedType !== ZodParsedType.string &&
-            ctx.parsedType !== ZodParsedType.number) {
+        if (ctx.parsedType !== ZodParsedType.string && ctx.parsedType !== ZodParsedType.number) {
             const expectedValues = util.objectValues(nativeEnumValues);
             addIssueToContext(ctx, {
                 expected: util.joinValues(expectedValues),
@@ -5549,10 +5318,10 @@ class ZodNativeEnum extends ZodType {
             });
             return INVALID;
         }
-        if (!__classPrivateFieldGet(this, _ZodNativeEnum_cache, "f")) {
-            __classPrivateFieldSet(this, _ZodNativeEnum_cache, new Set(util.getValidEnumValues(this._def.values)), "f");
+        if (!this._cache) {
+            this._cache = new Set(util.getValidEnumValues(this._def.values));
         }
-        if (!__classPrivateFieldGet(this, _ZodNativeEnum_cache, "f").has(input.data)) {
+        if (!this._cache.has(input.data)) {
             const expectedValues = util.objectValues(nativeEnumValues);
             addIssueToContext(ctx, {
                 received: ctx.data,
@@ -5567,7 +5336,6 @@ class ZodNativeEnum extends ZodType {
         return this._def.values;
     }
 }
-_ZodNativeEnum_cache = new WeakMap();
 ZodNativeEnum.create = (values, params) => {
     return new ZodNativeEnum({
         values: values,
@@ -5581,8 +5349,7 @@ class ZodPromise extends ZodType {
     }
     _parse(input) {
         const { ctx } = this._processInputParams(input);
-        if (ctx.parsedType !== ZodParsedType.promise &&
-            ctx.common.async === false) {
+        if (ctx.parsedType !== ZodParsedType.promise && ctx.common.async === false) {
             addIssueToContext(ctx, {
                 code: ZodIssueCode.invalid_type,
                 expected: ZodParsedType.promise,
@@ -5590,9 +5357,7 @@ class ZodPromise extends ZodType {
             });
             return INVALID;
         }
-        const promisified = ctx.parsedType === ZodParsedType.promise
-            ? ctx.data
-            : Promise.resolve(ctx.data);
+        const promisified = ctx.parsedType === ZodParsedType.promise ? ctx.data : Promise.resolve(ctx.data);
         return OK(promisified.then((data) => {
             return this._def.type.parseAsync(data, {
                 path: ctx.path,
@@ -5698,9 +5463,7 @@ class ZodEffects extends ZodType {
                 return { status: status.value, value: inner.value };
             }
             else {
-                return this._def.schema
-                    ._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx })
-                    .then((inner) => {
+                return this._def.schema._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx }).then((inner) => {
                     if (inner.status === "aborted")
                         return INVALID;
                     if (inner.status === "dirty")
@@ -5719,7 +5482,7 @@ class ZodEffects extends ZodType {
                     parent: ctx,
                 });
                 if (!isValid(base))
-                    return base;
+                    return INVALID;
                 const result = effect.transform(base.value, checkCtx);
                 if (result instanceof Promise) {
                     throw new Error(`Asynchronous transform encountered during synchronous parse operation. Use .parseAsync instead.`);
@@ -5727,12 +5490,13 @@ class ZodEffects extends ZodType {
                 return { status: status.value, value: result };
             }
             else {
-                return this._def.schema
-                    ._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx })
-                    .then((base) => {
+                return this._def.schema._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx }).then((base) => {
                     if (!isValid(base))
-                        return base;
-                    return Promise.resolve(effect.transform(base.value, checkCtx)).then((result) => ({ status: status.value, value: result }));
+                        return INVALID;
+                    return Promise.resolve(effect.transform(base.value, checkCtx)).then((result) => ({
+                        status: status.value,
+                        value: result,
+                    }));
                 });
             }
         }
@@ -5814,9 +5578,7 @@ ZodDefault.create = (type, params) => {
     return new ZodDefault({
         innerType: type,
         typeName: ZodFirstPartyTypeKind.ZodDefault,
-        defaultValue: typeof params.default === "function"
-            ? params.default
-            : () => params.default,
+        defaultValue: typeof params.default === "function" ? params.default : () => params.default,
         ...processCreateParams(params),
     });
 };
@@ -5900,7 +5662,6 @@ ZodNaN.create = (params) => {
         ...processCreateParams(params),
     });
 };
-const BRAND = Symbol("zod_brand");
 class ZodBranded extends ZodType {
     _parse(input) {
         const { ctx } = this._processInputParams(input);
@@ -5982,9 +5743,7 @@ class ZodReadonly extends ZodType {
             }
             return data;
         };
-        return isAsync(result)
-            ? result.then((data) => freeze(data))
-            : freeze(result);
+        return isAsync(result) ? result.then((data) => freeze(data)) : freeze(result);
     }
     unwrap() {
         return this._def.innerType;
@@ -5997,60 +5756,9 @@ ZodReadonly.create = (type, params) => {
         ...processCreateParams(params),
     });
 };
-////////////////////////////////////////
-////////////////////////////////////////
-//////////                    //////////
-//////////      z.custom      //////////
-//////////                    //////////
-////////////////////////////////////////
-////////////////////////////////////////
-function cleanParams(params, data) {
-    const p = typeof params === "function"
-        ? params(data)
-        : typeof params === "string"
-            ? { message: params }
-            : params;
-    const p2 = typeof p === "string" ? { message: p } : p;
-    return p2;
-}
-function custom(check, _params = {}, 
-/**
- * @deprecated
- *
- * Pass `fatal` into the params object instead:
- *
- * ```ts
- * z.string().custom((val) => val.length > 5, { fatal: false })
- * ```
- *
- */
-fatal) {
-    if (check)
-        return ZodAny.create().superRefine((data, ctx) => {
-            var _a, _b;
-            const r = check(data);
-            if (r instanceof Promise) {
-                return r.then((r) => {
-                    var _a, _b;
-                    if (!r) {
-                        const params = cleanParams(_params, data);
-                        const _fatal = (_b = (_a = params.fatal) !== null && _a !== void 0 ? _a : fatal) !== null && _b !== void 0 ? _b : true;
-                        ctx.addIssue({ code: "custom", ...params, fatal: _fatal });
-                    }
-                });
-            }
-            if (!r) {
-                const params = cleanParams(_params, data);
-                const _fatal = (_b = (_a = params.fatal) !== null && _a !== void 0 ? _a : fatal) !== null && _b !== void 0 ? _b : true;
-                ctx.addIssue({ code: "custom", ...params, fatal: _fatal });
-            }
-            return;
-        });
-    return ZodAny.create();
-}
-const late = {
+({
     object: ZodObject.lazycreate,
-};
+});
 var ZodFirstPartyTypeKind;
 (function (ZodFirstPartyTypeKind) {
     ZodFirstPartyTypeKind["ZodString"] = "ZodString";
@@ -6090,174 +5798,23 @@ var ZodFirstPartyTypeKind;
     ZodFirstPartyTypeKind["ZodPipeline"] = "ZodPipeline";
     ZodFirstPartyTypeKind["ZodReadonly"] = "ZodReadonly";
 })(ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {}));
-const instanceOfType = (
-// const instanceOfType = <T extends new (...args: any[]) => any>(
-cls, params = {
-    message: `Input not instance of ${cls.name}`,
-}) => custom((data) => data instanceof cls, params);
 const stringType = ZodString.create;
-const numberType = ZodNumber.create;
-const nanType = ZodNaN.create;
-const bigIntType = ZodBigInt.create;
-const booleanType = ZodBoolean.create;
-const dateType = ZodDate.create;
-const symbolType = ZodSymbol.create;
-const undefinedType = ZodUndefined.create;
-const nullType = ZodNull.create;
-const anyType = ZodAny.create;
-const unknownType = ZodUnknown.create;
-const neverType = ZodNever.create;
-const voidType = ZodVoid.create;
+ZodNever.create;
 const arrayType = ZodArray.create;
 const objectType = ZodObject.create;
-const strictObjectType = ZodObject.strictCreate;
+ZodObject.strictCreate;
 const unionType = ZodUnion.create;
-const discriminatedUnionType = ZodDiscriminatedUnion.create;
-const intersectionType = ZodIntersection.create;
-const tupleType = ZodTuple.create;
-const recordType = ZodRecord.create;
-const mapType = ZodMap.create;
-const setType = ZodSet.create;
-const functionType = ZodFunction.create;
-const lazyType = ZodLazy.create;
+ZodIntersection.create;
+ZodTuple.create;
 const literalType = ZodLiteral.create;
-const enumType = ZodEnum.create;
-const nativeEnumType = ZodNativeEnum.create;
-const promiseType = ZodPromise.create;
-const effectsType = ZodEffects.create;
-const optionalType = ZodOptional.create;
-const nullableType = ZodNullable.create;
-const preprocessType = ZodEffects.createWithPreprocess;
-const pipelineType = ZodPipeline.create;
-const ostring = () => stringType().optional();
-const onumber = () => numberType().optional();
-const oboolean = () => booleanType().optional();
-const coerce = {
-    string: ((arg) => ZodString.create({ ...arg, coerce: true })),
-    number: ((arg) => ZodNumber.create({ ...arg, coerce: true })),
-    boolean: ((arg) => ZodBoolean.create({
-        ...arg,
-        coerce: true,
-    })),
-    bigint: ((arg) => ZodBigInt.create({ ...arg, coerce: true })),
-    date: ((arg) => ZodDate.create({ ...arg, coerce: true })),
-};
-const NEVER = INVALID;
-
-var z = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    defaultErrorMap: errorMap,
-    setErrorMap: setErrorMap,
-    getErrorMap: getErrorMap,
-    makeIssue: makeIssue,
-    EMPTY_PATH: EMPTY_PATH,
-    addIssueToContext: addIssueToContext,
-    ParseStatus: ParseStatus,
-    INVALID: INVALID,
-    DIRTY: DIRTY,
-    OK: OK,
-    isAborted: isAborted,
-    isDirty: isDirty,
-    isValid: isValid,
-    isAsync: isAsync,
-    get util () { return util; },
-    get objectUtil () { return objectUtil; },
-    ZodParsedType: ZodParsedType,
-    getParsedType: getParsedType,
-    ZodType: ZodType,
-    datetimeRegex: datetimeRegex,
-    ZodString: ZodString,
-    ZodNumber: ZodNumber,
-    ZodBigInt: ZodBigInt,
-    ZodBoolean: ZodBoolean,
-    ZodDate: ZodDate,
-    ZodSymbol: ZodSymbol,
-    ZodUndefined: ZodUndefined,
-    ZodNull: ZodNull,
-    ZodAny: ZodAny,
-    ZodUnknown: ZodUnknown,
-    ZodNever: ZodNever,
-    ZodVoid: ZodVoid,
-    ZodArray: ZodArray,
-    ZodObject: ZodObject,
-    ZodUnion: ZodUnion,
-    ZodDiscriminatedUnion: ZodDiscriminatedUnion,
-    ZodIntersection: ZodIntersection,
-    ZodTuple: ZodTuple,
-    ZodRecord: ZodRecord,
-    ZodMap: ZodMap,
-    ZodSet: ZodSet,
-    ZodFunction: ZodFunction,
-    ZodLazy: ZodLazy,
-    ZodLiteral: ZodLiteral,
-    ZodEnum: ZodEnum,
-    ZodNativeEnum: ZodNativeEnum,
-    ZodPromise: ZodPromise,
-    ZodEffects: ZodEffects,
-    ZodTransformer: ZodEffects,
-    ZodOptional: ZodOptional,
-    ZodNullable: ZodNullable,
-    ZodDefault: ZodDefault,
-    ZodCatch: ZodCatch,
-    ZodNaN: ZodNaN,
-    BRAND: BRAND,
-    ZodBranded: ZodBranded,
-    ZodPipeline: ZodPipeline,
-    ZodReadonly: ZodReadonly,
-    custom: custom,
-    Schema: ZodType,
-    ZodSchema: ZodType,
-    late: late,
-    get ZodFirstPartyTypeKind () { return ZodFirstPartyTypeKind; },
-    coerce: coerce,
-    any: anyType,
-    array: arrayType,
-    bigint: bigIntType,
-    boolean: booleanType,
-    date: dateType,
-    discriminatedUnion: discriminatedUnionType,
-    effect: effectsType,
-    'enum': enumType,
-    'function': functionType,
-    'instanceof': instanceOfType,
-    intersection: intersectionType,
-    lazy: lazyType,
-    literal: literalType,
-    map: mapType,
-    nan: nanType,
-    nativeEnum: nativeEnumType,
-    never: neverType,
-    'null': nullType,
-    nullable: nullableType,
-    number: numberType,
-    object: objectType,
-    oboolean: oboolean,
-    onumber: onumber,
-    optional: optionalType,
-    ostring: ostring,
-    pipeline: pipelineType,
-    preprocess: preprocessType,
-    promise: promiseType,
-    record: recordType,
-    set: setType,
-    strictObject: strictObjectType,
-    string: stringType,
-    symbol: symbolType,
-    transformer: effectsType,
-    tuple: tupleType,
-    'undefined': undefinedType,
-    union: unionType,
-    unknown: unknownType,
-    'void': voidType,
-    NEVER: NEVER,
-    ZodIssueCode: ZodIssueCode,
-    quotelessJson: quotelessJson,
-    ZodError: ZodError
-});
-
-const ChangelogResponseSchema = z.object({
-    title: z.string(),
-    content: z.string(),
+ZodEnum.create;
+ZodPromise.create;
+ZodOptional.create;
+ZodNullable.create;
+
+const ChangelogResponseSchema = objectType({
+    title: stringType(),
+    content: stringType(),
 });
 const command$4 = 'changelog';
 /**
@@ -6291,70 +5848,234 @@ const builder$4 = (yargs) => {
 };
 
 /**
- * Get LLM Model Based on Configuration
+ * Default retry predicate - retries on non-validation errors
+ */
+function defaultShouldRetry(error) {
+    // Don't retry validation errors or configuration errors
+    if (error.name.includes('Validation') || error.name.includes('Configuration')) {
+        return false;
+    }
+    // Don't retry authentication errors
+    if (error.name.includes('Authentication')) {
+        return false;
+    }
+    // Retry execution errors and timeouts
+    return true;
+}
+/**
+ * Executes an operation with retry logic
+ */
+async function withRetry(operation, options = {}) {
+    const { maxAttempts = 3, backoffMs = 1000, backoffMultiplier = 2, maxBackoffMs = 10000, onRetry, shouldRetry = defaultShouldRetry } = options;
+    let lastError = new Error('No attempts made');
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        try {
+            return await operation();
+        }
+        catch (error) {
+            lastError = error instanceof Error ? error : new Error(String(error));
+            // If this is the last attempt or we shouldn't retry, throw the error
+            if (attempt === maxAttempts || !shouldRetry(lastError)) {
+                throw lastError;
+            }
+            // Calculate delay with exponential backoff
+            const delay = Math.min(backoffMs * Math.pow(backoffMultiplier, attempt - 1), maxBackoffMs);
+            // Call retry callback if provided
+            if (onRetry) {
+                onRetry(attempt, lastError, delay);
+            }
+            // Wait before retrying
+            await new Promise(resolve => setTimeout(resolve, delay));
+        }
+    }
+    // This should never be reached, but TypeScript requires it
+    throw new Error(`Operation failed after ${maxAttempts} attempts. Last error: ${lastError.message}`);
+}
+
+/**
+ * Wraps errors with additional context and converts them to LangChain errors
+ */
+function handleLangChainError(error, context, additionalContext) {
+    // If it's already a LangChain error, re-throw with additional context
+    if (error instanceof LangChainError) {
+        throw new LangChainExecutionError(`${context}: ${error.message}`, {
+            ...error.context,
+            ...additionalContext,
+            originalError: error.name,
+            context
+        });
+    }
+    // If it's a regular Error, wrap it
+    if (error instanceof Error) {
+        throw new LangChainExecutionError(`${context}: ${error.message}`, {
+            originalError: error.name,
+            originalMessage: error.message,
+            stack: error.stack,
+            context,
+            ...additionalContext
+        });
+    }
+    // For unknown error types
+    throw new LangChainExecutionError(`${context}: Unknown error occurred`, {
+        originalError: typeof error,
+        originalValue: String(error),
+        context,
+        ...additionalContext
+    });
+}
+
+/**
+ * Creates and configures an LLM instance based on the provider and configuration.
  *
- * @param fields
- * @param configuration
- * @returns LLM Model
+ * @param provider - The LLM provider (openai, anthropic, ollama)
+ * @param model - The specific model to use
+ * @param config - The configuration object containing service settings
+ * @returns Configured LLM instance
+ * @throws LangChainConfigurationError if the provider/model combination is invalid
+ * @throws LangChainExecutionError if LLM instantiation fails
  */
 function getLlm(provider, model, config) {
-    if (!model) {
-        throw new Error(`Invalid LLM Service: ${provider}/${model}`);
+    // Validate input parameters
+    validateProvider(provider, 'getLlm');
+    validateModel(model, provider, 'getLlm');
+    validateRequired(config, 'config', 'getLlm');
+    // Get the API key once and validate it
+    let apiKey;
+    try {
+        apiKey = getApiKeyForModel(config);
     }
-    switch (provider) {
-        case 'anthropic':
-            return new ChatAnthropic({
-                anthropicApiKey: getApiKeyForModel(config),
-                maxConcurrency: config.service.maxConcurrent,
-                model,
-            });
-        case 'ollama':
-            return new ChatOllama({
-                baseUrl: DEFAULT_OLLAMA_LLM_SERVICE.endpoint,
+    catch (error) {
+        handleLangChainError(error, 'getLlm: Failed to retrieve API key', { provider, model });
+    }
+    try {
+        switch (provider) {
+            case 'anthropic':
+                return new ChatAnthropic({
+                    anthropicApiKey: apiKey,
+                    maxConcurrency: config.service.maxConcurrent,
+                    model,
+                });
+            case 'ollama':
+                // Use endpoint from service config if available, otherwise fall back to default
+                const endpoint = 'endpoint' in config.service
+                    ? config.service.endpoint
+                    : DEFAULT_OLLAMA_LLM_SERVICE.endpoint;
+                return new ChatOllama({
+                    baseUrl: endpoint,
+                    maxConcurrency: config.service.maxConcurrent,
+                    model,
+                });
+            case 'openai':
+                return new ChatOpenAI({
+                    openAIApiKey: apiKey,
+                    model,
+                    temperature: config.service.temperature || 0.2,
+                });
+            default:
+                throw new LangChainConfigurationError(`getLlm: Unsupported provider '${provider}'`, { provider, model, supportedProviders: ['openai', 'anthropic', 'ollama'] });
+        }
+    }
+    catch (error) {
+        // If it's already a LangChain error, re-throw it
+        if (error instanceof LangChainConfigurationError || error instanceof LangChainExecutionError) {
+            throw error;
+        }
+        // Wrap other errors
+        handleLangChainError(error, `getLlm: Failed to instantiate ${provider} LLM`, {
+            provider,
+            model,
+            hasApiKey: !!apiKey,
+            serviceConfig: {
                 maxConcurrency: config.service.maxConcurrent,
-                model,
-            });
-        case 'openai':
-        default:
-            const openAiModel = new ChatOpenAI({
-                openAIApiKey: getApiKeyForModel(config),
-                model,
-                temperature: config.service.temperature || 0.2,
-            });
-            return openAiModel;
+                temperature: config.service.temperature
+            }
+        });
     }
 }
 
+/**
+ * Creates a PromptTemplate from a template string or returns a fallback template.
+ *
+ * @param params - The prompt creation parameters
+ * @returns A configured PromptTemplate instance
+ * @throws LangChainValidationError if neither template nor fallback is provided or if parameters are invalid
+ * @throws LangChainExecutionError if PromptTemplate instantiation fails
+ */
 function getPrompt({ template, variables, fallback }) {
-    if (!template && !fallback)
-        throw new Error('Must provide either a template or a fallback');
-    return (template
-        ? new PromptTemplate({
-            template,
-            inputVariables: variables,
-            templateFormat: 'mustache',
-        })
-        : fallback);
+    // Validate that we have either a template or fallback
+    if (!template && !fallback) {
+        throw new LangChainValidationError('getPrompt: Must provide either a template string or a fallback PromptTemplate', { hasTemplate: !!template, hasFallback: !!fallback, variables });
+    }
+    // Validate variables array
+    validateRequired(variables, 'variables', 'getPrompt');
+    validateNonEmptyArray(variables, 'variables', 'getPrompt');
+    // If using template, validate it and create PromptTemplate
+    if (template) {
+        validateNonEmptyString(template, 'template', 'getPrompt');
+        try {
+            return new PromptTemplate({
+                template,
+                inputVariables: variables,
+                templateFormat: 'mustache',
+            });
+        }
+        catch (error) {
+            handleLangChainError(error, 'getPrompt: Failed to create PromptTemplate', {
+                template: template.substring(0, 100) + (template.length > 100 ? '...' : ''),
+                variables,
+                templateFormat: 'mustache'
+            });
+        }
+    }
+    // Validate fallback if using it
+    if (fallback) {
+        validateRequired(fallback, 'fallback', 'getPrompt');
+        if (!(fallback instanceof PromptTemplate)) {
+            throw new LangChainValidationError('getPrompt: Fallback must be a PromptTemplate instance', { fallbackType: typeof fallback, fallbackConstructor: fallback.constructor?.name });
+        }
+        return fallback;
+    }
+    // This should never be reached, but TypeScript requires it
+    throw new LangChainExecutionError('getPrompt: Unexpected execution path - neither template nor fallback available', { template, fallback, variables });
 }
 
+/**
+ * Executes a LangChain pipeline with the provided LLM, prompt, variables, and parser.
+ * @param params - The execution parameters
+ * @returns The parsed result from the LLM chain
+ * @throws LangChainExecutionError if the chain execution fails or returns empty results
+ */
 const executeChain = async ({ llm, prompt, variables, parser }) => {
-    if (!llm || !prompt || !variables) {
-        throw new Error('The input parameters "llm", "prompt", and "variables" are all required.');
+    // Validate all required parameters
+    validateRequired(llm, 'llm', 'executeChain');
+    validateRequired(prompt, 'prompt', 'executeChain');
+    validateRequired(variables, 'variables', 'executeChain');
+    validateRequired(parser, 'parser', 'executeChain');
+    // Validate that variables is an object
+    if (typeof variables !== 'object' || Array.isArray(variables)) {
+        throw new LangChainExecutionError('executeChain: Variables must be a non-array object', { variables, type: typeof variables, isArray: Array.isArray(variables) });
     }
-    const chain = prompt.pipe(llm).pipe(parser);
-    let res;
     try {
-        res = await chain.invoke(variables);
+        const chain = prompt.pipe(llm).pipe(parser);
+        const result = await chain.invoke(variables);
+        console.debug('LLMChain call result:', result);
+        if (result === null || result === undefined) {
+            throw new LangChainExecutionError('executeChain: Chain execution returned null or undefined result', { variables, promptInputVariables: prompt.inputVariables });
+        }
+        return result;
     }
     catch (error) {
-        if (error instanceof Error) {
-            throw new Error(`LLMChain call error: ${error.message}`);
+        // Re-throw LangChain errors as-is
+        if (error instanceof LangChainExecutionError) {
+            throw error;
         }
+        // Wrap other errors with context
+        handleLangChainError(error, 'executeChain: Chain execution failed', {
+            promptInputVariables: prompt.inputVariables,
+            variableKeys: Object.keys(variables),
+            parserType: parser.constructor.name
+        });
     }
-    if (!res) {
-        throw new Error('Empty response from LLMChain call');
-    }
-    return res;
 };
 
 function extractTicketIdFromBranchName(branchName) {
@@ -6393,19 +6114,20 @@ const getChangesSinceLastTag = async ({ git }) => {
 };
 
 /**
- * Retrieves the commit log range between two specified commits.
+ * Retrieves the commit log range between two specified commits (inclusive of both commits).
  *
- * @param from - The starting commit (can be a commit hash, HEAD reference, or branch name).
- * @param to - The ending commit (can be a commit hash, HEAD reference, or branch name).
+ * @param from - The starting commit (can be a commit hash, HEAD reference, or branch name). This commit will be included in the results.
+ * @param to - The ending commit (can be a commit hash, HEAD reference, or branch name). This commit will be included in the results.
  * @param options - Additional options for retrieving the commit log range.
- * @returns A promise that resolves to an array of commit log messages.
+ * @returns A promise that resolves to an array of commit log messages, including both the 'from' and 'to' commits.
  * @throws If there is an error retrieving the commit log range.
  */
 async function getCommitLogRange(from, to, { noMerges, git }) {
     try {
-        // Use the git range syntax directly (from..to) which works with both commit hashes and references
+        // Use from^..to to include the 'from' commit in the range
+        // This works because from^..to means "commits reachable from 'to' but not from the parent of 'from'"
         const logOptions = {
-            from,
+            from: `${from}^`,
             to,
             '--no-merges': noMerges
         };
@@ -6413,7 +6135,29 @@ async function getCommitLogRange(from, to, { noMerges, git }) {
         return commitLog.all.map(({ message, date, body, author_name, hash, author_email }) => `[${date}] ${message}\n${body}\n(${hash}) - ${author_name}<${author_email}>`);
     }
     catch (error) {
-        // If there's an error, handle it appropriately
+        // If from^ fails (e.g., 'from' is the first commit), fall back to using from..to and manually adding the 'from' commit
+        if (error instanceof Error && error.message.includes('unknown revision')) {
+            try {
+                // Get the 'from' commit separately
+                const fromCommitLog = await git.log({ from: from, maxCount: 1 });
+                const fromCommit = fromCommitLog.latest;
+                // Get the range from..to (excluding 'from')
+                const rangeLogOptions = {
+                    from,
+                    to,
+                    '--no-merges': noMerges
+                };
+                const rangeCommitLog = await git.log(rangeLogOptions);
+                // Combine the 'from' commit with the range commits
+                const allCommits = fromCommit
+                    ? [fromCommit, ...rangeCommitLog.all]
+                    : rangeCommitLog.all;
+                return allCommits.map(({ message, date, body, author_name, hash, author_email }) => `[${date}] ${message}\n${body}\n(${hash}) - ${author_name}<${author_email}>`);
+            }
+            catch (fallbackError) {
+                throw fallbackError;
+            }
+        }
         throw error;
     }
 }
@@ -6474,38 +6218,38 @@ async function getCommitLogAgainstBranch({ git, logger, targetBranch, }) {
  */
 async function getCommitLogCurrentBranch({ git, logger, comparisonBranch = 'main', comparisonRemote = 'origin', }) {
     try {
-        // Get the current branch name
-        const branch = await getCurrentBranchName({ git });
-        // Check if the current branch has any commits
-        const hasCommits = (await git.raw(['rev-list', '--count', branch])) !== '0';
+        const branchName = await getCurrentBranchName({ git });
+        const hasCommits = (await git.raw(['rev-list', '--count', branchName])) !== '0';
         if (!hasCommits) {
             logger?.log('No commits on the current branch.');
             return [];
         }
-        // Get the list of commits that are unique to the current branch
         let uniqueCommits;
-        if (comparisonBranch === branch) {
+        if (comparisonBranch === branchName) {
             // If the comparison branch is the same as the current branch, we compare against the remote.
-            uniqueCommits = (await git.raw(['rev-list', `${comparisonRemote}/${comparisonBranch}..${branch}`]))
+            uniqueCommits = (await git.raw(['rev-list', `${comparisonRemote}/${comparisonBranch}..${branchName}`]))
                 .split('\n')
                 .filter(Boolean)
                 .reverse();
         }
         else {
             // Your existing code for different branches
-            uniqueCommits = (await git.raw(['rev-list', `${comparisonBranch}..${branch}`]))
+            uniqueCommits = (await git.raw(['rev-list', `${comparisonBranch}..${branchName}`]))
                 .split('\n')
                 .filter(Boolean)
                 .reverse();
         }
-        logger?.verbose(`Found ${uniqueCommits.length} unique commits on "${branch}"`, { color: 'blue' });
+        logger?.verbose(`Found ${uniqueCommits.length} unique commits on "${branchName}"`, {
+            color: 'blue',
+        });
         const firstCommit = uniqueCommits[0];
         const lastCommit = uniqueCommits[uniqueCommits.length - 1];
         if (!firstCommit || !lastCommit) {
-            logger?.log('Unable to determine first and last commit on the current branch', { color: 'yellow' });
+            logger?.log('Unable to determine first and last commit on the current branch', {
+                color: 'yellow',
+            });
             return [];
         }
-        // Retrieve commit log with messages
         return await getCommitLogRange(firstCommit, lastCommit, { git, noMerges: true });
     }
     catch (error) {
@@ -6634,17 +6378,35 @@ const CONVENTIONAL_COMMIT_PROMPT = new PromptTemplate({
  *
  * @param text template string
  * @param inputVariables template variables
- * @returns boolean or error message
+ * @throws Error if validation fails
  */
 function validatePromptTemplate(text, inputVariables) {
-    if (!text) {
-        return 'Prompt template cannot be empty';
+    if (!text || text.trim() === '') {
+        throw new Error('Prompt template cannot be empty');
     }
-    if (!inputVariables.some((entry) => text.includes(entry))) {
-        return ('Prompt template must include at least one of the following input variables: ' +
-            inputVariables.map((value) => `{${value}}`).join(', '));
+    if (!inputVariables || inputVariables.length === 0) {
+        return; // No variables to validate
+    }
+    // Extract variables from template using regex to find {variable} patterns
+    // This regex matches {variable_name} with no whitespace inside braces
+    // Excludes JSON-like patterns with quotes, colons, or whitespace
+    const templateVariableRegex = /\{([^}\s:"']+)\}/g;
+    const foundVariables = new Set();
+    let match;
+    while ((match = templateVariableRegex.exec(text)) !== null) {
+        foundVariables.add(match[1]);
+    }
+    // Check if all required variables are present in template
+    const missingVariables = inputVariables.filter(variable => !foundVariables.has(variable));
+    if (missingVariables.length > 0) {
+        throw new Error(`Prompt template is missing required variables: ${missingVariables.map(v => `{${v}}`).join(', ')}. ` +
+            `Found variables: ${Array.from(foundVariables).map(v => `{${v}}`).join(', ') || 'none'}`);
+    }
+    // Warn about unused variables in template (optional check)
+    const unusedVariables = Array.from(foundVariables).filter(variable => !inputVariables.includes(variable));
+    if (unusedVariables.length > 0) {
+        console.warn(`Prompt template contains undefined variables: ${unusedVariables.map(v => `{${v}}`).join(', ')}`);
     }
-    return true;
 }
 
 async function editPrompt(options) {
@@ -6653,7 +6415,15 @@ async function editPrompt(options) {
         default: options.prompt?.length ? options.prompt : COMMIT_PROMPT.template,
         waitForUseInput: false,
         postfix: 'Press ENTER to continue',
-        validate: (text) => validatePromptTemplate(text, COMMIT_PROMPT.inputVariables),
+        validate: (text) => {
+            try {
+                validatePromptTemplate(text, COMMIT_PROMPT.inputVariables);
+                return true;
+            }
+            catch (error) {
+                return error instanceof Error ? error.message : 'Invalid prompt template';
+            }
+        },
     });
 }
 
@@ -6872,7 +6642,9 @@ const handler$4 = async (argv, logger) => {
     const llm = getLlm(provider, model, config);
     const INTERACTIVE = isInteractive(config);
     if (INTERACTIVE) {
-        logger.log(LOGO);
+        if (!config.hideCocoBanner) {
+            logger.log(LOGO);
+        }
     }
     async function factory() {
         const branchName = await getCurrentBranchName({ git });
@@ -6904,9 +6676,10 @@ const handler$4 = async (argv, logger) => {
         logger.verbose(`No range, branch, or tag option provided. Defaulting to current branch`, {
             color: 'yellow',
         });
+        const commits = await getCommitLogCurrentBranch({ git, logger });
         return {
             branch: branchName,
-            commits: await getCommitLogCurrentBranch({ git, logger }),
+            commits,
         };
     }
     async function parser({ branch, commits }) {
@@ -6983,16 +6756,16 @@ var changelog = {
 
 const conventionalTypeRegex = /^(feat|fix|docs|style|refactor|perf|test|build|ci|chore|revert)(\(.+\))?:/;
 // Regular commit message schema with basic validation
-const CommitMessageResponseSchema = z.object({
-    title: z.string(),
-    body: z.string(),
+const CommitMessageResponseSchema = objectType({
+    title: stringType(),
+    body: stringType(),
 });
 // Conventional commit message schema with strict formatting rules
-const ConventionalCommitMessageResponseSchema = z.object({
-    title: z.string()
+const ConventionalCommitMessageResponseSchema = objectType({
+    title: stringType()
         .max(50, "Title must be 50 characters or less")
         .refine((title) => conventionalTypeRegex.test(title), "Title must follow Conventional Commits format (e.g., 'feat: add new feature' or 'fix(scope): fix bug')"),
-    body: z.string()
+    body: stringType()
     // .max(280, "Body must be 280 characters or less"),
 });
 const command$3 = 'commit';
@@ -7049,152 +6822,33 @@ const builder$3 = (yargs) => {
     return yargs.options(options$3).usage(getCommandUsageHeader(command$3));
 };
 
-/**
- * Extract the path from a file path string.
- * @param {string} filePath - The full file path.
- * @returns {string} The path portion of the file path.
- */
-function getPathFromFilePath(filePath) {
-    return filePath.split('/').slice(0, -1).join('/');
-}
-
-async function summarize(documents, { chain, textSplitter, options }) {
-    const { returnIntermediateSteps = false } = options || {};
-    const docs = await textSplitter.splitDocuments(documents.map((doc) => new Document(doc)));
-    const res = await chain.invoke({
-        input_documents: docs,
-        returnIntermediateSteps,
-    });
-    if (res.error)
-        throw new Error(res.error);
-    return res.text && res.text.trim();
-}
+new Set("ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789");
 
 /**
- * Create groups from a given node info.
- * @param {DiffNode} node - The node info to start grouping.
- * @returns {DirectoryDiff[]} The groups created.
+ * Base interface that all chains must implement.
  */
-function createDirectoryDiffs(node) {
-    const groupByPath = {};
-    function traverse(node) {
-        node.diffs.forEach((diff) => {
-            const path = getPathFromFilePath(diff.file);
-            if (!groupByPath[path]) {
-                groupByPath[path] = { diffs: [], path, tokenCount: 0 };
-            }
-            groupByPath[path].diffs.push(diff);
-            groupByPath[path].tokenCount += diff.tokenCount;
-        });
-        node.children.forEach(traverse);
+class BaseChain extends BaseLangChain {
+    get lc_namespace() {
+        return ["langchain", "chains", this._chainType()];
     }
-    traverse(node);
-    return Object.values(groupByPath);
-}
-/**
- * Summarize a directory diff asynchronously.
- */
-async function summarizeDirectoryDiff(directory, { chain, textSplitter, tokenizer }) {
-    try {
-        const directorySummary = await summarize(directory.diffs.map((diff) => ({
-            pageContent: diff.diff,
-            metadata: {
-                file: diff.file,
-                summary: diff.summary,
-            },
-        })), {
-            chain,
-            textSplitter,
-            options: {
-                returnIntermediateSteps: true,
-            },
-        });
-        const newTokenTotal = tokenizer(directorySummary);
-        return {
-            diffs: directory.diffs,
-            path: directory.path,
-            summary: directorySummary,
-            tokenCount: newTokenTotal,
-        };
-    }
-    catch (error) {
-        console.error(error);
-        return directory;
-    }
-}
-const defaultOutputCallback = (group) => {
-    let output = `
--------\n* changes in "/${group.path}"\n\n`;
-    if (group.summary) {
-        output += `${group.diffs.map((diff) => ` • ${diff.summary}`).join('\n')}\n\nSummary:\n\n${group.summary}\n\n`;
-    }
-    else {
-        output += `${group.diffs.map((diff) => ` • ${diff.summary}\n\n${diff.diff}`).join('\n\n')}\n\n`;
-    }
-    return output;
-};
-async function summarizeDiffs(rootDiffNode, { tokenizer, logger, maxTokens = 2048, textSplitter, chain, handleOutput = defaultOutputCallback, }) {
-    const queue = new pQueue({ concurrency: 8 });
-    logger.startTimer().startSpinner(`Organizing Diffs...`, { color: 'blue' });
-    const directoryDiffs = createDirectoryDiffs(rootDiffNode);
-    // Sort by token count descending
-    directoryDiffs.sort((a, b) => b.tokenCount - a.tokenCount);
-    let totalTokenCount = directoryDiffs.reduce((sum, group) => sum + group.tokenCount, 0);
-    logger.stopSpinner('Diffs Organized').stopTimer();
-    logger.startSpinner(`Consolidating Diffs`, { color: 'blue' });
-    const processingTasks = directoryDiffs.map((group, i) => {
-        return queue.add(async () => {
-            // If the diff token count is already less than the average req, we can skip summarizing.
-            const isLessThanAvgTokenReq = group.tokenCount <= maxTokens / directoryDiffs.length;
-            if (totalTokenCount <= maxTokens || isLessThanAvgTokenReq) {
-                return group;
-            }
-            group = await summarizeDirectoryDiff(group, {
-                chain,
-                textSplitter,
-                tokenizer,
-            });
-            // We need to subtract the old token count and add the new one
-            totalTokenCount = totalTokenCount - directoryDiffs[i].tokenCount + group.tokenCount;
-            directoryDiffs[i] = group;
-            logger
-                .verbose(`\n • Summarized diffs in "/${group.path}" `, { color: 'blue' })
-                .verbose(`\nTotal token count: ${totalTokenCount}`, {
-                color: totalTokenCount > maxTokens ? 'yellow' : 'green',
-            });
-            return group;
-        }, { priority: group.tokenCount });
-    });
-    await Promise.all(processingTasks);
-    logger.stopSpinner(`Summarized Diffs`);
-    return directoryDiffs.map(handleOutput).join('');
-}
-
-/**
- * Base interface that all chains must implement.
- */
-class BaseChain extends BaseLangChain {
-    get lc_namespace() {
-        return ["langchain", "chains", this._chainType()];
-    }
-    constructor(fields, 
-    /** @deprecated */
-    verbose, 
-    /** @deprecated */
-    callbacks) {
-        if (arguments.length === 1 &&
-            typeof fields === "object" &&
-            !("saveContext" in fields)) {
-            // fields is not a BaseMemory
-            const { memory, callbackManager, ...rest } = fields;
-            super({ ...rest, callbacks: callbackManager ?? rest.callbacks });
-            this.memory = memory;
-        }
-        else {
-            // fields is a BaseMemory
-            super({ verbose, callbacks });
-            this.memory = fields;
-        }
+    constructor(fields, 
+    /** @deprecated */
+    verbose, 
+    /** @deprecated */
+    callbacks) {
+        if (arguments.length === 1 &&
+            typeof fields === "object" &&
+            !("saveContext" in fields)) {
+            // fields is not a BaseMemory
+            const { memory, callbackManager, ...rest } = fields;
+            super({ ...rest, callbacks: callbackManager ?? rest.callbacks });
+            this.memory = memory;
+        }
+        else {
+            // fields is a BaseMemory
+            super({ verbose, callbacks });
+            this.memory = fields;
+        }
     }
     /** @ignore */
     _selectMemoryInputs(values) {
@@ -7616,15 +7270,550 @@ class LLMChain extends BaseChain {
             prompt: this.prompt.serialize(),
         };
     }
-    _getNumTokens(text) {
-        return _getLanguageModel(this.llm).getNumTokens(text);
+    _getNumTokens(text) {
+        return _getLanguageModel(this.llm).getNumTokens(text);
+    }
+}
+
+var llm_chain = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  LLMChain: LLMChain
+});
+
+const NAIVE_FIX_TEMPLATE = `Instructions:
+--------------
+{instructions}
+--------------
+Completion:
+--------------
+{completion}
+--------------
+
+Above, the Completion did not satisfy the constraints given in the Instructions.
+Error:
+--------------
+{error}
+--------------
+
+Please try again. Please only respond with an answer that satisfies the constraints laid out in the Instructions:`;
+const NAIVE_FIX_PROMPT = 
+/* #__PURE__ */ PromptTemplate.fromTemplate(NAIVE_FIX_TEMPLATE);
+
+function isLLMChain(x) {
+    return (x.prompt !== undefined && x.llm !== undefined);
+}
+/**
+ * Class that extends the BaseOutputParser to handle situations where the
+ * initial parsing attempt fails. It contains a retryChain for retrying
+ * the parsing process in case of a failure.
+ */
+class OutputFixingParser extends BaseOutputParser {
+    static lc_name() {
+        return "OutputFixingParser";
+    }
+    /**
+     * Static method to create a new instance of OutputFixingParser using a
+     * given language model, parser, and optional fields.
+     * @param llm The language model to be used.
+     * @param parser The parser to be used.
+     * @param fields Optional fields which may contain a prompt.
+     * @returns A new instance of OutputFixingParser.
+     */
+    static fromLLM(llm, parser, fields) {
+        const prompt = fields?.prompt ?? NAIVE_FIX_PROMPT;
+        const chain = new LLMChain({ llm, prompt });
+        return new OutputFixingParser({ parser, retryChain: chain });
+    }
+    constructor({ parser, retryChain, }) {
+        super(...arguments);
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain", "output_parsers", "fix"]
+        });
+        Object.defineProperty(this, "lc_serializable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.defineProperty(this, "parser", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "retryChain", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.parser = parser;
+        this.retryChain = retryChain;
+    }
+    /**
+     * Method to parse the completion using the parser. If the initial parsing
+     * fails, it uses the retryChain to attempt to fix the output and retry
+     * the parsing process.
+     * @param completion The completion to be parsed.
+     * @param callbacks Optional callbacks to be used during parsing.
+     * @returns The parsed output.
+     */
+    async parse(completion, callbacks) {
+        try {
+            return await this.parser.parse(completion, callbacks);
+        }
+        catch (e) {
+            // eslint-disable-next-line no-instanceof/no-instanceof
+            if (e instanceof OutputParserException) {
+                const retryInput = {
+                    instructions: this.parser.getFormatInstructions(),
+                    completion,
+                    error: e,
+                };
+                if (isLLMChain(this.retryChain)) {
+                    const result = await this.retryChain.call(retryInput, callbacks);
+                    const newCompletion = result[this.retryChain.outputKey];
+                    return this.parser.parse(newCompletion, callbacks);
+                }
+                else {
+                    const result = await this.retryChain.invoke(retryInput, {
+                        callbacks,
+                    });
+                    return result;
+                }
+            }
+            throw e;
+        }
+    }
+    /**
+     * Method to get the format instructions for the parser.
+     * @returns The format instructions for the parser.
+     */
+    getFormatInstructions() {
+        return this.parser.getFormatInstructions();
+    }
+}
+
+/**
+ * Creates a parser with built-in retry logic for schema-based generation
+ * @param schema - Zod schema for the expected output structure
+ * @param llm - LLM instance for retry attempts
+ * @param options - Configuration options for retry behavior
+ * @returns OutputFixingParser configured with retry logic
+ * @throws LangChainExecutionError if parser creation fails
+ */
+function createSchemaParser(schema, llm, options = {}) {
+    // Validate required parameters
+    validateRequired(schema, 'schema', 'createSchemaParser');
+    validateRequired(llm, 'llm', 'createSchemaParser');
+    validateRequired(options, 'options', 'createSchemaParser');
+    // Validate schema is actually a Zod schema
+    if (typeof schema.parse !== 'function') {
+        throw new LangChainExecutionError('createSchemaParser: Schema must be a valid Zod schema with a parse method', { schemaType: typeof schema, hasParseMethod: typeof schema.parse });
+    }
+    // Validate options structure
+    if (typeof options !== 'object' || Array.isArray(options)) {
+        throw new LangChainExecutionError('createSchemaParser: Options must be a non-array object', { options, type: typeof options, isArray: Array.isArray(options) });
+    }
+    const { retryTemplate } = options;
+    // Validate retryTemplate if provided
+    if (retryTemplate !== undefined && typeof retryTemplate !== 'string') {
+        throw new LangChainExecutionError('createSchemaParser: retryTemplate must be a string when provided', { retryTemplate, type: typeof retryTemplate });
+    }
+    try {
+        const baseParser = new StructuredOutputParser(schema);
+        const defaultRetryTemplate = `The following text failed to parse as valid JSON. Please convert it into a valid JSON object that matches the required schema.
+
+## Text to fix:
+{completion}
+
+## Instructions: 
+{instructions}
+
+You must return ONLY valid JSON that matches the schema exactly. Do not include any additional text, explanations, or markdown formatting:`;
+        const retryPromptTemplate = new PromptTemplate({
+            template: retryTemplate || defaultRetryTemplate,
+            inputVariables: ['completion', 'instructions'],
+        });
+        const retryChain = retryPromptTemplate.pipe(llm).pipe(baseParser);
+        return new OutputFixingParser({
+            parser: baseParser,
+            retryChain: retryChain,
+        });
+    }
+    catch (error) {
+        handleLangChainError(error, 'createSchemaParser: Failed to create schema parser', {
+            schemaName: schema.constructor.name,
+            llmType: llm.constructor.name,
+            hasRetryTemplate: !!retryTemplate
+        });
+    }
+}
+
+/**
+ * High-level function that combines chain execution with schema-based parsing
+ * Includes automatic retry logic and graceful degradation
+ * @param schema - Zod schema for the expected output structure
+ * @param llm - LLM instance
+ * @param prompt - Prompt template
+ * @param variables - Variables for the prompt
+ * @param options - Configuration options
+ * @returns Parsed result matching the schema type
+ */
+async function executeChainWithSchema(schema, llm, prompt, variables, options = {}) {
+    const { retryOptions = { maxAttempts: 3 }, fallbackParser, onFallback, ...parserOptions } = options;
+    const parser = createSchemaParser(schema, llm, parserOptions);
+    // Define the operation to retry
+    const operation = async () => {
+        const result = await executeChain({
+            llm,
+            prompt,
+            variables,
+            parser,
+        });
+        return result;
+    };
+    try {
+        // Use the general retry utility
+        return await withRetry(operation, retryOptions);
+    }
+    catch (error) {
+        // If all retries failed and we have a fallback parser, use it
+        if (fallbackParser) {
+            if (onFallback) {
+                onFallback();
+            }
+            // Generate without structured parsing as fallback
+            const fallbackResult = await executeChain({
+                llm,
+                prompt,
+                variables,
+                parser: new StringOutputParser(),
+            });
+            const fallbackText = typeof fallbackResult === 'string' ? fallbackResult : String(fallbackResult);
+            return fallbackParser(fallbackText);
+        }
+        // No fallback available, re-throw the error
+        throw error;
+    }
+}
+
+/**
+ * Extract the path from a file path string.
+ * @param {string} filePath - The full file path.
+ * @returns {string} The path portion of the file path.
+ */
+function getPathFromFilePath(filePath) {
+    return filePath.split('/').slice(0, -1).join('/');
+}
+
+async function summarize(documents, { chain, textSplitter, options }) {
+    const { returnIntermediateSteps = false } = options || {};
+    const docs = await textSplitter.splitDocuments(documents.map((doc) => new Document(doc)));
+    const res = await chain.invoke({
+        input_documents: docs,
+        returnIntermediateSteps,
+    });
+    if (res.error)
+        throw new Error(res.error);
+    return res.text && res.text.trim();
+}
+
+/**
+ * Create groups from a given node info.
+ * @param {DiffNode} node - The node info to start grouping.
+ * @returns {DirectoryDiff[]} The groups created.
+ */
+function createDirectoryDiffs(node) {
+    const groupByPath = {};
+    function traverse(node) {
+        node.diffs.forEach((diff) => {
+            const path = getPathFromFilePath(diff.file);
+            if (!groupByPath[path]) {
+                groupByPath[path] = { diffs: [], path, tokenCount: 0 };
+            }
+            groupByPath[path].diffs.push(diff);
+            groupByPath[path].tokenCount += diff.tokenCount;
+        });
+        node.children.forEach(traverse);
+    }
+    traverse(node);
+    return Object.values(groupByPath);
+}
+/**
+ * Summarize a directory diff asynchronously.
+ */
+async function summarizeDirectoryDiff(directory, { chain, textSplitter, tokenizer }) {
+    try {
+        const directorySummary = await summarize(directory.diffs.map((diff) => ({
+            pageContent: diff.diff,
+            metadata: {
+                file: diff.file,
+                summary: diff.summary,
+            },
+        })), {
+            chain,
+            textSplitter,
+            options: {
+                returnIntermediateSteps: true,
+            },
+        });
+        const newTokenTotal = tokenizer(directorySummary);
+        return {
+            diffs: directory.diffs,
+            path: directory.path,
+            summary: directorySummary,
+            tokenCount: newTokenTotal,
+        };
+    }
+    catch (error) {
+        console.error(error);
+        return directory;
+    }
+}
+const defaultOutputCallback = (group) => {
+    let output = `
+-------\n* changes in "/${group.path}"\n\n`;
+    if (group.summary) {
+        output += `${group.diffs.map((diff) => ` • ${diff.summary}`).join('\n')}\n\nSummary:\n\n${group.summary}\n\n`;
+    }
+    else {
+        output += `${group.diffs.map((diff) => ` • ${diff.summary}\n\n${diff.diff}`).join('\n\n')}\n\n`;
+    }
+    return output;
+};
+async function summarizeDiffs(rootDiffNode, { tokenizer, logger, maxTokens = 2048, textSplitter, chain, handleOutput = defaultOutputCallback, }) {
+    const queue = new pQueue({ concurrency: 8 });
+    logger.startTimer().startSpinner(`Organizing Diffs...`, { color: 'blue' });
+    const directoryDiffs = createDirectoryDiffs(rootDiffNode);
+    // Sort by token count descending
+    directoryDiffs.sort((a, b) => b.tokenCount - a.tokenCount);
+    let totalTokenCount = directoryDiffs.reduce((sum, group) => sum + group.tokenCount, 0);
+    logger.stopSpinner('Diffs Organized').stopTimer();
+    logger.startSpinner(`Consolidating Diffs`, { color: 'blue' });
+    const processingTasks = directoryDiffs.map((group, i) => {
+        return queue.add(async () => {
+            // If the diff token count is already less than the average req, we can skip summarizing.
+            const isLessThanAvgTokenReq = group.tokenCount <= maxTokens / directoryDiffs.length;
+            if (totalTokenCount <= maxTokens || isLessThanAvgTokenReq) {
+                return group;
+            }
+            group = await summarizeDirectoryDiff(group, {
+                chain,
+                textSplitter,
+                tokenizer,
+            });
+            // We need to subtract the old token count and add the new one
+            totalTokenCount = totalTokenCount - directoryDiffs[i].tokenCount + group.tokenCount;
+            directoryDiffs[i] = group;
+            logger
+                .verbose(`\n • Summarized diffs in "/${group.path}" `, { color: 'blue' })
+                .verbose(`\nTotal token count: ${totalTokenCount}`, {
+                color: totalTokenCount > maxTokens ? 'yellow' : 'green',
+            });
+            return group;
+        }, { priority: group.tokenCount });
+    });
+    await Promise.all(processingTasks);
+    logger.stopSpinner(`Summarized Diffs`);
+    return directoryDiffs.map(handleOutput).join('');
+}
+
+/**
+ * Asynchronously collect diffs for a given node and its children.
+ */
+async function collectDiffs(node, getFileDiff, tokenizer, logger) {
+    // Collect diffs for the files of the current node
+    const diffPromises = node.files.map(async (nodeFile) => {
+        const diff = await getFileDiff(nodeFile);
+        const tokenCount = tokenizer(diff);
+        logger.verbose(`Collected diff for ${nodeFile.filePath} (${tokenCount} tokens)`, {
+            color: 'magenta',
+        });
+        return {
+            file: nodeFile.filePath,
+            summary: nodeFile.summary,
+            diff,
+            tokenCount,
+        };
+    });
+    // Collect diffs for the children of the current node
+    const childrenPromises = Array.from(node.children.values()).map(async (child) => collectDiffs(child, getFileDiff, tokenizer, logger));
+    const [diffs, children] = await Promise.all([
+        Promise.all(diffPromises),
+        Promise.all(childrenPromises),
+    ]);
+    return {
+        path: node.getPath(),
+        diffs,
+        children,
+    };
+}
+
+class DiffTreeNode {
+    constructor(path) {
+        this.path = [];
+        this.files = [];
+        this.children = new Map();
+        if (path)
+            this.path = path;
+    }
+    addFile(file) {
+        this.files.push(file);
+    }
+    addChild(part, node) {
+        this.children.set(part, node);
+    }
+    getChild(part) {
+        return this.children.get(part);
+    }
+    getPath() {
+        return this.path.join('/');
+    }
+    print(indentation = 0) {
+        const indent = ' '.repeat(indentation);
+        let output = `${indent}- Path: ${this.getPath()}\n`;
+        if (this.files.length > 0) {
+            output += `${indent}  Files:\n`;
+            for (const file of this.files) {
+                output += `${indent}    - ${file.summary}\n`;
+            }
+        }
+        if (this.children.size > 0) {
+            output += `${indent}  Children:\n`;
+            for (const [, child] of this.children) {
+                output += child.print(indentation + 4);
+            }
+        }
+        return output;
+    }
+}
+const createDiffTree = (changes) => {
+    const root = new DiffTreeNode();
+    for (const change of changes) {
+        let currentParent = root;
+        const parts = change.filePath.split('/');
+        parts.pop();
+        for (const part of parts) {
+            let childNode = currentParent.getChild(part);
+            if (!childNode) {
+                childNode = new DiffTreeNode([...currentParent.path, part]);
+                currentParent.addChild(part, childNode);
+            }
+            currentParent = childNode;
+        }
+        // Create a NodeFile object and add it to the parent
+        currentParent.addFile({
+            filePath: change.filePath,
+            oldFilePath: change.oldFilePath,
+            summary: change.summary,
+            status: change.status,
+        });
+    }
+    return root;
+};
+
+/**
+ * Parses the default file diff for a given nodeFile.
+ *
+ * @param nodeFile - The file change object.
+ * @param commit - The commit to diff against. Defaults to '--staged'.
+ * @param git - The SimpleGit instance.
+ * @returns A Promise that resolves to the file diff as a string.
+ */
+async function parseDefaultFileDiff(nodeFile, commit = '--staged', git) {
+    if (commit === '--staged') {
+        return await git.diff(['--staged', nodeFile.filePath]);
+    }
+    else if (commit === '--unstaged') {
+        return await git.diff([nodeFile.filePath]);
+    }
+    else if (commit === '--untracked') {
+        // For untracked files, read the file content directly from the filesystem
+        try {
+            const fileContent = await promises.readFile(nodeFile.filePath, 'utf-8');
+            return fileContent;
+        }
+        catch (error) {
+            throw new Error(`Error reading untracked file: ${error?.message || 'Unknown error'}`);
+        }
+    }
+    return await git.diff([commit, nodeFile.filePath]);
+}
+/**
+ * Parses the diff for a renamed file.
+ *
+ * @param nodeFile - The file change object.
+ * @param commit - The commit hash or '--staged'.
+ * @param git - The SimpleGit instance.
+ * @param logger - The logger instance.
+ * @returns A Promise that resolves to the diff string.
+ */
+async function parseRenamedFileDiff(nodeFile, commit, git, logger) {
+    let result = '';
+    const oldFilePath = nodeFile?.oldFilePath || nodeFile.filePath;
+    let previousCommitHash = 'HEAD';
+    let newCommitHash = '';
+    if (commit !== '--staged') {
+        try {
+            previousCommitHash = await git.revparse([`${commit}~1`]);
+        }
+        catch (err) {
+            logger.verbose(`Error getting previous commit hash for ${nodeFile.filePath}`, {
+                color: 'red',
+            });
+        }
+        newCommitHash = commit;
+    }
+    try {
+        const [previousContent, newContent] = await Promise.all([
+            git.show([`${previousCommitHash}:${oldFilePath}`]),
+            git.show([`${newCommitHash}:${nodeFile.filePath}`]),
+        ]);
+        if (previousContent !== newContent) {
+            result = createTwoFilesPatch(oldFilePath, nodeFile.filePath, previousContent, newContent, '', '', {
+                context: 3,
+            });
+            // remove the first 4 lines of the patch (they contain the old and new file names)
+            result = result.split('\n').slice(4).join('\n');
+        }
+        else {
+            result = 'File contents are unchanged.';
+        }
+    }
+    catch (err) {
+        logger.verbose(`Error comparing file contents for ${nodeFile.filePath}`, { color: 'red' });
+        result = 'Error comparing file contents.';
     }
+    return result;
+}
+/**
+ * Retrieves the diff for a given file change in a specific commit.
+ * If the file is deleted, it returns a message indicating that the file has been deleted.
+ * If the file is renamed, it parses the renamed file diff and returns it.
+ * Otherwise, it retrieves the default diff from the index and returns it.
+ *
+ * @param nodeFile - The file change object.
+ * @param commit - The commit hash.
+ * @param git - The SimpleGit instance.
+ * @param logger - The logger instance.
+ * @returns A promise that resolves to the diff as a string.
+ */
+async function getDiff(nodeFile, commit, { git, logger, }) {
+    if (nodeFile.status === 'deleted') {
+        return 'This file has been deleted.';
+    }
+    if (nodeFile.status === 'renamed' && nodeFile.oldFilePath) {
+        const renamedDiff = await parseRenamedFileDiff(nodeFile, commit, git, logger);
+        return renamedDiff;
+    }
+    // If not deleted or renamed, get the diff from the index
+    const defaultDiff = await parseDefaultFileDiff(nodeFile, commit, git);
+    return defaultDiff;
 }
-
-var llm_chain = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  LLMChain: LLMChain
-});
 
 /* eslint-disable spaced-comment */
 const API_URL_RAW_PROMPT_TEMPLATE = `You are given the below API Documentation:
@@ -9374,8 +9563,6 @@ const loadSummarizationChain = (llm, params = { type: "map_reduce" }) => {
     throw new Error(`Invalid _type: ${params.type}`);
 };
 
-new Set("ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789");
-
 /*! js-yaml 4.1.0 https://github.com/nodeca/js-yaml @license MIT */
 function isNothing(subject) {
   return (typeof subject === 'undefined') || (subject === null);
@@ -10400,225 +10587,12 @@ for (var i = 0; i < 256; i++) {
   simpleEscapeMap[i] = simpleEscapeSequence(i);
 }
 
-/**
- * Get Summarization Chain
- * @param model
- * @param options
- * @returns
- */
-function getSummarizationChain(model, options = { type: 'map_reduce' }) {
-    return loadSummarizationChain(model, options);
-}
-
-/**
- * Get Recursive Character Text Splitter
- *
- * @param options
- * @returns
- */
-function getTextSplitter(options = {}) {
-    return new RecursiveCharacterTextSplitter(options);
-}
-
-/**
- * Asynchronously collect diffs for a given node and its children.
- */
-async function collectDiffs(node, getFileDiff, tokenizer, logger) {
-    // Collect diffs for the files of the current node
-    const diffPromises = node.files.map(async (nodeFile) => {
-        const diff = await getFileDiff(nodeFile);
-        const tokenCount = tokenizer(diff);
-        logger.verbose(`Collected diff for ${nodeFile.filePath} (${tokenCount} tokens)`, {
-            color: 'magenta',
-        });
-        return {
-            file: nodeFile.filePath,
-            summary: nodeFile.summary,
-            diff,
-            tokenCount,
-        };
-    });
-    // Collect diffs for the children of the current node
-    const childrenPromises = Array.from(node.children.values()).map(async (child) => collectDiffs(child, getFileDiff, tokenizer, logger));
-    const [diffs, children] = await Promise.all([
-        Promise.all(diffPromises),
-        Promise.all(childrenPromises),
-    ]);
-    return {
-        path: node.getPath(),
-        diffs,
-        children,
-    };
-}
-
-class DiffTreeNode {
-    constructor(path) {
-        this.path = [];
-        this.files = [];
-        this.children = new Map();
-        if (path)
-            this.path = path;
-    }
-    addFile(file) {
-        this.files.push(file);
-    }
-    addChild(part, node) {
-        this.children.set(part, node);
-    }
-    getChild(part) {
-        return this.children.get(part);
-    }
-    getPath() {
-        return this.path.join('/');
-    }
-    print(indentation = 0) {
-        const indent = ' '.repeat(indentation);
-        let output = `${indent}- Path: ${this.getPath()}\n`;
-        if (this.files.length > 0) {
-            output += `${indent}  Files:\n`;
-            for (const file of this.files) {
-                output += `${indent}    - ${file.summary}\n`;
-            }
-        }
-        if (this.children.size > 0) {
-            output += `${indent}  Children:\n`;
-            for (const [, child] of this.children) {
-                output += child.print(indentation + 4);
-            }
-        }
-        return output;
-    }
-}
-const createDiffTree = (changes) => {
-    const root = new DiffTreeNode();
-    for (const change of changes) {
-        let currentParent = root;
-        const parts = change.filePath.split('/');
-        parts.pop();
-        for (const part of parts) {
-            let childNode = currentParent.getChild(part);
-            if (!childNode) {
-                childNode = new DiffTreeNode([...currentParent.path, part]);
-                currentParent.addChild(part, childNode);
-            }
-            currentParent = childNode;
-        }
-        // Create a NodeFile object and add it to the parent
-        currentParent.addFile({
-            filePath: change.filePath,
-            oldFilePath: change.oldFilePath,
-            summary: change.summary,
-            status: change.status,
-        });
-    }
-    return root;
-};
-
-/**
- * Parses the default file diff for a given nodeFile.
- *
- * @param nodeFile - The file change object.
- * @param commit - The commit to diff against. Defaults to '--staged'.
- * @param git - The SimpleGit instance.
- * @returns A Promise that resolves to the file diff as a string.
- */
-async function parseDefaultFileDiff(nodeFile, commit = '--staged', git) {
-    if (commit === '--staged') {
-        return await git.diff(['--staged', nodeFile.filePath]);
-    }
-    else if (commit === '--unstaged') {
-        return await git.diff([nodeFile.filePath]);
-    }
-    else if (commit === '--untracked') {
-        // For untracked files, read the file content directly from the filesystem
-        try {
-            const fileContent = await promises.readFile(nodeFile.filePath, 'utf-8');
-            return fileContent;
-        }
-        catch (error) {
-            throw new Error(`Error reading untracked file: ${error?.message || 'Unknown error'}`);
-        }
-    }
-    return await git.diff([commit, nodeFile.filePath]);
-}
-/**
- * Parses the diff for a renamed file.
- *
- * @param nodeFile - The file change object.
- * @param commit - The commit hash or '--staged'.
- * @param git - The SimpleGit instance.
- * @param logger - The logger instance.
- * @returns A Promise that resolves to the diff string.
- */
-async function parseRenamedFileDiff(nodeFile, commit, git, logger) {
-    let result = '';
-    const oldFilePath = nodeFile?.oldFilePath || nodeFile.filePath;
-    let previousCommitHash = 'HEAD';
-    let newCommitHash = '';
-    if (commit !== '--staged') {
-        try {
-            previousCommitHash = await git.revparse([`${commit}~1`]);
-        }
-        catch (err) {
-            logger.verbose(`Error getting previous commit hash for ${nodeFile.filePath}`, {
-                color: 'red',
-            });
-        }
-        newCommitHash = commit;
-    }
-    try {
-        const [previousContent, newContent] = await Promise.all([
-            git.show([`${previousCommitHash}:${oldFilePath}`]),
-            git.show([`${newCommitHash}:${nodeFile.filePath}`]),
-        ]);
-        if (previousContent !== newContent) {
-            result = createTwoFilesPatch(oldFilePath, nodeFile.filePath, previousContent, newContent, '', '', {
-                context: 3,
-            });
-            // remove the first 4 lines of the patch (they contain the old and new file names)
-            result = result.split('\n').slice(4).join('\n');
-        }
-        else {
-            result = 'File contents are unchanged.';
-        }
-    }
-    catch (err) {
-        logger.verbose(`Error comparing file contents for ${nodeFile.filePath}`, { color: 'red' });
-        result = 'Error comparing file contents.';
-    }
-    return result;
-}
-/**
- * Retrieves the diff for a given file change in a specific commit.
- * If the file is deleted, it returns a message indicating that the file has been deleted.
- * If the file is renamed, it parses the renamed file diff and returns it.
- * Otherwise, it retrieves the default diff from the index and returns it.
- *
- * @param nodeFile - The file change object.
- * @param commit - The commit hash.
- * @param git - The SimpleGit instance.
- * @param logger - The logger instance.
- * @returns A promise that resolves to the diff as a string.
- */
-async function getDiff(nodeFile, commit, { git, logger, }) {
-    if (nodeFile.status === 'deleted') {
-        return 'This file has been deleted.';
-    }
-    if (nodeFile.status === 'renamed' && nodeFile.oldFilePath) {
-        const renamedDiff = await parseRenamedFileDiff(nodeFile, commit, git, logger);
-        return renamedDiff;
-    }
-    // If not deleted or renamed, get the diff from the index
-    const defaultDiff = await parseDefaultFileDiff(nodeFile, commit, git);
-    return defaultDiff;
-}
-
 // Max tokens for GPT-3 is 4096
 // const MAX_TOKENS_PER_SUMMARY = 4096
 const MAX_TOKENS_PER_SUMMARY = 12288;
 async function fileChangeParser({ changes, commit, options: { tokenizer, git, llm: model, logger }, }) {
-    const textSplitter = getTextSplitter({ chunkSize: 10000, chunkOverlap: 250 });
-    const summarizationChain = getSummarizationChain(model, {
+    const textSplitter = new RecursiveCharacterTextSplitter({ chunkSize: 10000, chunkOverlap: 250 });
+    const summarizationChain = loadSummarizationChain(model, {
         type: 'map_reduce',
         combineMapPrompt: SUMMARIZE_PROMPT,
         combinePrompt: SUMMARIZE_PROMPT,
@@ -10889,7 +10863,9 @@ const handler$3 = async (argv, logger) => {
     const llm = getLlm(provider, model, config);
     const INTERACTIVE = argv.interactive || isInteractive(config);
     if (INTERACTIVE) {
-        logger.log(LOGO);
+        if (!config.hideCocoBanner) {
+            logger.log(LOGO);
+        }
     }
     else {
         logger.setConfig({ silent: true });
@@ -10940,7 +10916,8 @@ const handler$3 = async (argv, logger) => {
             const schema = useConventional
                 ? ConventionalCommitMessageResponseSchema
                 : CommitMessageResponseSchema;
-            const parser = new StructuredOutputParser(schema);
+            const formatInstructions = `You must always return valid JSON fenced by a markdown code block. Do not return any additional text. The JSON object you return should match the following schema:
+{{ body: string, title: string }}`;
             // Use conventional commit prompt if enabled
             const promptTemplate = useConventional ? CONVENTIONAL_COMMIT_PROMPT : COMMIT_PROMPT;
             const prompt = getPrompt({
@@ -10948,7 +10925,11 @@ const handler$3 = async (argv, logger) => {
                 variables: promptTemplate.inputVariables,
                 fallback: promptTemplate,
             });
-            const formatInstructions = "Respond with a valid JSON object, containing two fields: 'title' and 'body', both strings.";
+            if (config.service.provider === 'ollama') {
+                logger.log('Note: Ollama models may not strictly adhere to the output format instructions.', {
+                    color: 'yellow',
+                });
+            }
             // Get additional context if provided
             let additional_context = '';
             if (argv.additional) {
@@ -10981,11 +10962,25 @@ const handler$3 = async (argv, logger) => {
                 commit_history: commit_history,
                 branch_name_context: branchNameContext,
             };
-            const commitMsg = await executeChain({
-                llm,
-                prompt,
-                variables,
-                parser,
+            const maxAttempts = config.service.provider === 'ollama' && 'maxParsingAttempts' in config.service
+                ? config.service.maxParsingAttempts || 3
+                : 3;
+            const commitMsg = await executeChainWithSchema(schema, llm, prompt, variables, {
+                retryOptions: {
+                    maxAttempts,
+                    onRetry: (attempt, error) => {
+                        logger.verbose(`Failed to parse commit message (attempt ${attempt}/${maxAttempts}): ${error.message}`, { color: 'yellow' });
+                    }
+                },
+                fallbackParser: (text) => ({
+                    title: text.split('\n')[0] || 'Auto-generated commit',
+                    body: text.split('\n').slice(1).join('\n') || 'Generated commit message',
+                }),
+                onFallback: () => {
+                    logger.verbose('Max retry attempts reached. Falling back to simple text output.', {
+                        color: 'red',
+                    });
+                },
             });
             // Construct the full commit message
             const appendedText = argv.append ? `\n\n${argv.append}` : '';
@@ -11203,12 +11198,15 @@ const OPEN_AI_MODELS = [
     'gpt-3.5-turbo',
 ];
 const ANTHROPIC_MODELS = [
+    'claude-sonnet-4-0',
+    'claude-3-7-sonnet-latest',
+    'claude-3-5-haiku-latest',
+    'claude-3-5-sonnet-latest',
+    'claude-3-5-sonnet-20241022',
     'claude-3-5-sonnet-20240620',
     'claude-3-opus-20240229',
     'claude-3-sonnet-20240229',
     'claude-3-haiku-20240307',
-    'claude-2.1',
-    'claude-2.0',
 ];
 
 const questions = {
@@ -11500,9 +11498,9 @@ var init = {
     options: options$2,
 };
 
-const RecapLlmResponseSchema = z.object({
-    title: z.string().optional(),
-    summary: z.string().optional(),
+const RecapLlmResponseSchema = objectType({
+    title: stringType().optional(),
+    summary: stringType().optional(),
 });
 const command$1 = 'recap';
 /**
@@ -11576,7 +11574,9 @@ const handler$1 = async (argv, logger) => {
     const llm = getLlm(provider, model, config);
     const INTERACTIVE = argv.interactive || isInteractive(config);
     if (INTERACTIVE) {
-        logger.log(LOGO);
+        if (!config.hideCocoBanner) {
+            logger.log(LOGO);
+        }
     }
     else {
         logger.setConfig({ silent: true });
@@ -11725,26 +11725,26 @@ var recap = {
     options: options$1,
 };
 
-const ReviewFeedbackItemSchema = z.object({
-    title: z.string(),
-    summary: z.string(),
-    severity: z.union([
-        z.literal(1),
-        z.literal(2),
-        z.literal(3),
-        z.literal(4),
-        z.literal(5),
-        z.literal(6),
-        z.literal(7),
-        z.literal(8),
-        z.literal(9),
-        z.literal(10),
+const ReviewFeedbackItemSchema = objectType({
+    title: stringType(),
+    summary: stringType(),
+    severity: unionType([
+        literalType(1),
+        literalType(2),
+        literalType(3),
+        literalType(4),
+        literalType(5),
+        literalType(6),
+        literalType(7),
+        literalType(8),
+        literalType(9),
+        literalType(10),
     ]),
-    category: z.string(),
-    filePath: z.string(),
+    category: stringType(),
+    filePath: stringType(),
 });
 // Array schema for review feedback items
-const ReviewFeedbackItemArraySchema = z.array(ReviewFeedbackItemSchema);
+const ReviewFeedbackItemArraySchema = arrayType(ReviewFeedbackItemSchema);
 const command = 'review';
 /**
  * Command line options via yargs
@@ -14014,7 +14014,9 @@ const handler = async (argv, logger) => {
     const llm = getLlm(provider, model, config);
     const INTERACTIVE = isInteractive(config);
     if (INTERACTIVE) {
-        logger.log(LOGO);
+        if (!config.hideCocoBanner) {
+            logger.log(LOGO);
+        }
     }
     async function factory() {
         if (argv.branch) {