@probelabs/probe 0.6.0-rc131 → 0.6.0-rc133

package/cjs/index.cjs

@@ -9774,7 +9774,7 @@ var require_dist_cjs15 = __commonJS({
       const registerTimeout = (offset) => {
         const timeoutId = timing.setTimeout(() => {
           request.destroy();
-          reject2(Object.assign(new Error(`Socket timed out without establishing a connection within ${timeoutInMs} ms`), {
+          reject2(Object.assign(new Error(`@smithy/node-http-handler - the request socket did not establish a connection with the server within the configured timeout of ${timeoutInMs} ms.`), {
             name: "TimeoutError"
           }));
         }, timeoutInMs - offset);
@@ -9799,6 +9799,25 @@ var require_dist_cjs15 = __commonJS({
       }
       return timing.setTimeout(registerTimeout.bind(null, DEFER_EVENT_LISTENER_TIME$2), DEFER_EVENT_LISTENER_TIME$2);
     };
+    var setRequestTimeout = (req, reject2, timeoutInMs = 0, throwOnRequestTimeout, logger2) => {
+      if (timeoutInMs) {
+        return timing.setTimeout(() => {
+          let msg = `@smithy/node-http-handler - [${throwOnRequestTimeout ? "ERROR" : "WARN"}] a request has exceeded the configured ${timeoutInMs} ms requestTimeout.`;
+          if (throwOnRequestTimeout) {
+            const error2 = Object.assign(new Error(msg), {
+              name: "TimeoutError",
+              code: "ETIMEDOUT"
+            });
+            req.destroy(error2);
+            reject2(error2);
+          } else {
+            msg += ` Init client requestHandler with throwOnRequestTimeout=true to turn this into an error.`;
+            logger2?.warn?.(msg);
+          }
+        }, timeoutInMs);
+      }
+      return -1;
+    };
     var DEFER_EVENT_LISTENER_TIME$1 = 3e3;
     var setSocketKeepAlive = (request, { keepAlive, keepAliveMsecs }, deferTimeMs = DEFER_EVENT_LISTENER_TIME$1) => {
       if (keepAlive !== true) {
@@ -9820,12 +9839,12 @@ var require_dist_cjs15 = __commonJS({
       return timing.setTimeout(registerListener, deferTimeMs);
     };
     var DEFER_EVENT_LISTENER_TIME = 3e3;
-    var setSocketTimeout = (request, reject2, timeoutInMs = DEFAULT_REQUEST_TIMEOUT) => {
+    var setSocketTimeout = (request, reject2, timeoutInMs = 0) => {
       const registerTimeout = (offset) => {
         const timeout = timeoutInMs - offset;
         const onTimeout = () => {
           request.destroy();
-          reject2(Object.assign(new Error(`Connection timed out after ${timeoutInMs} ms`), { name: "TimeoutError" }));
+          reject2(Object.assign(new Error(`@smithy/node-http-handler - the request socket timed out after ${timeoutInMs} ms of inactivity (configured by client requestHandler).`), { name: "TimeoutError" }));
         };
         if (request.socket) {
           request.socket.setTimeout(timeout, onTimeout);
@@ -9938,13 +9957,15 @@ or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler conf
         });
       }
       resolveDefaultConfig(options) {
-        const { requestTimeout, connectionTimeout, socketTimeout, socketAcquisitionWarningTimeout, httpAgent, httpsAgent } = options || {};
+        const { requestTimeout, connectionTimeout, socketTimeout, socketAcquisitionWarningTimeout, httpAgent, httpsAgent, throwOnRequestTimeout } = options || {};
         const keepAlive = true;
         const maxSockets = 50;
         return {
           connectionTimeout,
-          requestTimeout: requestTimeout ?? socketTimeout,
+          requestTimeout,
+          socketTimeout,
           socketAcquisitionWarningTimeout,
+          throwOnRequestTimeout,
           httpAgent: (() => {
             if (httpAgent instanceof http.Agent || typeof httpAgent?.destroy === "function") {
               return httpAgent;
@@ -10058,7 +10079,8 @@ or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler conf
           }
           const effectiveRequestTimeout = requestTimeout ?? this.config.requestTimeout;
           timeouts.push(setConnectionTimeout(req, reject2, this.config.connectionTimeout));
-          timeouts.push(setSocketTimeout(req, reject2, effectiveRequestTimeout));
+          timeouts.push(setRequestTimeout(req, reject2, effectiveRequestTimeout, this.config.throwOnRequestTimeout, this.config.logger ?? console));
+          timeouts.push(setSocketTimeout(req, reject2, this.config.socketTimeout));
           const httpAgent = nodeHttpsOptions.agent;
           if (typeof httpAgent === "object" && "keepAlive" in httpAgent) {
             timeouts.push(setSocketKeepAlive(req, {
@@ -10983,120 +11005,6 @@ var init_deref = __esm({
   }
 });
 
-// node_modules/@smithy/core/dist-es/submodules/schema/middleware/schemaDeserializationMiddleware.js
-var import_protocol_http2, import_util_middleware3, schemaDeserializationMiddleware, findHeader;
-var init_schemaDeserializationMiddleware = __esm({
-  "node_modules/@smithy/core/dist-es/submodules/schema/middleware/schemaDeserializationMiddleware.js"() {
-    import_protocol_http2 = __toESM(require_dist_cjs2());
-    import_util_middleware3 = __toESM(require_dist_cjs7());
-    schemaDeserializationMiddleware = (config) => (next, context) => async (args) => {
-      const { response } = await next(args);
-      const { operationSchema } = (0, import_util_middleware3.getSmithyContext)(context);
-      try {
-        const parsed = await config.protocol.deserializeResponse(operationSchema, {
-          ...config,
-          ...context
-        }, response);
-        return {
-          response,
-          output: parsed
-        };
-      } catch (error2) {
-        Object.defineProperty(error2, "$response", {
-          value: response
-        });
-        if (!("$metadata" in error2)) {
-          const hint = `Deserialization error: to see the raw response, inspect the hidden field {error}.$response on this object.`;
-          try {
-            error2.message += "\n  " + hint;
-          } catch (e3) {
-            if (!context.logger || context.logger?.constructor?.name === "NoOpLogger") {
-              console.warn(hint);
-            } else {
-              context.logger?.warn?.(hint);
-            }
-          }
-          if (typeof error2.$responseBodyText !== "undefined") {
-            if (error2.$response) {
-              error2.$response.body = error2.$responseBodyText;
-            }
-          }
-          try {
-            if (import_protocol_http2.HttpResponse.isInstance(response)) {
-              const { headers = {} } = response;
-              const headerEntries = Object.entries(headers);
-              error2.$metadata = {
-                httpStatusCode: response.statusCode,
-                requestId: findHeader(/^x-[\w-]+-request-?id$/, headerEntries),
-                extendedRequestId: findHeader(/^x-[\w-]+-id-2$/, headerEntries),
-                cfId: findHeader(/^x-[\w-]+-cf-id$/, headerEntries)
-              };
-            }
-          } catch (e3) {
-          }
-        }
-        throw error2;
-      }
-    };
-    findHeader = (pattern, headers) => {
-      return (headers.find(([k3]) => {
-        return k3.match(pattern);
-      }) || [void 0, void 0])[1];
-    };
-  }
-});
-
-// node_modules/@smithy/core/dist-es/submodules/schema/middleware/schemaSerializationMiddleware.js
-var import_util_middleware4, schemaSerializationMiddleware;
-var init_schemaSerializationMiddleware = __esm({
-  "node_modules/@smithy/core/dist-es/submodules/schema/middleware/schemaSerializationMiddleware.js"() {
-    import_util_middleware4 = __toESM(require_dist_cjs7());
-    schemaSerializationMiddleware = (config) => (next, context) => async (args) => {
-      const { operationSchema } = (0, import_util_middleware4.getSmithyContext)(context);
-      const endpoint = context.endpointV2?.url && config.urlParser ? async () => config.urlParser(context.endpointV2.url) : config.endpoint;
-      const request = await config.protocol.serializeRequest(operationSchema, args.input, {
-        ...config,
-        ...context,
-        endpoint
-      });
-      return next({
-        ...args,
-        request
-      });
-    };
-  }
-});
-
-// node_modules/@smithy/core/dist-es/submodules/schema/middleware/getSchemaSerdePlugin.js
-function getSchemaSerdePlugin(config) {
-  return {
-    applyToStack: (commandStack) => {
-      commandStack.add(schemaSerializationMiddleware(config), serializerMiddlewareOption2);
-      commandStack.add(schemaDeserializationMiddleware(config), deserializerMiddlewareOption);
-      config.protocol.setSerdeContext(config);
-    }
-  };
-}
-var deserializerMiddlewareOption, serializerMiddlewareOption2;
-var init_getSchemaSerdePlugin = __esm({
-  "node_modules/@smithy/core/dist-es/submodules/schema/middleware/getSchemaSerdePlugin.js"() {
-    init_schemaDeserializationMiddleware();
-    init_schemaSerializationMiddleware();
-    deserializerMiddlewareOption = {
-      name: "deserializerMiddleware",
-      step: "deserialize",
-      tags: ["DESERIALIZER"],
-      override: true
-    };
-    serializerMiddlewareOption2 = {
-      name: "serializerMiddleware",
-      step: "serialize",
-      tags: ["SERIALIZER"],
-      override: true
-    };
-  }
-});
-
 // node_modules/@smithy/core/dist-es/submodules/schema/TypeRegistry.js
 var TypeRegistry;
 var init_TypeRegistry = __esm({
@@ -11128,11 +11036,11 @@ var init_TypeRegistry = __esm({
         }
         return this.schemas.get(id);
       }
-      registerError(errorSchema, ctor) {
-        this.exceptions.set(errorSchema, ctor);
+      registerError(es, ctor) {
+        this.exceptions.set(es, ctor);
       }
-      getErrorCtor(errorSchema) {
-        return this.exceptions.get(errorSchema);
+      getErrorCtor(es) {
+        return this.exceptions.get(es);
       }
       getBaseException() {
         for (const [id, schema] of this.schemas.entries()) {
@@ -11191,6 +11099,51 @@ var init_Schema = __esm({
   }
 });
 
+// node_modules/@smithy/core/dist-es/submodules/schema/schemas/StructureSchema.js
+var StructureSchema, struct;
+var init_StructureSchema = __esm({
+  "node_modules/@smithy/core/dist-es/submodules/schema/schemas/StructureSchema.js"() {
+    init_Schema();
+    StructureSchema = class _StructureSchema extends Schema {
+      static symbol = Symbol.for("@smithy/str");
+      name;
+      traits;
+      memberNames;
+      memberList;
+      symbol = _StructureSchema.symbol;
+    };
+    struct = (namespace, name14, traits, memberNames, memberList) => Schema.assign(new StructureSchema(), {
+      name: name14,
+      namespace,
+      traits,
+      memberNames,
+      memberList
+    });
+  }
+});
+
+// node_modules/@smithy/core/dist-es/submodules/schema/schemas/ErrorSchema.js
+var ErrorSchema, error;
+var init_ErrorSchema = __esm({
+  "node_modules/@smithy/core/dist-es/submodules/schema/schemas/ErrorSchema.js"() {
+    init_Schema();
+    init_StructureSchema();
+    ErrorSchema = class _ErrorSchema extends StructureSchema {
+      static symbol = Symbol.for("@smithy/err");
+      ctor;
+      symbol = _ErrorSchema.symbol;
+    };
+    error = (namespace, name14, traits, memberNames, memberList, ctor) => Schema.assign(new ErrorSchema(), {
+      name: name14,
+      namespace,
+      traits,
+      memberNames,
+      memberList,
+      ctor: null
+    });
+  }
+});
+
 // node_modules/@smithy/core/dist-es/submodules/schema/schemas/ListSchema.js
 var ListSchema, list;
 var init_ListSchema = __esm({
@@ -11258,47 +11211,23 @@ var init_OperationSchema = __esm({
   }
 });
 
-// node_modules/@smithy/core/dist-es/submodules/schema/schemas/StructureSchema.js
-var StructureSchema, struct;
-var init_StructureSchema = __esm({
-  "node_modules/@smithy/core/dist-es/submodules/schema/schemas/StructureSchema.js"() {
+// node_modules/@smithy/core/dist-es/submodules/schema/schemas/SimpleSchema.js
+var SimpleSchema, sim;
+var init_SimpleSchema = __esm({
+  "node_modules/@smithy/core/dist-es/submodules/schema/schemas/SimpleSchema.js"() {
     init_Schema();
-    StructureSchema = class _StructureSchema extends Schema {
-      static symbol = Symbol.for("@smithy/str");
+    SimpleSchema = class _SimpleSchema extends Schema {
+      static symbol = Symbol.for("@smithy/sim");
       name;
+      schemaRef;
       traits;
-      memberNames;
-      memberList;
-      symbol = _StructureSchema.symbol;
-    };
-    struct = (namespace, name14, traits, memberNames, memberList) => Schema.assign(new StructureSchema(), {
-      name: name14,
-      namespace,
-      traits,
-      memberNames,
-      memberList
-    });
-  }
-});
-
-// node_modules/@smithy/core/dist-es/submodules/schema/schemas/ErrorSchema.js
-var ErrorSchema, error;
-var init_ErrorSchema = __esm({
-  "node_modules/@smithy/core/dist-es/submodules/schema/schemas/ErrorSchema.js"() {
-    init_Schema();
-    init_StructureSchema();
-    ErrorSchema = class _ErrorSchema extends StructureSchema {
-      static symbol = Symbol.for("@smithy/err");
-      ctor;
-      symbol = _ErrorSchema.symbol;
+      symbol = _SimpleSchema.symbol;
     };
-    error = (namespace, name14, traits, memberNames, memberList, ctor) => Schema.assign(new ErrorSchema(), {
+    sim = (namespace, name14, schemaRef, traits) => Schema.assign(new SimpleSchema(), {
       name: name14,
       namespace,
       traits,
-      memberNames,
-      memberList,
-      ctor: null
+      schemaRef
     });
   }
 });
@@ -11342,13 +11271,27 @@ function member(memberSchema, memberName) {
   const internalCtorAccess = NormalizedSchema;
   return new internalCtorAccess(memberSchema, memberName);
 }
-var NormalizedSchema;
+function hydrate(ss) {
+  const [id, ...rest] = ss;
+  return {
+    [0]: sim,
+    [1]: list,
+    [2]: map,
+    [3]: struct,
+    [-3]: error,
+    [9]: op
+  }[id].call(null, ...rest);
+}
+var NormalizedSchema, isMemberSchema, isStaticSchema;
 var init_NormalizedSchema = __esm({
   "node_modules/@smithy/core/dist-es/submodules/schema/schemas/NormalizedSchema.js"() {
     init_deref();
+    init_ErrorSchema();
     init_ListSchema();
     init_MapSchema();
+    init_OperationSchema();
     init_Schema();
+    init_SimpleSchema();
     init_StructureSchema();
     init_translateTraits();
     NormalizedSchema = class _NormalizedSchema {
@@ -11369,12 +11312,14 @@ var init_NormalizedSchema = __esm({
         let _ref = ref;
         let schema = ref;
         this._isMemberSchema = false;
-        while (Array.isArray(_ref)) {
+        while (isMemberSchema(_ref)) {
           traitStack.push(_ref[1]);
           _ref = _ref[0];
           schema = deref(_ref);
           this._isMemberSchema = true;
         }
+        if (isStaticSchema(schema))
+          schema = hydrate(schema);
         if (traitStack.length > 0) {
           this.memberTraits = {};
           for (let i3 = traitStack.length - 1; i3 >= 0; --i3) {
@@ -11411,7 +11356,7 @@ var init_NormalizedSchema = __esm({
         if (sc instanceof _NormalizedSchema) {
           return sc;
         }
-        if (Array.isArray(sc)) {
+        if (isMemberSchema(sc)) {
           const [ns, traits] = sc;
           if (ns instanceof _NormalizedSchema) {
             Object.assign(ns.getMergedTraits(), translateTraits(traits));
@@ -11520,7 +11465,7 @@ var init_NormalizedSchema = __esm({
         if (this.isStructSchema() && struct2.memberNames.includes(memberName)) {
           const i3 = struct2.memberNames.indexOf(memberName);
           const memberSchema = struct2.memberList[i3];
-          return member(Array.isArray(memberSchema) ? memberSchema : [memberSchema, 0], memberName);
+          return member(isMemberSchema(memberSchema) ? memberSchema : [memberSchema, 0], memberName);
         }
         if (this.isDocumentSchema()) {
           return member([15, 0], memberName);
@@ -11560,27 +11505,130 @@ var init_NormalizedSchema = __esm({
         }
       }
     };
+    isMemberSchema = (sc) => Array.isArray(sc) && sc.length === 2;
+    isStaticSchema = (sc) => Array.isArray(sc) && sc.length >= 5;
   }
 });
 
-// node_modules/@smithy/core/dist-es/submodules/schema/schemas/SimpleSchema.js
-var SimpleSchema, sim;
-var init_SimpleSchema = __esm({
-  "node_modules/@smithy/core/dist-es/submodules/schema/schemas/SimpleSchema.js"() {
-    init_Schema();
-    SimpleSchema = class _SimpleSchema extends Schema {
-      static symbol = Symbol.for("@smithy/sim");
-      name;
-      schemaRef;
-      traits;
-      symbol = _SimpleSchema.symbol;
+// node_modules/@smithy/core/dist-es/submodules/schema/middleware/schemaDeserializationMiddleware.js
+var import_protocol_http2, import_util_middleware3, schemaDeserializationMiddleware, findHeader;
+var init_schemaDeserializationMiddleware = __esm({
+  "node_modules/@smithy/core/dist-es/submodules/schema/middleware/schemaDeserializationMiddleware.js"() {
+    import_protocol_http2 = __toESM(require_dist_cjs2());
+    import_util_middleware3 = __toESM(require_dist_cjs7());
+    init_NormalizedSchema();
+    schemaDeserializationMiddleware = (config) => (next, context) => async (args) => {
+      const { response } = await next(args);
+      let { operationSchema } = (0, import_util_middleware3.getSmithyContext)(context);
+      if (isStaticSchema(operationSchema)) {
+        operationSchema = hydrate(operationSchema);
+      }
+      try {
+        const parsed = await config.protocol.deserializeResponse(operationSchema, {
+          ...config,
+          ...context
+        }, response);
+        return {
+          response,
+          output: parsed
+        };
+      } catch (error2) {
+        Object.defineProperty(error2, "$response", {
+          value: response
+        });
+        if (!("$metadata" in error2)) {
+          const hint = `Deserialization error: to see the raw response, inspect the hidden field {error}.$response on this object.`;
+          try {
+            error2.message += "\n  " + hint;
+          } catch (e3) {
+            if (!context.logger || context.logger?.constructor?.name === "NoOpLogger") {
+              console.warn(hint);
+            } else {
+              context.logger?.warn?.(hint);
+            }
+          }
+          if (typeof error2.$responseBodyText !== "undefined") {
+            if (error2.$response) {
+              error2.$response.body = error2.$responseBodyText;
+            }
+          }
+          try {
+            if (import_protocol_http2.HttpResponse.isInstance(response)) {
+              const { headers = {} } = response;
+              const headerEntries = Object.entries(headers);
+              error2.$metadata = {
+                httpStatusCode: response.statusCode,
+                requestId: findHeader(/^x-[\w-]+-request-?id$/, headerEntries),
+                extendedRequestId: findHeader(/^x-[\w-]+-id-2$/, headerEntries),
+                cfId: findHeader(/^x-[\w-]+-cf-id$/, headerEntries)
+              };
+            }
+          } catch (e3) {
+          }
+        }
+        throw error2;
+      }
+    };
+    findHeader = (pattern, headers) => {
+      return (headers.find(([k3]) => {
+        return k3.match(pattern);
+      }) || [void 0, void 0])[1];
+    };
+  }
+});
+
+// node_modules/@smithy/core/dist-es/submodules/schema/middleware/schemaSerializationMiddleware.js
+var import_util_middleware4, schemaSerializationMiddleware;
+var init_schemaSerializationMiddleware = __esm({
+  "node_modules/@smithy/core/dist-es/submodules/schema/middleware/schemaSerializationMiddleware.js"() {
+    import_util_middleware4 = __toESM(require_dist_cjs7());
+    init_NormalizedSchema();
+    schemaSerializationMiddleware = (config) => (next, context) => async (args) => {
+      let { operationSchema } = (0, import_util_middleware4.getSmithyContext)(context);
+      if (isStaticSchema(operationSchema)) {
+        operationSchema = hydrate(operationSchema);
+      }
+      const endpoint = context.endpointV2?.url && config.urlParser ? async () => config.urlParser(context.endpointV2.url) : config.endpoint;
+      const request = await config.protocol.serializeRequest(operationSchema, args.input, {
+        ...config,
+        ...context,
+        endpoint
+      });
+      return next({
+        ...args,
+        request
+      });
+    };
+  }
+});
+
+// node_modules/@smithy/core/dist-es/submodules/schema/middleware/getSchemaSerdePlugin.js
+function getSchemaSerdePlugin(config) {
+  return {
+    applyToStack: (commandStack) => {
+      commandStack.add(schemaSerializationMiddleware(config), serializerMiddlewareOption2);
+      commandStack.add(schemaDeserializationMiddleware(config), deserializerMiddlewareOption);
+      config.protocol.setSerdeContext(config);
+    }
+  };
+}
+var deserializerMiddlewareOption, serializerMiddlewareOption2;
+var init_getSchemaSerdePlugin = __esm({
+  "node_modules/@smithy/core/dist-es/submodules/schema/middleware/getSchemaSerdePlugin.js"() {
+    init_schemaDeserializationMiddleware();
+    init_schemaSerializationMiddleware();
+    deserializerMiddlewareOption = {
+      name: "deserializerMiddleware",
+      step: "deserialize",
+      tags: ["DESERIALIZER"],
+      override: true
+    };
+    serializerMiddlewareOption2 = {
+      name: "serializerMiddleware",
+      step: "serialize",
+      tags: ["SERIALIZER"],
+      override: true
     };
-    sim = (namespace, name14, schemaRef, traits) => Schema.assign(new SimpleSchema(), {
-      name: name14,
-      namespace,
-      traits,
-      schemaRef
-    });
   }
 });
 
@@ -11624,6 +11672,8 @@ __export(schema_exports, {
   deserializerMiddlewareOption: () => deserializerMiddlewareOption,
   error: () => error,
   getSchemaSerdePlugin: () => getSchemaSerdePlugin,
+  hydrate: () => hydrate,
+  isStaticSchema: () => isStaticSchema,
   list: () => list,
   map: () => map,
   op: () => op,
@@ -12970,6 +13020,19 @@ var init_serde = __esm({
   }
 });
 
+// node_modules/@smithy/core/dist-es/submodules/protocols/SerdeContext.js
+var SerdeContext;
+var init_SerdeContext = __esm({
+  "node_modules/@smithy/core/dist-es/submodules/protocols/SerdeContext.js"() {
+    SerdeContext = class {
+      serdeContext;
+      setSerdeContext(serdeContext) {
+        this.serdeContext = serdeContext;
+      }
+    };
+  }
+});
+
 // node_modules/@smithy/core/dist-es/submodules/event-streams/EventStreamSerde.js
 var import_util_utf8, EventStreamSerde;
 var init_EventStreamSerde = __esm({
@@ -13188,10 +13251,11 @@ var init_HttpProtocol = __esm({
   "node_modules/@smithy/core/dist-es/submodules/protocols/HttpProtocol.js"() {
     init_schema();
     import_protocol_http3 = __toESM(require_dist_cjs2());
-    HttpProtocol = class {
+    init_SerdeContext();
+    HttpProtocol = class extends SerdeContext {
       options;
-      serdeContext;
       constructor(options) {
+        super();
         this.options = options;
       }
       getRequestType() {
@@ -13775,16 +13839,14 @@ var init_FromStringShapeDeserializer = __esm({
     init_serde();
     import_util_base64 = __toESM(require_dist_cjs12());
     import_util_utf82 = __toESM(require_dist_cjs11());
+    init_SerdeContext();
     init_determineTimestampFormat();
-    FromStringShapeDeserializer = class {
+    FromStringShapeDeserializer = class extends SerdeContext {
       settings;
-      serdeContext;
       constructor(settings) {
+        super();
         this.settings = settings;
       }
-      setSerdeContext(serdeContext) {
-        this.serdeContext = serdeContext;
-      }
       read(_schema, data2) {
         const ns = NormalizedSchema.of(_schema);
         if (ns.isListSchema()) {
@@ -13848,12 +13910,13 @@ var init_HttpInterceptingShapeDeserializer = __esm({
   "node_modules/@smithy/core/dist-es/submodules/protocols/serde/HttpInterceptingShapeDeserializer.js"() {
     init_schema();
     import_util_utf83 = __toESM(require_dist_cjs11());
+    init_SerdeContext();
     init_FromStringShapeDeserializer();
-    HttpInterceptingShapeDeserializer = class {
+    HttpInterceptingShapeDeserializer = class extends SerdeContext {
       codecDeserializer;
       stringDeserializer;
-      serdeContext;
       constructor(codecDeserializer, codecSettings) {
+        super();
         this.codecDeserializer = codecDeserializer;
         this.stringDeserializer = new FromStringShapeDeserializer(codecSettings);
       }
@@ -13896,17 +13959,15 @@ var init_ToStringShapeSerializer = __esm({
     init_schema();
     init_serde();
     import_util_base642 = __toESM(require_dist_cjs12());
+    init_SerdeContext();
     init_determineTimestampFormat();
-    ToStringShapeSerializer = class {
+    ToStringShapeSerializer = class extends SerdeContext {
       settings;
       stringBuffer = "";
-      serdeContext = void 0;
       constructor(settings) {
+        super();
         this.settings = settings;
       }
-      setSerdeContext(serdeContext) {
-        this.serdeContext = serdeContext;
-      }
       write(schema, value) {
         const ns = NormalizedSchema.of(schema);
         switch (typeof value) {
@@ -14034,6 +14095,7 @@ __export(protocols_exports, {
   HttpProtocol: () => HttpProtocol,
   RequestBuilder: () => RequestBuilder,
   RpcProtocol: () => RpcProtocol,
+  SerdeContext: () => SerdeContext,
   ToStringShapeSerializer: () => ToStringShapeSerializer,
   collectBody: () => collectBody,
   determineTimestampFormat: () => determineTimestampFormat,
@@ -14055,12 +14117,13 @@ var init_protocols = __esm({
     init_HttpInterceptingShapeSerializer();
     init_ToStringShapeSerializer();
     init_determineTimestampFormat();
+    init_SerdeContext();
   }
 });
 
-// node_modules/@smithy/core/dist-es/protocols/requestBuilder.js
+// node_modules/@smithy/core/dist-es/request-builder/requestBuilder.js
 var init_requestBuilder2 = __esm({
-  "node_modules/@smithy/core/dist-es/protocols/requestBuilder.js"() {
+  "node_modules/@smithy/core/dist-es/request-builder/requestBuilder.js"() {
     init_protocols();
   }
 });
@@ -17015,13 +17078,13 @@ var init_parseCborBody = __esm({
 var import_util_base643, CborCodec, CborShapeSerializer, CborShapeDeserializer;
 var init_CborCodec = __esm({
   "node_modules/@smithy/core/dist-es/submodules/cbor/CborCodec.js"() {
+    init_protocols();
     init_schema();
     init_serde();
     import_util_base643 = __toESM(require_dist_cjs12());
     init_cbor();
     init_parseCborBody();
-    CborCodec = class {
-      serdeContext;
+    CborCodec = class extends SerdeContext {
       createSerializer() {
         const serializer = new CborShapeSerializer();
         serializer.setSerdeContext(this.serdeContext);
@@ -17032,16 +17095,9 @@ var init_CborCodec = __esm({
         deserializer.setSerdeContext(this.serdeContext);
         return deserializer;
       }
-      setSerdeContext(serdeContext) {
-        this.serdeContext = serdeContext;
-      }
     };
-    CborShapeSerializer = class {
-      serdeContext;
+    CborShapeSerializer = class extends SerdeContext {
       value;
-      setSerdeContext(serdeContext) {
-        this.serdeContext = serdeContext;
-      }
       write(schema, value) {
         this.value = this.serialize(schema, value);
       }
@@ -17113,11 +17169,7 @@ var init_CborCodec = __esm({
         return buffer;
       }
     };
-    CborShapeDeserializer = class {
-      serdeContext;
-      setSerdeContext(serdeContext) {
-        this.serdeContext = serdeContext;
-      }
+    CborShapeDeserializer = class extends SerdeContext {
       read(schema, bytes) {
         const data2 = cbor.deserialize(bytes);
         return this.readValue(schema, data2);
@@ -17982,13 +18034,16 @@ var require_dist_cjs27 = __commonJS({
             this.schema = closure._operationSchema;
           }
           resolveMiddleware(stack, configuration, options) {
+            const op2 = closure._operationSchema;
+            const input = op2?.[4] ?? op2?.input;
+            const output = op2?.[5] ?? op2?.output;
             return this.resolveMiddlewareWithContext(stack, configuration, options, {
               CommandCtor: CommandRef,
               middlewareFn: closure._middlewareFn,
               clientName: closure._clientName,
               commandName: closure._commandName,
-              inputFilterSensitiveLog: closure._inputFilterSensitiveLog ?? (closure._operationSchema ? schemaLogFilter.bind(null, closure._operationSchema.input) : (_2) => _2),
-              outputFilterSensitiveLog: closure._outputFilterSensitiveLog ?? (closure._operationSchema ? schemaLogFilter.bind(null, closure._operationSchema.output) : (_2) => _2),
+              inputFilterSensitiveLog: closure._inputFilterSensitiveLog ?? (op2 ? schemaLogFilter.bind(null, input) : (_2) => _2),
+              outputFilterSensitiveLog: closure._outputFilterSensitiveLog ?? (op2 ? schemaLogFilter.bind(null, output) : (_2) => _2),
               smithyContext: closure._smithyContext,
               additionalContext: closure._additionalContext
             });
@@ -71941,6 +71996,28 @@ var init_out = __esm({
 });
 
 // src/agent/schemaUtils.js
+var schemaUtils_exports = {};
+__export(schemaUtils_exports, {
+  JsonFixingAgent: () => JsonFixingAgent,
+  MermaidFixingAgent: () => MermaidFixingAgent,
+  cleanSchemaResponse: () => cleanSchemaResponse,
+  createJsonCorrectionPrompt: () => createJsonCorrectionPrompt,
+  createMermaidCorrectionPrompt: () => createMermaidCorrectionPrompt,
+  createSchemaDefinitionCorrectionPrompt: () => createSchemaDefinitionCorrectionPrompt,
+  decodeHtmlEntities: () => decodeHtmlEntities,
+  extractMermaidFromMarkdown: () => extractMermaidFromMarkdown,
+  isJsonSchema: () => isJsonSchema,
+  isJsonSchemaDefinition: () => isJsonSchemaDefinition,
+  isMermaidSchema: () => isMermaidSchema,
+  processSchemaResponse: () => processSchemaResponse,
+  replaceMermaidDiagramsInMarkdown: () => replaceMermaidDiagramsInMarkdown,
+  tryMaidAutoFix: () => tryMaidAutoFix,
+  validateAndFixMermaidResponse: () => validateAndFixMermaidResponse,
+  validateJsonResponse: () => validateJsonResponse,
+  validateMermaidDiagram: () => validateMermaidDiagram,
+  validateMermaidResponse: () => validateMermaidResponse,
+  validateXmlResponse: () => validateXmlResponse
+});
 function decodeHtmlEntities(text) {
   if (!text || typeof text !== "string") {
     return text;
@@ -71996,19 +72073,16 @@ function cleanSchemaResponse(response) {
       return trimmed.substring(startIndex, endIndex);
     }
   }
-  const firstBracket = Math.min(
-    trimmed.indexOf("{") >= 0 ? trimmed.indexOf("{") : Infinity,
-    trimmed.indexOf("[") >= 0 ? trimmed.indexOf("[") : Infinity
-  );
-  const lastBracket = Math.max(
-    trimmed.lastIndexOf("}"),
-    trimmed.lastIndexOf("]")
-  );
-  if (firstBracket < Infinity && lastBracket >= 0 && firstBracket < lastBracket) {
-    const beforeFirstBracket = trimmed.substring(0, firstBracket).trim();
-    if (beforeFirstBracket === "" || beforeFirstBracket.match(/^```\w*$/) || beforeFirstBracket.split("\n").length <= 2) {
-      return trimmed.substring(firstBracket, lastBracket + 1);
-    }
+  let cleaned = trimmed;
+  cleaned = cleaned.replace(/^```(?:json)?\s*\n?/i, "");
+  cleaned = cleaned.replace(/\n?```\s*$/, "");
+  cleaned = cleaned.trim();
+  const firstChar = cleaned[0];
+  const lastChar = cleaned[cleaned.length - 1];
+  const isJsonObject = firstChar === "{" && lastChar === "}";
+  const isJsonArray = firstChar === "[" && lastChar === "]";
+  if (isJsonObject || isJsonArray) {
+    return cleaned;
   }
   return response;
 }
@@ -72029,9 +72103,49 @@ function validateJsonResponse(response, options = {}) {
     }
     return { isValid: true, parsed };
   } catch (error2) {
+    const positionMatch = error2.message.match(/position (\d+)/);
+    let errorPosition = positionMatch ? parseInt(positionMatch[1], 10) : null;
+    if (errorPosition === null) {
+      const tokenMatch = error2.message.match(/Unexpected token '(.)', /);
+      if (tokenMatch && tokenMatch[1]) {
+        const problematicToken = tokenMatch[1];
+        errorPosition = response.indexOf(problematicToken);
+      }
+    }
+    let enhancedError = error2.message;
+    let errorContext = null;
+    if (errorPosition !== null && errorPosition >= 0 && response && response.length > 0) {
+      const contextRadius = 50;
+      const startPos = Math.max(0, errorPosition - contextRadius);
+      const endPos = Math.min(response.length, errorPosition + contextRadius);
+      const beforeError = response.substring(startPos, errorPosition);
+      const atError = response[errorPosition] || "";
+      const afterError = response.substring(errorPosition + 1, endPos);
+      const snippet = beforeError + atError + afterError;
+      const pointerOffset = beforeError.length;
+      const pointer = " ".repeat(pointerOffset) + "^";
+      errorContext = {
+        position: errorPosition,
+        snippet,
+        pointer,
+        beforeError,
+        atError,
+        afterError
+      };
+      enhancedError = `${error2.message}
+
+Error location (position ${errorPosition}):
+${snippet}
+${pointer} here`;
+    }
     if (debug) {
       console.log(`[DEBUG] JSON validation: Parse failed with error: ${error2.message}`);
-      console.log(`[DEBUG] JSON validation: Error at position: ${error2.message.match(/position (\d+)/) ? error2.message.match(/position (\d+)/)[1] : "unknown"}`);
+      console.log(`[DEBUG] JSON validation: Error at position: ${errorPosition !== null ? errorPosition : "unknown"}`);
+      if (errorContext) {
+        console.log(`[DEBUG] JSON validation: Error context:
+${errorContext.snippet}
+${errorContext.pointer}`);
+      }
       if (error2.message.includes("Unexpected token")) {
         console.log(`[DEBUG] JSON validation: Likely syntax error - unexpected character`);
       } else if (error2.message.includes("Unexpected end")) {
@@ -72040,8 +72154,72 @@ function validateJsonResponse(response, options = {}) {
         console.log(`[DEBUG] JSON validation: Likely unquoted property names`);
       }
     }
-    return { isValid: false, error: error2.message };
+    return {
+      isValid: false,
+      error: error2.message,
+      enhancedError,
+      errorContext
+    };
+  }
+}
+function validateXmlResponse(response) {
+  const xmlPattern = /<\/?[\w\s="'.-]+>/g;
+  const tags = response.match(xmlPattern);
+  if (!tags) {
+    return { isValid: false, error: "No XML tags found" };
   }
+  if (response.includes("<") && response.includes(">")) {
+    return { isValid: true };
+  }
+  return { isValid: false, error: "Invalid XML structure" };
+}
+function processSchemaResponse(response, schema, options = {}) {
+  const { validateJson = false, validateXml = false, debug = false } = options;
+  if (debug) {
+    console.log(`[DEBUG] Schema processing: Starting with response length ${response.length}`);
+    console.log(`[DEBUG] Schema processing: Schema type detection...`);
+    if (isJsonSchema(schema)) {
+      console.log(`[DEBUG] Schema processing: Detected JSON schema`);
+    } else {
+      console.log(`[DEBUG] Schema processing: Non-JSON schema detected`);
+    }
+  }
+  const cleanStart = Date.now();
+  const cleaned = cleanSchemaResponse(response);
+  const cleanTime = Date.now() - cleanStart;
+  const result = { cleaned };
+  if (debug) {
+    console.log(`[DEBUG] Schema processing: Cleaning completed in ${cleanTime}ms`);
+    result.debug = {
+      originalLength: response.length,
+      cleanedLength: cleaned.length,
+      wasModified: response !== cleaned,
+      cleaningTimeMs: cleanTime,
+      removedContent: response !== cleaned ? {
+        before: response.substring(0, 100) + (response.length > 100 ? "..." : ""),
+        after: cleaned.substring(0, 100) + (cleaned.length > 100 ? "..." : "")
+      } : null
+    };
+    if (response !== cleaned) {
+      console.log(`[DEBUG] Schema processing: Response was modified during cleaning`);
+      console.log(`[DEBUG] Schema processing: Original length: ${response.length}, cleaned length: ${cleaned.length}`);
+    } else {
+      console.log(`[DEBUG] Schema processing: Response unchanged during cleaning`);
+    }
+  }
+  if (validateJson) {
+    if (debug) {
+      console.log(`[DEBUG] Schema processing: Running JSON validation...`);
+    }
+    result.jsonValidation = validateJsonResponse(cleaned, { debug });
+  }
+  if (validateXml) {
+    if (debug) {
+      console.log(`[DEBUG] Schema processing: Running XML validation...`);
+    }
+    result.xmlValidation = validateXmlResponse(cleaned);
+  }
+  return result;
 }
 function isJsonSchema(schema) {
   if (!schema || typeof schema !== "string") {
@@ -72101,7 +72279,16 @@ function isJsonSchemaDefinition(jsonString, options = {}) {
     return false;
   }
 }
-function createJsonCorrectionPrompt(invalidResponse, schema, error2, retryCount = 0) {
+function createJsonCorrectionPrompt(invalidResponse, schema, errorOrValidation, retryCount = 0) {
+  let errorMessage;
+  let enhancedError;
+  if (typeof errorOrValidation === "object" && errorOrValidation !== null) {
+    errorMessage = errorOrValidation.error;
+    enhancedError = errorOrValidation.enhancedError || errorMessage;
+  } else {
+    errorMessage = errorOrValidation;
+    enhancedError = errorMessage;
+  }
   const strengthLevels = [
     {
       prefix: "CRITICAL JSON ERROR:",
@@ -72125,7 +72312,7 @@ function createJsonCorrectionPrompt(invalidResponse, schema, error2, retryCount
 
 ${invalidResponse.substring(0, 500)}${invalidResponse.length > 500 ? "..." : ""}
 
-Error: ${error2}
+Error: ${enhancedError}
 
 ${currentLevel.instruction}
 
@@ -72170,6 +72357,28 @@ ${currentLevel.example}
 Return ONLY the JSON data object/array that follows the schema structure. NO schema definitions, NO explanations, NO markdown formatting.`;
   return prompt;
 }
+function isMermaidSchema(schema) {
+  if (!schema || typeof schema !== "string") {
+    return false;
+  }
+  const trimmedSchema = schema.trim().toLowerCase();
+  const mermaidIndicators = [
+    trimmedSchema.includes("mermaid"),
+    trimmedSchema.includes("diagram"),
+    trimmedSchema.includes("flowchart"),
+    trimmedSchema.includes("sequence"),
+    trimmedSchema.includes("gantt"),
+    trimmedSchema.includes("pie chart"),
+    trimmedSchema.includes("state diagram"),
+    trimmedSchema.includes("class diagram"),
+    trimmedSchema.includes("entity relationship"),
+    trimmedSchema.includes("user journey"),
+    trimmedSchema.includes("git graph"),
+    trimmedSchema.includes("requirement diagram"),
+    trimmedSchema.includes("c4 context")
+  ];
+  return mermaidIndicators.some((indicator) => indicator);
+}
 function extractMermaidFromMarkdown(response) {
   if (!response || typeof response !== "string") {
     return { diagrams: [], cleanedResponse: response };
@@ -72190,6 +72399,24 @@ function extractMermaidFromMarkdown(response) {
   }
   return { diagrams, cleanedResponse: response };
 }
+function replaceMermaidDiagramsInMarkdown(originalResponse, correctedDiagrams) {
+  if (!originalResponse || typeof originalResponse !== "string") {
+    return originalResponse;
+  }
+  if (!correctedDiagrams || correctedDiagrams.length === 0) {
+    return originalResponse;
+  }
+  let modifiedResponse = originalResponse;
+  const sortedDiagrams = [...correctedDiagrams].sort((a3, b3) => b3.startIndex - a3.startIndex);
+  for (const diagram of sortedDiagrams) {
+    const attributesStr = diagram.attributes ? ` ${diagram.attributes}` : "";
+    const newCodeBlock = `\`\`\`mermaid${attributesStr}
+${diagram.content}
+\`\`\``;
+    modifiedResponse = modifiedResponse.slice(0, diagram.startIndex) + newCodeBlock + modifiedResponse.slice(diagram.endIndex);
+  }
+  return modifiedResponse;
+}
 async function validateMermaidDiagram(diagram) {
   if (!diagram || typeof diagram !== "string") {
     return { isValid: false, error: "Empty or invalid diagram input" };
@@ -72256,6 +72483,45 @@ async function validateMermaidResponse(response) {
     errors: errors.length > 0 ? errors : void 0
   };
 }
+function createMermaidCorrectionPrompt(invalidResponse, schema, errors, diagrams) {
+  let prompt = `Your previous response contains invalid Mermaid diagrams that cannot be parsed. Here's what you returned:
+
+${invalidResponse}
+
+Validation Errors:`;
+  errors.forEach((error2, index) => {
+    prompt += `
+${index + 1}. ${error2}`;
+  });
+  if (diagrams && diagrams.length > 0) {
+    prompt += `
+
+Diagram Details:`;
+    diagrams.forEach((diagramResult, index) => {
+      if (!diagramResult.isValid) {
+        prompt += `
+
+Diagram ${index + 1}:`;
+        const diagramContent = diagramResult.content || diagramResult.diagram || "";
+        prompt += `
+- Content: ${diagramContent.substring(0, 100)}${diagramContent.length > 100 ? "..." : ""}`;
+        prompt += `
+- Error: ${diagramResult.error}`;
+        if (diagramResult.detailedError && diagramResult.detailedError !== diagramResult.error) {
+          prompt += `
+- Details: ${diagramResult.detailedError}`;
+        }
+      }
+    });
+  }
+  prompt += `
+
+Please correct your response to include valid Mermaid diagrams that match this schema:
+${schema}
+
+Ensure all Mermaid diagrams are properly formatted within \`\`\`mermaid code blocks and follow correct Mermaid syntax.`;
+  return prompt;
+}
 async function tryMaidAutoFix(diagramContent, options = {}) {
   const { debug = false } = options;
   try {
@@ -72565,7 +72831,7 @@ ${fixedContent}
     };
   }
 }
-var HTML_ENTITY_MAP, MermaidFixingAgent;
+var HTML_ENTITY_MAP, JsonFixingAgent, MermaidFixingAgent;
 var init_schemaUtils = __esm({
   "src/agent/schemaUtils.js"() {
     "use strict";
@@ -72581,6 +72847,156 @@ var init_schemaUtils = __esm({
       // Also handle XML/HTML5 apostrophe entity
       "&nbsp;": " "
     };
+    JsonFixingAgent = class {
+      constructor(options = {}) {
+        this.ProbeAgent = null;
+        this.options = {
+          sessionId: options.sessionId || `json-fixer-${Date.now()}`,
+          path: options.path || process.cwd(),
+          provider: options.provider,
+          model: options.model,
+          debug: options.debug,
+          tracer: options.tracer,
+          // Set to false since we're only fixing JSON syntax, not implementing code
+          allowEdit: false
+        };
+      }
+      /**
+       * Get the specialized prompt for JSON fixing
+       */
+      getJsonFixingPrompt() {
+        return `You are a world-class JSON syntax correction specialist. Your expertise lies in analyzing and fixing JSON syntax errors while preserving the original data structure and intent.
+
+CORE RESPONSIBILITIES:
+- Analyze JSON for syntax errors and structural issues
+- Fix syntax errors while maintaining the original data's semantic meaning
+- Ensure JSON follows proper RFC 8259 specification
+- Handle all JSON structures: objects, arrays, primitives, nested structures
+
+JSON SYNTAX RULES:
+1. **Property names**: Must be enclosed in double quotes
+2. **String values**: Must use double quotes (not single quotes)
+3. **Numbers**: Can be integers or decimals, no quotes needed
+4. **Booleans**: true or false (lowercase, no quotes)
+5. **Null**: null (lowercase, no quotes)
+6. **Arrays**: Comma-separated values in square brackets [...]
+7. **Objects**: Comma-separated key-value pairs in curly braces {...}
+8. **No trailing commas**: Last item in array/object must not have a trailing comma
+9. **Escape sequences**: Special characters must be escaped (\\n, \\t, \\", \\\\, etc.)
+
+COMMON ERRORS TO FIX:
+1. **Unquoted property names**: {name: "value"} \u2192 {"name": "value"}
+2. **Single quotes**: {'key': 'value'} \u2192 {"key": "value"}
+3. **Trailing commas**: {"a": 1,} \u2192 {"a": 1}
+4. **Unquoted strings**: {key: value} \u2192 {"key": "value"}
+5. **Missing commas**: {"a": 1 "b": 2} \u2192 {"a": 1, "b": 2}
+6. **Extra commas**: {"a": 1,, "b": 2} \u2192 {"a": 1, "b": 2}
+7. **Unclosed brackets/braces**: {"key": "value" \u2192 {"key": "value"}
+8. **Invalid escape sequences**: Fix or remove
+9. **Comments**: Remove // or /* */ comments (not allowed in JSON)
+10. **Undefined values**: Replace undefined with null
+
+FIXING METHODOLOGY:
+1. **Identify the error location** from the error message
+2. **Analyze the context** around the error
+3. **Apply the appropriate fix** based on JSON syntax rules
+4. **Preserve data intent** - never change the meaning of the data
+5. **Validate the result** - ensure it's parseable JSON
+
+CRITICAL RULES:
+- ALWAYS output only the corrected JSON
+- NEVER add explanations, comments, or additional text
+- NEVER wrap in markdown code blocks (no \`\`\`json)
+- PRESERVE the original data structure and values
+- FIX only syntax errors, don't modify the data itself
+- ENSURE the output is valid, parseable JSON
+
+When presented with broken JSON, analyze it thoroughly and provide the corrected version that maintains the original intent while fixing all syntax issues.`;
+      }
+      /**
+       * Initialize the ProbeAgent if not already done
+       */
+      async initializeAgent() {
+        if (!this.ProbeAgent) {
+          const { ProbeAgent: ProbeAgent2 } = await Promise.resolve().then(() => (init_ProbeAgent(), ProbeAgent_exports));
+          this.ProbeAgent = ProbeAgent2;
+        }
+        if (!this.agent) {
+          this.agent = new this.ProbeAgent({
+            sessionId: this.options.sessionId,
+            customPrompt: this.getJsonFixingPrompt(),
+            path: this.options.path,
+            provider: this.options.provider,
+            model: this.options.model,
+            debug: this.options.debug,
+            tracer: this.options.tracer,
+            allowEdit: this.options.allowEdit,
+            maxIterations: 5,
+            // Allow multiple iterations for JSON fixing
+            disableJsonValidation: true
+            // CRITICAL: Disable JSON validation in nested agent to prevent infinite recursion
+          });
+        }
+        return this.agent;
+      }
+      /**
+       * Fix invalid JSON using the specialized agent
+       * @param {string} invalidJson - The broken JSON string
+       * @param {string} schema - The original schema for context
+       * @param {Object} validationResult - Validation result with error details
+       * @param {number} attemptNumber - Current attempt number (for logging)
+       * @returns {Promise<string>} - The corrected JSON
+       */
+      async fixJson(invalidJson, schema, validationResult, attemptNumber = 1) {
+        await this.initializeAgent();
+        let errorContext = validationResult.error;
+        if (validationResult.enhancedError) {
+          errorContext = validationResult.enhancedError;
+        }
+        const prompt = `Fix the following invalid JSON.
+
+Error: ${errorContext}
+
+Invalid JSON:
+${invalidJson}
+
+Expected schema structure:
+${schema}
+
+Provide only the corrected JSON without any markdown formatting or explanations.`;
+        try {
+          if (this.options.debug) {
+            console.log(`[DEBUG] JSON fixing: Attempt ${attemptNumber} to fix JSON with separate agent`);
+          }
+          const result = await this.agent.answer(prompt, []);
+          const cleaned = cleanSchemaResponse(result);
+          if (this.options.debug) {
+            console.log(`[DEBUG] JSON fixing: Agent returned ${cleaned.length} chars`);
+          }
+          return cleaned;
+        } catch (error2) {
+          if (this.options.debug) {
+            console.error(`[DEBUG] JSON fixing failed: ${error2.message}`);
+          }
+          throw new Error(`Failed to fix JSON: ${error2.message}`);
+        }
+      }
+      /**
+       * Get token usage information from the specialized agent
+       * @returns {Object} - Token usage statistics
+       */
+      getTokenUsage() {
+        return this.agent ? this.agent.getTokenUsage() : null;
+      }
+      /**
+       * Cancel any ongoing operations
+       */
+      cancel() {
+        if (this.agent) {
+          this.agent.cancel();
+        }
+      }
+    };
     MermaidFixingAgent = class {
       constructor(options = {}) {
         this.ProbeAgent = null;
@@ -73573,6 +73989,7 @@ var init_ProbeAgent = __esm({
        * @param {number} [options.maxResponseTokens] - Maximum tokens for AI responses
        * @param {number} [options.maxIterations] - Maximum tool iterations (overrides MAX_TOOL_ITERATIONS env var)
        * @param {boolean} [options.disableMermaidValidation=false] - Disable automatic mermaid diagram validation and fixing
+       * @param {boolean} [options.disableJsonValidation=false] - Disable automatic JSON validation and fixing (prevents infinite recursion in JsonFixingAgent)
        * @param {boolean} [options.enableMcp=false] - Enable MCP tool integration
        * @param {string} [options.mcpConfigPath] - Path to MCP configuration file
        * @param {Object} [options.mcpConfig] - MCP configuration object (overrides mcpConfigPath)
@@ -73592,6 +74009,7 @@ var init_ProbeAgent = __esm({
         this.maxResponseTokens = options.maxResponseTokens || parseInt(process.env.MAX_RESPONSE_TOKENS || "0", 10) || null;
         this.maxIterations = options.maxIterations || null;
         this.disableMermaidValidation = !!options.disableMermaidValidation;
+        this.disableJsonValidation = !!options.disableJsonValidation;
         this.storageAdapter = options.storageAdapter || new InMemoryStorageAdapter();
         this.hooks = new HookManager();
         if (options.hooks) {
@@ -74806,15 +75224,16 @@ Remember: Use proper XML format with BOTH opening and closing tags:
 <parameter>value</parameter>
 </tool_name>
 
-IMPORTANT: A schema was provided. You MUST respond with data that matches this schema.
-Use attempt_completion with your response directly inside the tags:
+IMPORTANT: A schema was provided for the final output format. You have two options:
 
+Option 1 - Use attempt_completion with your complete answer:
 <attempt_completion>
-[Your response content matching the provided schema format]
+[Your complete answer here - will be automatically formatted to match the schema]
 </attempt_completion>
 
-Your response must conform to this schema:
-${options.schema}`;
+Option 2 - Provide a natural response without any tool, and it will be automatically formatted.
+
+Do NOT try to format your response as JSON yourself - this will be done automatically.`;
               } else {
                 reminderContent = `Please use one of the available tools to help answer the question, or use attempt_completion if you have enough information to provide a final answer.
 
@@ -74961,6 +75380,10 @@ Convert your previous response content into actual JSON data that follows this s
                   console.log(`[DEBUG] JSON validation: Starting validation process for schema response`);
                   console.log(`[DEBUG] JSON validation: Response length: ${finalResult.length} chars`);
                 }
+                finalResult = cleanSchemaResponse(finalResult);
+                if (this.debug) {
+                  console.log(`[DEBUG] JSON validation: After cleaning, length: ${finalResult.length} chars`);
+                }
                 if (this.tracer) {
                   this.tracer.recordJsonValidationEvent("started", {
                     "json_validation.response_length": finalResult.length,
@@ -74972,75 +75395,66 @@ Convert your previous response content into actual JSON data that follows this s
                 const maxRetries = 3;
                 if (validation.isValid && isJsonSchemaDefinition(finalResult, { debug: this.debug })) {
                   if (this.debug) {
-                    console.log(`[DEBUG] JSON validation: Response is a JSON schema definition instead of data, correcting...`);
+                    console.log(`[DEBUG] JSON validation: Response is a JSON schema definition instead of data, needs correction...`);
                   }
-                  const schemaDefinitionPrompt = createSchemaDefinitionCorrectionPrompt(
-                    finalResult,
-                    options.schema,
-                    0
-                  );
-                  finalResult = await this.answer(schemaDefinitionPrompt, [], {
-                    ...options,
-                    _schemaFormatted: true
-                  });
-                  finalResult = cleanSchemaResponse(finalResult);
-                  validation = validateJsonResponse(finalResult);
-                  retryCount = 1;
+                  validation = {
+                    isValid: false,
+                    error: "Response is a JSON schema definition instead of actual data",
+                    enhancedError: "Response is a JSON schema definition instead of actual data. Please return data that conforms to the schema, not the schema itself."
+                  };
                 }
-                while (!validation.isValid && retryCount < maxRetries) {
+                if (!validation.isValid) {
                   if (this.debug) {
-                    console.log(`[DEBUG] JSON validation: Validation failed (attempt ${retryCount + 1}/${maxRetries}):`, validation.error);
-                    console.log(`[DEBUG] JSON validation: Invalid response sample: ${finalResult.substring(0, 300)}${finalResult.length > 300 ? "..." : ""}`);
+                    console.log(`[DEBUG] JSON validation: Starting separate JsonFixingAgent session...`);
                   }
-                  let correctionPrompt;
-                  try {
-                    if (isJsonSchemaDefinition(finalResult, { debug: this.debug })) {
-                      if (this.debug) {
-                        console.log(`[DEBUG] JSON validation: Response is still a schema definition, using specialized correction`);
-                      }
-                      correctionPrompt = createSchemaDefinitionCorrectionPrompt(
-                        finalResult,
-                        options.schema,
-                        retryCount
-                      );
-                    } else {
-                      correctionPrompt = createJsonCorrectionPrompt(
-                        finalResult,
+                  const { JsonFixingAgent: JsonFixingAgent2 } = await Promise.resolve().then(() => (init_schemaUtils(), schemaUtils_exports));
+                  const jsonFixer = new JsonFixingAgent2({
+                    path: this.allowedFolders[0],
+                    provider: this.clientApiProvider,
+                    model: this.model,
+                    debug: this.debug,
+                    tracer: this.tracer
+                  });
+                  let currentResult = finalResult;
+                  let currentValidation = validation;
+                  while (!currentValidation.isValid && retryCount < maxRetries) {
+                    if (this.debug) {
+                      console.log(`[DEBUG] JSON validation: Validation failed (attempt ${retryCount + 1}/${maxRetries}):`, currentValidation.error);
+                      console.log(`[DEBUG] JSON validation: Invalid response sample: ${currentResult.substring(0, 300)}${currentResult.length > 300 ? "..." : ""}`);
+                    }
+                    try {
+                      currentResult = await jsonFixer.fixJson(
+                        currentResult,
                         options.schema,
-                        validation.error,
-                        retryCount
+                        currentValidation,
+                        retryCount + 1
                       );
+                      currentValidation = validateJsonResponse(currentResult, { debug: this.debug });
+                      retryCount++;
+                      if (this.debug) {
+                        if (!currentValidation.isValid && retryCount < maxRetries) {
+                          console.log(`[DEBUG] JSON validation: Still invalid after correction ${retryCount}, retrying...`);
+                          console.log(`[DEBUG] JSON validation: Corrected response sample: ${currentResult.substring(0, 300)}${currentResult.length > 300 ? "..." : ""}`);
+                        } else if (currentValidation.isValid) {
+                          console.log(`[DEBUG] JSON validation: Successfully corrected after ${retryCount} attempts with JsonFixingAgent`);
+                        }
+                      }
+                    } catch (error2) {
+                      if (this.debug) {
+                        console.error(`[DEBUG] JSON validation: JsonFixingAgent error on attempt ${retryCount + 1}:`, error2.message);
+                      }
+                      break;
                     }
-                  } catch (error2) {
-                    correctionPrompt = createJsonCorrectionPrompt(
-                      finalResult,
-                      options.schema,
-                      validation.error,
-                      retryCount
-                    );
                   }
-                  finalResult = await this.answer(correctionPrompt, [], {
-                    ...options,
-                    _schemaFormatted: true
-                  });
-                  finalResult = cleanSchemaResponse(finalResult);
-                  validation = validateJsonResponse(finalResult, { debug: this.debug });
-                  retryCount++;
-                  if (this.debug) {
-                    if (!validation.isValid && retryCount < maxRetries) {
-                      console.log(`[DEBUG] JSON validation: Still invalid after correction ${retryCount}, retrying...`);
-                      console.log(`[DEBUG] JSON validation: Corrected response sample: ${finalResult.substring(0, 300)}${finalResult.length > 300 ? "..." : ""}`);
-                    } else if (validation.isValid) {
-                      console.log(`[DEBUG] JSON validation: Successfully corrected after ${retryCount} attempts`);
-                    }
+                  finalResult = currentResult;
+                  validation = currentValidation;
+                  if (!validation.isValid && this.debug) {
+                    console.log(`[DEBUG] JSON validation: Still invalid after ${maxRetries} correction attempts with JsonFixingAgent:`, validation.error);
+                    console.log(`[DEBUG] JSON validation: Final invalid response: ${finalResult.substring(0, 500)}${finalResult.length > 500 ? "..." : ""}`);
+                  } else if (validation.isValid && this.debug) {
+                    console.log(`[DEBUG] JSON validation: Final validation successful`);
                   }
                 }
-                if (!validation.isValid && this.debug) {
-                  console.log(`[DEBUG] JSON validation: Still invalid after ${maxRetries} correction attempts:`, validation.error);
-                  console.log(`[DEBUG] JSON validation: Final invalid response: ${finalResult.substring(0, 500)}${finalResult.length > 500 ? "..." : ""}`);
-                } else if (validation.isValid && this.debug) {
-                  console.log(`[DEBUG] JSON validation: Final validation successful`);
-                }
                 if (this.tracer) {
                   this.tracer.recordJsonValidationEvent("completed", {
                     "json_validation.success": validation.isValid,
@@ -75288,6 +75702,7 @@ Convert your previous response content into actual JSON data that follows this s
           maxResponseTokens: this.maxResponseTokens,
           maxIterations: this.maxIterations,
           disableMermaidValidation: this.disableMermaidValidation,
+          disableJsonValidation: this.disableJsonValidation,
           enableMcp: !!this.mcpBridge,
           mcpConfig: this.mcpConfig,
           enableBash: this.enableBash,
@@ -75306,11 +75721,44 @@ Convert your previous response content into actual JSON data that follows this s
       }
       /**
        * Internal method to strip internal/temporary messages from history
-       * Removes: schema reminders, mermaid fix prompts, tool use reminders, etc.
-       * Keeps: system message, user messages, assistant responses, tool results
+       * Strategy: Find the FIRST schema-related message and truncate everything from that point onwards.
+       * This ensures that all schema formatting iterations (IMPORTANT, CRITICAL, corrections, etc.) are removed.
+       * Keeps: system message, user messages, assistant responses, tool results up to the first schema message
        * @private
        */
       _stripInternalMessages(history, keepSystemMessage = true) {
+        let firstSchemaMessageIndex = -1;
+        for (let i3 = 0; i3 < history.length; i3++) {
+          const message = history[i3];
+          if (message.role === "system") {
+            continue;
+          }
+          if (this._isSchemaMessage(message)) {
+            firstSchemaMessageIndex = i3;
+            if (this.debug) {
+              console.log(`[DEBUG] Found first schema message at index ${i3}, truncating from here`);
+            }
+            break;
+          }
+        }
+        if (firstSchemaMessageIndex === -1) {
+          return this._stripNonSchemaInternalMessages(history, keepSystemMessage);
+        }
+        const truncated = history.slice(0, firstSchemaMessageIndex);
+        const filtered = this._stripNonSchemaInternalMessages(truncated, keepSystemMessage);
+        if (this.debug) {
+          const removedCount = history.length - filtered.length;
+          console.log(`[DEBUG] Truncated at schema message (index ${firstSchemaMessageIndex}) and filtered non-schema internal messages`);
+          console.log(`[DEBUG] Removed ${removedCount} messages total (${history.length} \u2192 ${filtered.length})`);
+        }
+        return filtered;
+      }
+      /**
+       * Strip non-schema internal messages (mermaid fixes, tool reminders, etc.) individually
+       * Used when no schema messages are present in history
+       * @private
+       */
+      _stripNonSchemaInternalMessages(history, keepSystemMessage = true) {
         const filtered = [];
         for (let i3 = 0; i3 < history.length; i3++) {
           const message = history[i3];
@@ -75322,9 +75770,9 @@ Convert your previous response content into actual JSON data that follows this s
             }
             continue;
           }
-          if (this._isInternalMessage(message, i3, history)) {
+          if (this._isNonSchemaInternalMessage(message)) {
             if (this.debug) {
-              console.log(`[DEBUG] Stripping internal message at index ${i3}: ${message.role}`);
+              console.log(`[DEBUG] Stripping non-schema internal message at index ${i3}: ${message.role}`);
             }
             continue;
           }
@@ -75333,20 +75781,50 @@ Convert your previous response content into actual JSON data that follows this s
         return filtered;
       }
       /**
-       * Determine if a message is an internal/temporary message
+       * Check if a message is schema-related (IMPORTANT, CRITICAL, etc.)
        * @private
        */
-      _isInternalMessage(message, index, history) {
+      _isSchemaMessage(message) {
         if (message.role !== "user") {
           return false;
         }
         if (!message.content) {
           return false;
         }
-        const content = typeof message.content === "string" ? message.content : JSON.stringify(message.content);
-        if (content.includes("IMPORTANT: A schema was provided") || content.includes("You MUST respond with data that matches this schema") || content.includes("Your response must conform to this schema:")) {
+        let content;
+        try {
+          content = typeof message.content === "string" ? message.content : JSON.stringify(message.content);
+        } catch (error2) {
+          if (this.debug) {
+            console.log(`[DEBUG] Could not stringify message content in _isSchemaMessage: ${error2.message}`);
+          }
+          return false;
+        }
+        if (content.includes("IMPORTANT: A schema was provided") || content.includes("You MUST respond with data that matches this schema") || content.includes("Your response must conform to this schema:") || content.includes("CRITICAL: You MUST respond with ONLY valid JSON DATA") || content.includes("Schema to follow (this is just the structure")) {
           return true;
         }
+        return false;
+      }
+      /**
+       * Check if a message is a non-schema internal message (mermaid, tool reminders, JSON corrections)
+       * @private
+       */
+      _isNonSchemaInternalMessage(message) {
+        if (message.role !== "user") {
+          return false;
+        }
+        if (!message.content) {
+          return false;
+        }
+        let content;
+        try {
+          content = typeof message.content === "string" ? message.content : JSON.stringify(message.content);
+        } catch (error2) {
+          if (this.debug) {
+            console.log(`[DEBUG] Could not stringify message content in _isNonSchemaInternalMessage: ${error2.message}`);
+          }
+          return false;
+        }
         if (content.includes("Please use one of the available tools") && content.includes("or use attempt_completion") && content.includes("Remember: Use proper XML format")) {
           return true;
         }