@probelabs/probe 0.6.0-rc134 → 0.6.0-rc136

package/cjs/index.cjs

@@ -8357,10 +8357,10 @@ var require_dist_cjs3 = __commonJS({
     }
     __name(resolveEventStreamConfig, "resolveEventStreamConfig");
     var import_protocol_http15 = require_dist_cjs2();
-    var eventStreamHandlingMiddleware = /* @__PURE__ */ __name((options) => (next, context) => async (args) => {
+    var eventStreamHandlingMiddleware = /* @__PURE__ */ __name((options) => (next, context3) => async (args) => {
       const { request } = args;
       if (!import_protocol_http15.HttpRequest.isInstance(request)) return next(args);
-      return options.eventStreamPayloadHandler.handle(next, args, context);
+      return options.eventStreamPayloadHandler.handle(next, args, context3);
     }, "eventStreamHandlingMiddleware");
     var eventStreamHandlingMiddlewareOptions = {
       tags: ["EVENT_STREAM", "SIGNATURE", "HANDLE"],
@@ -8490,13 +8490,13 @@ var require_dist_cjs5 = __commonJS({
       loggerMiddlewareOptions: () => loggerMiddlewareOptions
     });
     module2.exports = __toCommonJS2(index_exports2);
-    var loggerMiddleware = /* @__PURE__ */ __name(() => (next, context) => async (args) => {
+    var loggerMiddleware = /* @__PURE__ */ __name(() => (next, context3) => async (args) => {
       try {
         const response = await next(args);
-        const { clientName, commandName, logger: logger2, dynamoDbDocumentClientOptions = {} } = context;
+        const { clientName, commandName, logger: logger2, dynamoDbDocumentClientOptions = {} } = context3;
         const { overrideInputFilterSensitiveLog, overrideOutputFilterSensitiveLog } = dynamoDbDocumentClientOptions;
-        const inputFilterSensitiveLog = overrideInputFilterSensitiveLog ?? context.inputFilterSensitiveLog;
-        const outputFilterSensitiveLog = overrideOutputFilterSensitiveLog ?? context.outputFilterSensitiveLog;
+        const inputFilterSensitiveLog = overrideInputFilterSensitiveLog ?? context3.inputFilterSensitiveLog;
+        const outputFilterSensitiveLog = overrideOutputFilterSensitiveLog ?? context3.outputFilterSensitiveLog;
         const { $metadata, ...outputWithoutMetadata } = response.output;
         logger2?.info?.({
           clientName,
@@ -8507,9 +8507,9 @@ var require_dist_cjs5 = __commonJS({
         });
         return response;
       } catch (error2) {
-        const { clientName, commandName, logger: logger2, dynamoDbDocumentClientOptions = {} } = context;
+        const { clientName, commandName, logger: logger2, dynamoDbDocumentClientOptions = {} } = context3;
         const { overrideInputFilterSensitiveLog } = dynamoDbDocumentClientOptions;
-        const inputFilterSensitiveLog = overrideInputFilterSensitiveLog ?? context.inputFilterSensitiveLog;
+        const inputFilterSensitiveLog = overrideInputFilterSensitiveLog ?? context3.inputFilterSensitiveLog;
         logger2?.error?.({
           clientName,
           commandName,
@@ -8556,8 +8556,8 @@ var require_invoke_store = __commonJS({
       /**
        * Initialize and run code within an invoke context
        */
-      static run(context, fn) {
-        return this.storage.run({ ...context }, fn);
+      static run(context3, fn) {
+        return this.storage.run({ ...context3 }, fn);
       }
       /**
        * Get the complete current context
@@ -8569,8 +8569,8 @@ var require_invoke_store = __commonJS({
        * Get a specific value from the context by key
        */
       static get(key) {
-        const context = this.storage.getStore();
-        return context?.[key];
+        const context3 = this.storage.getStore();
+        return context3?.[key];
       }
       /**
        * Set a custom value in the current context
@@ -8580,9 +8580,9 @@ var require_invoke_store = __commonJS({
         if (this.isProtectedKey(key)) {
           throw new Error(`Cannot modify protected Lambda context field`);
         }
-        const context = this.storage.getStore();
-        if (context) {
-          context[key] = value;
+        const context3 = this.storage.getStore();
+        if (context3) {
+          context3[key] = value;
         }
       }
       /**
@@ -8710,7 +8710,7 @@ var import_types, getSmithyContext;
 var init_getSmithyContext = __esm({
   "node_modules/@smithy/core/dist-es/getSmithyContext.js"() {
     import_types = __toESM(require_dist_cjs());
-    getSmithyContext = (context) => context[import_types.SMITHY_CONTEXT_KEY] || (context[import_types.SMITHY_CONTEXT_KEY] = {});
+    getSmithyContext = (context3) => context3[import_types.SMITHY_CONTEXT_KEY] || (context3[import_types.SMITHY_CONTEXT_KEY] = {});
   }
 });
 
@@ -8719,7 +8719,7 @@ var require_dist_cjs7 = __commonJS({
   "node_modules/@smithy/util-middleware/dist-cjs/index.js"(exports2) {
     "use strict";
     var types2 = require_dist_cjs();
-    var getSmithyContext9 = (context) => context[types2.SMITHY_CONTEXT_KEY] || (context[types2.SMITHY_CONTEXT_KEY] = {});
+    var getSmithyContext9 = (context3) => context3[types2.SMITHY_CONTEXT_KEY] || (context3[types2.SMITHY_CONTEXT_KEY] = {});
     var normalizeProvider4 = (input) => {
       if (typeof input === "function")
         return input;
@@ -8771,12 +8771,12 @@ var init_httpAuthSchemeMiddleware = __esm({
   "node_modules/@smithy/core/dist-es/middleware-http-auth-scheme/httpAuthSchemeMiddleware.js"() {
     import_util_middleware = __toESM(require_dist_cjs7());
     init_resolveAuthOptions();
-    httpAuthSchemeMiddleware = (config, mwOptions) => (next, context) => async (args) => {
-      const options = config.httpAuthSchemeProvider(await mwOptions.httpAuthSchemeParametersProvider(config, context, args.input));
+    httpAuthSchemeMiddleware = (config, mwOptions) => (next, context3) => async (args) => {
+      const options = config.httpAuthSchemeProvider(await mwOptions.httpAuthSchemeParametersProvider(config, context3, args.input));
       const authSchemePreference = config.authSchemePreference ? await config.authSchemePreference() : [];
       const resolvedOptions = resolveAuthOptions(options, authSchemePreference);
       const authSchemes = convertHttpAuthSchemesToMap(config.httpAuthSchemes);
-      const smithyContext = (0, import_util_middleware.getSmithyContext)(context);
+      const smithyContext = (0, import_util_middleware.getSmithyContext)(context3);
       const failureReasons = [];
       for (const option of resolvedOptions) {
         const scheme = authSchemes.get(option.schemeId);
@@ -8789,7 +8789,7 @@ var init_httpAuthSchemeMiddleware = __esm({
           failureReasons.push(`HttpAuthScheme \`${option.schemeId}\` did not have an IdentityProvider configured.`);
           continue;
         }
-        const { identityProperties = {}, signingProperties = {} } = option.propertiesExtractor?.(config, context) || {};
+        const { identityProperties = {}, signingProperties = {} } = option.propertiesExtractor?.(config, context3) || {};
         option.identityProperties = Object.assign(option.identityProperties || {}, identityProperties);
         option.signingProperties = Object.assign(option.signingProperties || {}, signingProperties);
         smithyContext.selectedHttpAuthScheme = {
@@ -8836,7 +8836,7 @@ var require_dist_cjs8 = __commonJS({
   "node_modules/@smithy/middleware-serde/dist-cjs/index.js"(exports2) {
     "use strict";
     var protocolHttp = require_dist_cjs2();
-    var deserializerMiddleware = (options, deserializer) => (next, context) => async (args) => {
+    var deserializerMiddleware = (options, deserializer) => (next, context3) => async (args) => {
       const { response } = await next(args);
       try {
         const parsed = await deserializer(response, options);
@@ -8853,10 +8853,10 @@ var require_dist_cjs8 = __commonJS({
           try {
             error2.message += "\n  " + hint;
           } catch (e3) {
-            if (!context.logger || context.logger?.constructor?.name === "NoOpLogger") {
+            if (!context3.logger || context3.logger?.constructor?.name === "NoOpLogger") {
               console.warn(hint);
             } else {
-              context.logger?.warn?.(hint);
+              context3.logger?.warn?.(hint);
             }
           }
           if (typeof error2.$responseBodyText !== "undefined") {
@@ -8886,9 +8886,9 @@ var require_dist_cjs8 = __commonJS({
         return k3.match(pattern);
       }) || [void 0, void 0])[1];
     };
-    var serializerMiddleware = (options, serializer) => (next, context) => async (args) => {
+    var serializerMiddleware = (options, serializer) => (next, context3) => async (args) => {
       const endpointConfig = options;
-      const endpoint = context.endpointV2?.url && endpointConfig.urlParser ? async () => endpointConfig.urlParser(context.endpointV2.url) : endpointConfig.endpoint;
+      const endpoint = context3.endpointV2?.url && endpointConfig.urlParser ? async () => endpointConfig.urlParser(context3.endpointV2.url) : endpointConfig.endpoint;
       if (!endpoint) {
         throw new Error("No valid endpoint provider available.");
       }
@@ -8971,11 +8971,11 @@ var init_httpSigningMiddleware = __esm({
     };
     defaultSuccessHandler = (httpResponse, signingProperties) => {
     };
-    httpSigningMiddleware = (config) => (next, context) => async (args) => {
+    httpSigningMiddleware = (config) => (next, context3) => async (args) => {
       if (!import_protocol_http.HttpRequest.isInstance(args.request)) {
         return next(args);
       }
-      const smithyContext = (0, import_util_middleware2.getSmithyContext)(context);
+      const smithyContext = (0, import_util_middleware2.getSmithyContext)(context3);
       const scheme = smithyContext.selectedHttpAuthScheme;
       if (!scheme) {
         throw new Error(`No HttpAuthScheme was selected: unable to sign request`);
@@ -10968,14 +10968,14 @@ var import_util_stream, collectBody;
 var init_collect_stream_body = __esm({
   "node_modules/@smithy/core/dist-es/submodules/protocols/collect-stream-body.js"() {
     import_util_stream = __toESM(require_dist_cjs18());
-    collectBody = async (streamBody = new Uint8Array(), context) => {
+    collectBody = async (streamBody = new Uint8Array(), context3) => {
       if (streamBody instanceof Uint8Array) {
         return import_util_stream.Uint8ArrayBlobAdapter.mutate(streamBody);
       }
       if (!streamBody) {
         return import_util_stream.Uint8ArrayBlobAdapter.mutate(new Uint8Array());
       }
-      const fromContext = context.streamCollector(streamBody);
+      const fromContext = context3.streamCollector(streamBody);
       return import_util_stream.Uint8ArrayBlobAdapter.mutate(await fromContext);
     };
   }
@@ -11005,83 +11005,16 @@ var init_deref = __esm({
   }
 });
 
-// node_modules/@smithy/core/dist-es/submodules/schema/TypeRegistry.js
-var TypeRegistry;
-var init_TypeRegistry = __esm({
-  "node_modules/@smithy/core/dist-es/submodules/schema/TypeRegistry.js"() {
-    TypeRegistry = class _TypeRegistry {
-      namespace;
-      schemas;
-      exceptions;
-      static registries = /* @__PURE__ */ new Map();
-      constructor(namespace, schemas = /* @__PURE__ */ new Map(), exceptions = /* @__PURE__ */ new Map()) {
-        this.namespace = namespace;
-        this.schemas = schemas;
-        this.exceptions = exceptions;
-      }
-      static for(namespace) {
-        if (!_TypeRegistry.registries.has(namespace)) {
-          _TypeRegistry.registries.set(namespace, new _TypeRegistry(namespace));
-        }
-        return _TypeRegistry.registries.get(namespace);
-      }
-      register(shapeId, schema) {
-        const qualifiedName = this.normalizeShapeId(shapeId);
-        this.schemas.set(qualifiedName, schema);
-      }
-      getSchema(shapeId) {
-        const id = this.normalizeShapeId(shapeId);
-        if (!this.schemas.has(id)) {
-          throw new Error(`@smithy/core/schema - schema not found for ${id}`);
-        }
-        return this.schemas.get(id);
-      }
-      registerError(es, ctor) {
-        this.exceptions.set(es, ctor);
-      }
-      getErrorCtor(es) {
-        return this.exceptions.get(es);
-      }
-      getBaseException() {
-        for (const [id, schema] of this.schemas.entries()) {
-          if (id.startsWith("smithy.ts.sdk.synthetic.") && id.endsWith("ServiceException")) {
-            return schema;
-          }
-        }
-        return void 0;
-      }
-      find(predicate) {
-        return [...this.schemas.values()].find(predicate);
-      }
-      clear() {
-        this.schemas.clear();
-        this.exceptions.clear();
-      }
-      normalizeShapeId(shapeId) {
-        if (shapeId.includes("#")) {
-          return shapeId;
-        }
-        return this.namespace + "#" + shapeId;
-      }
-      getNamespace(shapeId) {
-        return this.normalizeShapeId(shapeId).split("#")[0];
-      }
-    };
-  }
-});
-
 // node_modules/@smithy/core/dist-es/submodules/schema/schemas/Schema.js
 var Schema;
 var init_Schema = __esm({
   "node_modules/@smithy/core/dist-es/submodules/schema/schemas/Schema.js"() {
-    init_TypeRegistry();
     Schema = class {
       name;
       namespace;
       traits;
       static assign(instance, values2) {
         const schema = Object.assign(instance, values2);
-        TypeRegistry.for(schema.namespace).register(schema.name, schema);
         return schema;
       }
       static [Symbol.hasInstance](lhs) {
@@ -11212,7 +11145,7 @@ var init_OperationSchema = __esm({
 });
 
 // node_modules/@smithy/core/dist-es/submodules/schema/schemas/SimpleSchema.js
-var SimpleSchema, sim;
+var SimpleSchema, sim, simAdapter;
 var init_SimpleSchema = __esm({
   "node_modules/@smithy/core/dist-es/submodules/schema/schemas/SimpleSchema.js"() {
     init_Schema();
@@ -11229,6 +11162,12 @@ var init_SimpleSchema = __esm({
       traits,
       schemaRef
     });
+    simAdapter = (namespace, name14, traits, schemaRef) => Schema.assign(new SimpleSchema(), {
+      name: name14,
+      namespace,
+      traits,
+      schemaRef
+    });
   }
 });
 
@@ -11274,7 +11213,7 @@ function member(memberSchema, memberName) {
 function hydrate(ss) {
   const [id, ...rest] = ss;
   return {
-    [0]: sim,
+    [0]: simAdapter,
     [1]: list,
     [2]: map,
     [3]: struct,
@@ -11517,16 +11456,16 @@ var init_schemaDeserializationMiddleware = __esm({
     import_protocol_http2 = __toESM(require_dist_cjs2());
     import_util_middleware3 = __toESM(require_dist_cjs7());
     init_NormalizedSchema();
-    schemaDeserializationMiddleware = (config) => (next, context) => async (args) => {
+    schemaDeserializationMiddleware = (config) => (next, context3) => async (args) => {
       const { response } = await next(args);
-      let { operationSchema } = (0, import_util_middleware3.getSmithyContext)(context);
+      let { operationSchema } = (0, import_util_middleware3.getSmithyContext)(context3);
       if (isStaticSchema(operationSchema)) {
         operationSchema = hydrate(operationSchema);
       }
       try {
         const parsed = await config.protocol.deserializeResponse(operationSchema, {
           ...config,
-          ...context
+          ...context3
         }, response);
         return {
           response,
@@ -11541,10 +11480,10 @@ var init_schemaDeserializationMiddleware = __esm({
           try {
             error2.message += "\n  " + hint;
           } catch (e3) {
-            if (!context.logger || context.logger?.constructor?.name === "NoOpLogger") {
+            if (!context3.logger || context3.logger?.constructor?.name === "NoOpLogger") {
               console.warn(hint);
             } else {
-              context.logger?.warn?.(hint);
+              context3.logger?.warn?.(hint);
             }
           }
           if (typeof error2.$responseBodyText !== "undefined") {
@@ -11583,15 +11522,15 @@ 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);
+    schemaSerializationMiddleware = (config) => (next, context3) => async (args) => {
+      let { operationSchema } = (0, import_util_middleware4.getSmithyContext)(context3);
       if (isStaticSchema(operationSchema)) {
         operationSchema = hydrate(operationSchema);
       }
-      const endpoint = context.endpointV2?.url && config.urlParser ? async () => config.urlParser(context.endpointV2.url) : config.endpoint;
+      const endpoint = context3.endpointV2?.url && config.urlParser ? async () => config.urlParser(context3.endpointV2.url) : config.endpoint;
       const request = await config.protocol.serializeRequest(operationSchema, args.input, {
         ...config,
-        ...context,
+        ...context3,
         endpoint
       });
       return next({
@@ -11655,6 +11594,78 @@ var init_sentinels = __esm({
   }
 });
 
+// node_modules/@smithy/core/dist-es/submodules/schema/TypeRegistry.js
+var TypeRegistry;
+var init_TypeRegistry = __esm({
+  "node_modules/@smithy/core/dist-es/submodules/schema/TypeRegistry.js"() {
+    TypeRegistry = class _TypeRegistry {
+      namespace;
+      schemas;
+      exceptions;
+      static registries = /* @__PURE__ */ new Map();
+      constructor(namespace, schemas = /* @__PURE__ */ new Map(), exceptions = /* @__PURE__ */ new Map()) {
+        this.namespace = namespace;
+        this.schemas = schemas;
+        this.exceptions = exceptions;
+      }
+      static for(namespace) {
+        if (!_TypeRegistry.registries.has(namespace)) {
+          _TypeRegistry.registries.set(namespace, new _TypeRegistry(namespace));
+        }
+        return _TypeRegistry.registries.get(namespace);
+      }
+      register(shapeId, schema) {
+        const qualifiedName = this.normalizeShapeId(shapeId);
+        const registry = _TypeRegistry.for(qualifiedName.split("#")[0]);
+        registry.schemas.set(qualifiedName, schema);
+      }
+      getSchema(shapeId) {
+        const id = this.normalizeShapeId(shapeId);
+        if (!this.schemas.has(id)) {
+          throw new Error(`@smithy/core/schema - schema not found for ${id}`);
+        }
+        return this.schemas.get(id);
+      }
+      registerError(es, ctor) {
+        const $error = es;
+        const registry = _TypeRegistry.for($error[1]);
+        registry.schemas.set($error[1] + "#" + $error[2], $error);
+        registry.exceptions.set($error, ctor);
+      }
+      getErrorCtor(es) {
+        const $error = es;
+        const registry = _TypeRegistry.for($error[1]);
+        return registry.exceptions.get(es);
+      }
+      getBaseException() {
+        for (const exceptionKey of this.exceptions.keys()) {
+          if (Array.isArray(exceptionKey)) {
+            const [, ns, name14] = exceptionKey;
+            const id = ns + "#" + name14;
+            if (id.startsWith("smithy.ts.sdk.synthetic.") && id.endsWith("ServiceException")) {
+              return exceptionKey;
+            }
+          }
+        }
+        return void 0;
+      }
+      find(predicate) {
+        return [...this.schemas.values()].find(predicate);
+      }
+      clear() {
+        this.schemas.clear();
+        this.exceptions.clear();
+      }
+      normalizeShapeId(shapeId) {
+        if (shapeId.includes("#")) {
+          return shapeId;
+        }
+        return this.namespace + "#" + shapeId;
+      }
+    };
+  }
+});
+
 // node_modules/@smithy/core/dist-es/submodules/schema/index.js
 var schema_exports = {};
 __export(schema_exports, {
@@ -11679,6 +11690,7 @@ __export(schema_exports, {
   op: () => op,
   serializerMiddlewareOption: () => serializerMiddlewareOption2,
   sim: () => sim,
+  simAdapter: () => simAdapter,
   struct: () => struct,
   translateTraits: () => translateTraits
 });
@@ -12209,14 +12221,14 @@ function __esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, e
   var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
   var _2, done = false;
   for (var i3 = decorators.length - 1; i3 >= 0; i3--) {
-    var context = {};
-    for (var p3 in contextIn) context[p3] = p3 === "access" ? {} : contextIn[p3];
-    for (var p3 in contextIn.access) context.access[p3] = contextIn.access[p3];
-    context.addInitializer = function(f3) {
+    var context3 = {};
+    for (var p3 in contextIn) context3[p3] = p3 === "access" ? {} : contextIn[p3];
+    for (var p3 in contextIn.access) context3.access[p3] = contextIn.access[p3];
+    context3.addInitializer = function(f3) {
       if (done) throw new TypeError("Cannot add initializers after decoration has completed");
       extraInitializers.push(accept(f3 || null));
     };
-    var result = (0, decorators[i3])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+    var result = (0, decorators[i3])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context3);
     if (kind === "accessor") {
       if (result === void 0) continue;
       if (result === null || typeof result !== "object") throw new TypeError("Object expected");
@@ -13354,20 +13366,20 @@ var init_HttpProtocol = __esm({
       getDefaultContentType() {
         throw new Error(`@smithy/core/protocols - ${this.constructor.name} getDefaultContentType() implementation missing.`);
       }
-      async deserializeHttpMessage(schema, context, response, arg4, arg5) {
+      async deserializeHttpMessage(schema, context3, response, arg4, arg5) {
         void schema;
-        void context;
+        void context3;
         void response;
         void arg4;
         void arg5;
         return [];
       }
       getEventStreamMarshaller() {
-        const context = this.serdeContext;
-        if (!context.eventStreamMarshaller) {
+        const context3 = this.serdeContext;
+        if (!context3.eventStreamMarshaller) {
           throw new Error("@smithy/core - HttpProtocol: eventStreamMarshaller missing in serdeContext.");
         }
-        return context.eventStreamMarshaller;
+        return context3.eventStreamMarshaller;
       }
     };
   }
@@ -13385,14 +13397,14 @@ var init_HttpBindingProtocol = __esm({
     init_extended_encode_uri_component();
     init_HttpProtocol();
     HttpBindingProtocol = class extends HttpProtocol {
-      async serializeRequest(operationSchema, _input, context) {
+      async serializeRequest(operationSchema, _input, context3) {
         const input = {
           ..._input ?? {}
         };
         const serializer = this.serializer;
         const query2 = {};
         const headers = {};
-        const endpoint = await context.endpoint();
+        const endpoint = await context3.endpoint();
         const ns = NormalizedSchema.of(operationSchema?.input);
         const schema = ns.getSchema();
         let hasNonHttpBindingMember = false;
@@ -13517,16 +13529,16 @@ var init_HttpBindingProtocol = __esm({
           query2[traits.httpQuery] = serializer.flush();
         }
       }
-      async deserializeResponse(operationSchema, context, response) {
+      async deserializeResponse(operationSchema, context3, response) {
         const deserializer = this.deserializer;
         const ns = NormalizedSchema.of(operationSchema.output);
         const dataObject = {};
         if (response.statusCode >= 300) {
-          const bytes = await collectBody(response.body, context);
+          const bytes = await collectBody(response.body, context3);
           if (bytes.byteLength > 0) {
             Object.assign(dataObject, await deserializer.read(15, bytes));
           }
-          await this.handleError(operationSchema, context, response, dataObject, this.deserializeMetadata(response));
+          await this.handleError(operationSchema, context3, response, dataObject, this.deserializeMetadata(response));
           throw new Error("@smithy/core/protocols - HTTP Protocol error handler failed to throw.");
         }
         for (const header in response.headers) {
@@ -13534,9 +13546,9 @@ var init_HttpBindingProtocol = __esm({
           delete response.headers[header];
           response.headers[header.toLowerCase()] = value;
         }
-        const nonHttpBindingMembers = await this.deserializeHttpMessage(ns, context, response, dataObject);
+        const nonHttpBindingMembers = await this.deserializeHttpMessage(ns, context3, response, dataObject);
         if (nonHttpBindingMembers.length) {
-          const bytes = await collectBody(response.body, context);
+          const bytes = await collectBody(response.body, context3);
           if (bytes.byteLength > 0) {
             const dataFromBody = await deserializer.read(ns, bytes);
             for (const member2 of nonHttpBindingMembers) {
@@ -13547,7 +13559,7 @@ var init_HttpBindingProtocol = __esm({
         dataObject.$metadata = this.deserializeMetadata(response);
         return dataObject;
       }
-      async deserializeHttpMessage(schema, context, response, arg4, arg5) {
+      async deserializeHttpMessage(schema, context3, response, arg4, arg5) {
         let dataObject;
         if (arg4 instanceof Set) {
           dataObject = arg5;
@@ -13572,7 +13584,7 @@ var init_HttpBindingProtocol = __esm({
                 dataObject[memberName] = (0, import_util_stream2.sdkStreamMixin)(response.body);
               }
             } else if (response.body) {
-              const bytes = await collectBody(response.body, context);
+              const bytes = await collectBody(response.body, context3);
               if (bytes.byteLength > 0) {
                 dataObject[memberName] = await deserializer.read(memberSchema, bytes);
               }
@@ -13629,11 +13641,11 @@ var init_RpcProtocol = __esm({
     init_collect_stream_body();
     init_HttpProtocol();
     RpcProtocol = class extends HttpProtocol {
-      async serializeRequest(operationSchema, input, context) {
+      async serializeRequest(operationSchema, input, context3) {
         const serializer = this.serializer;
         const query2 = {};
         const headers = {};
-        const endpoint = await context.endpoint();
+        const endpoint = await context3.endpoint();
         const ns = NormalizedSchema.of(operationSchema?.input);
         const schema = ns.getSchema();
         let payload2;
@@ -13682,16 +13694,16 @@ var init_RpcProtocol = __esm({
         request.method = "POST";
         return request;
       }
-      async deserializeResponse(operationSchema, context, response) {
+      async deserializeResponse(operationSchema, context3, response) {
         const deserializer = this.deserializer;
         const ns = NormalizedSchema.of(operationSchema.output);
         const dataObject = {};
         if (response.statusCode >= 300) {
-          const bytes = await collectBody(response.body, context);
+          const bytes = await collectBody(response.body, context3);
           if (bytes.byteLength > 0) {
             Object.assign(dataObject, await deserializer.read(15, bytes));
           }
-          await this.handleError(operationSchema, context, response, dataObject, this.deserializeMetadata(response));
+          await this.handleError(operationSchema, context3, response, dataObject, this.deserializeMetadata(response));
           throw new Error("@smithy/core/protocols - RPC Protocol error handler failed to throw.");
         }
         for (const header in response.headers) {
@@ -13707,7 +13719,7 @@ var init_RpcProtocol = __esm({
             initialResponseContainer: dataObject
           });
         } else {
-          const bytes = await collectBody(response.body, context);
+          const bytes = await collectBody(response.body, context3);
           if (bytes.byteLength > 0) {
             Object.assign(dataObject, await deserializer.read(ns, bytes));
           }
@@ -13740,8 +13752,8 @@ var init_resolve_path = __esm({
 });
 
 // node_modules/@smithy/core/dist-es/submodules/protocols/requestBuilder.js
-function requestBuilder(input, context) {
-  return new RequestBuilder(input, context);
+function requestBuilder(input, context3) {
+  return new RequestBuilder(input, context3);
 }
 var import_protocol_http6, RequestBuilder;
 var init_requestBuilder = __esm({
@@ -13758,9 +13770,9 @@ var init_requestBuilder = __esm({
       body = null;
       hostname = "";
       resolvePathStack = [];
-      constructor(input, context) {
+      constructor(input, context3) {
         this.input = input;
-        this.context = context;
+        this.context = context3;
       }
       async build() {
         const { hostname, protocol = "https", port, path: basePath } = await this.context.endpoint();
@@ -14129,15 +14141,15 @@ var init_requestBuilder2 = __esm({
 });
 
 // node_modules/@smithy/core/dist-es/setFeature.js
-function setFeature(context, feature, value) {
-  if (!context.__smithy_context) {
-    context.__smithy_context = {
+function setFeature(context3, feature, value) {
+  if (!context3.__smithy_context) {
+    context3.__smithy_context = {
       features: {}
     };
-  } else if (!context.__smithy_context.features) {
-    context.__smithy_context.features = {};
+  } else if (!context3.__smithy_context.features) {
+    context3.__smithy_context.features = {};
   }
-  context.__smithy_context.features[feature] = value;
+  context3.__smithy_context.features[feature] = value;
 }
 var init_setFeature = __esm({
   "node_modules/@smithy/core/dist-es/setFeature.js"() {
@@ -15289,15 +15301,15 @@ var init_setCredentialFeature = __esm({
 });
 
 // node_modules/@aws-sdk/core/dist-es/submodules/client/setFeature.js
-function setFeature2(context, feature, value) {
-  if (!context.__aws_sdk_context) {
-    context.__aws_sdk_context = {
+function setFeature2(context3, feature, value) {
+  if (!context3.__aws_sdk_context) {
+    context3.__aws_sdk_context = {
       features: {}
     };
-  } else if (!context.__aws_sdk_context.features) {
-    context.__aws_sdk_context.features = {};
+  } else if (!context3.__aws_sdk_context.features) {
+    context3.__aws_sdk_context.features = {};
   }
-  context.__aws_sdk_context.features[feature] = value;
+  context3.__aws_sdk_context.features[feature] = value;
 }
 var init_setFeature2 = __esm({
   "node_modules/@aws-sdk/core/dist-es/submodules/client/setFeature.js"() {
@@ -15398,9 +15410,9 @@ var init_AwsSdkSigV4Signer = __esm({
       return property2;
     };
     validateSigningProperties = async (signingProperties) => {
-      const context = throwSigningPropertyError("context", signingProperties.context);
+      const context3 = throwSigningPropertyError("context", signingProperties.context);
       const config = throwSigningPropertyError("config", signingProperties.config);
-      const authScheme = context.endpointV2?.properties?.authSchemes?.[0];
+      const authScheme = context3.endpointV2?.properties?.authSchemes?.[0];
       const signerFunction = throwSigningPropertyError("signer", config.signer);
       const signer = await signerFunction(authScheme);
       const signingRegion = signingProperties?.signingRegion;
@@ -17258,8 +17270,8 @@ var init_SmithyRpcV2CborProtocol = __esm({
       getPayloadCodec() {
         return this.codec;
       }
-      async serializeRequest(operationSchema, input, context) {
-        const request = await super.serializeRequest(operationSchema, input, context);
+      async serializeRequest(operationSchema, input, context3) {
+        const request = await super.serializeRequest(operationSchema, input, context3);
         Object.assign(request.headers, {
           "content-type": this.getDefaultContentType(),
           "smithy-protocol": "rpc-v2-cbor",
@@ -17278,7 +17290,7 @@ var init_SmithyRpcV2CborProtocol = __esm({
           } catch (e3) {
           }
         }
-        const { service, operation } = (0, import_util_middleware5.getSmithyContext)(context);
+        const { service, operation } = (0, import_util_middleware5.getSmithyContext)(context3);
         const path7 = `/service/${service}/operation/${operation}`;
         if (request.path.endsWith("/")) {
           request.path += path7.slice(1);
@@ -17287,10 +17299,10 @@ var init_SmithyRpcV2CborProtocol = __esm({
         }
         return request;
       }
-      async deserializeResponse(operationSchema, context, response) {
-        return super.deserializeResponse(operationSchema, context, response);
+      async deserializeResponse(operationSchema, context3, response) {
+        return super.deserializeResponse(operationSchema, context3, response);
       }
-      async handleError(operationSchema, context, response, dataObject, metadata) {
+      async handleError(operationSchema, context3, response, dataObject, metadata) {
         const errorName = loadSmithyRpcV2CborErrorCode(response, dataObject) ?? "Unknown";
         let namespace = this.options.defaultNamespace;
         if (errorName.includes("#")) {
@@ -17451,14 +17463,14 @@ var init_AwsSmithyRpcV2CborProtocol = __esm({
         super({ defaultNamespace });
         this.awsQueryCompatible = !!awsQueryCompatible;
       }
-      async serializeRequest(operationSchema, input, context) {
-        const request = await super.serializeRequest(operationSchema, input, context);
+      async serializeRequest(operationSchema, input, context3) {
+        const request = await super.serializeRequest(operationSchema, input, context3);
         if (this.awsQueryCompatible) {
           request.headers["x-amzn-query-mode"] = "true";
         }
         return request;
       }
-      async handleError(operationSchema, context, response, dataObject, metadata) {
+      async handleError(operationSchema, context3, response, dataObject, metadata) {
         if (this.awsQueryCompatible) {
           this.mixin.setQueryCompatError(dataObject, response);
         }
@@ -17558,9 +17570,9 @@ var init_ConfigurableSerdeContext = __esm({
 });
 
 // node_modules/@aws-sdk/core/dist-es/submodules/protocols/json/jsonReviver.js
-function jsonReviver(key, value, context) {
-  if (context?.source) {
-    const numericString = context.source;
+function jsonReviver(key, value, context3) {
+  if (context3?.source) {
+    const numericString = context3.source;
     if (typeof value === "number") {
       if (value > Number.MAX_SAFE_INTEGER || value < Number.MIN_SAFE_INTEGER || numericString !== String(value)) {
         const isFractional = numericString.includes(".");
@@ -17823,9 +17835,9 @@ var require_dist_cjs26 = __commonJS({
             identifyOnResolve = toggle;
           return identifyOnResolve;
         },
-        resolve: (handler, context) => {
+        resolve: (handler, context3) => {
           for (const middleware of getMiddlewareList().map((entry) => entry.middleware).reverse()) {
-            handler = middleware(handler, context);
+            handler = middleware(handler, context3);
           }
           if (identifyOnResolve) {
             console.log(stack.identify());
@@ -18425,7 +18437,7 @@ var init_common2 = __esm({
   "node_modules/@aws-sdk/core/dist-es/submodules/protocols/common.js"() {
     import_smithy_client = __toESM(require_dist_cjs27());
     import_util_utf86 = __toESM(require_dist_cjs11());
-    collectBodyString = (streamBody, context) => (0, import_smithy_client.collectBody)(streamBody, context).then((body) => (context?.utf8Encoder ?? import_util_utf86.toUtf8)(body));
+    collectBodyString = (streamBody, context3) => (0, import_smithy_client.collectBody)(streamBody, context3).then((body) => (context3?.utf8Encoder ?? import_util_utf86.toUtf8)(body));
   }
 });
 
@@ -18434,7 +18446,7 @@ var parseJsonBody, parseJsonErrorBody, loadRestJsonErrorCode;
 var init_parseJsonBody = __esm({
   "node_modules/@aws-sdk/core/dist-es/submodules/protocols/json/parseJsonBody.js"() {
     init_common2();
-    parseJsonBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
+    parseJsonBody = (streamBody, context3) => collectBodyString(streamBody, context3).then((encoded) => {
       if (encoded.length) {
         try {
           return JSON.parse(encoded);
@@ -18449,8 +18461,8 @@ var init_parseJsonBody = __esm({
       }
       return {};
     });
-    parseJsonErrorBody = async (errorBody, context) => {
-      const value = await parseJsonBody(errorBody, context);
+    parseJsonErrorBody = async (errorBody, context3) => {
+      const value = await parseJsonBody(errorBody, context3);
       value.message = value.message ?? value.Message;
       return value;
     };
@@ -18861,8 +18873,8 @@ var init_AwsJsonRpcProtocol = __esm({
         this.deserializer = this.codec.createDeserializer();
         this.awsQueryCompatible = !!awsQueryCompatible;
       }
-      async serializeRequest(operationSchema, input, context) {
-        const request = await super.serializeRequest(operationSchema, input, context);
+      async serializeRequest(operationSchema, input, context3) {
+        const request = await super.serializeRequest(operationSchema, input, context3);
         if (!request.path.endsWith("/")) {
           request.path += "/";
         }
@@ -18881,7 +18893,7 @@ var init_AwsJsonRpcProtocol = __esm({
       getPayloadCodec() {
         return this.codec;
       }
-      async handleError(operationSchema, context, response, dataObject, metadata) {
+      async handleError(operationSchema, context3, response, dataObject, metadata) {
         if (this.awsQueryCompatible) {
           this.mixin.setQueryCompatError(dataObject, response);
         }
@@ -19000,8 +19012,8 @@ var init_AwsRestJsonProtocol = __esm({
         this.codec.setSerdeContext(serdeContext);
         super.setSerdeContext(serdeContext);
       }
-      async serializeRequest(operationSchema, input, context) {
-        const request = await super.serializeRequest(operationSchema, input, context);
+      async serializeRequest(operationSchema, input, context3) {
+        const request = await super.serializeRequest(operationSchema, input, context3);
         const inputSchema = NormalizedSchema.of(operationSchema.input);
         if (!request.headers["content-type"]) {
           const contentType = this.mixin.resolveRestContentType(this.getDefaultContentType(), inputSchema);
@@ -19014,14 +19026,14 @@ var init_AwsRestJsonProtocol = __esm({
         }
         return request;
       }
-      async handleError(operationSchema, context, response, dataObject, metadata) {
+      async handleError(operationSchema, context3, response, dataObject, metadata) {
         const errorIdentifier = loadRestJsonErrorCode(response, dataObject) ?? "Unknown";
         const { errorSchema, errorMetadata } = await this.mixin.getErrorSchemaOrThrowBaseException(errorIdentifier, this.options.defaultNamespace, response, dataObject, metadata);
         const ns = NormalizedSchema.of(errorSchema);
         const message = dataObject.message ?? dataObject.Message ?? "Unknown";
         const ErrorCtor = TypeRegistry.for(errorSchema.namespace).getErrorCtor(errorSchema) ?? Error;
         const exception = new ErrorCtor(message);
-        await this.deserializeHttpMessage(errorSchema, context, response, dataObject);
+        await this.deserializeHttpMessage(errorSchema, context3, response, dataObject);
         const output = {};
         for (const [name14, member2] of ns.structIterator()) {
           const target = member2.getMergedTraits().jsonName ?? name14;
@@ -20371,8 +20383,8 @@ var init_AwsQueryProtocol = __esm({
       getPayloadCodec() {
         throw new Error("AWSQuery protocol has no payload codec.");
       }
-      async serializeRequest(operationSchema, input, context) {
-        const request = await super.serializeRequest(operationSchema, input, context);
+      async serializeRequest(operationSchema, input, context3) {
+        const request = await super.serializeRequest(operationSchema, input, context3);
         if (!request.path.endsWith("/")) {
           request.path += "/";
         }
@@ -20389,16 +20401,16 @@ var init_AwsQueryProtocol = __esm({
         }
         return request;
       }
-      async deserializeResponse(operationSchema, context, response) {
+      async deserializeResponse(operationSchema, context3, response) {
         const deserializer = this.deserializer;
         const ns = NormalizedSchema.of(operationSchema.output);
         const dataObject = {};
         if (response.statusCode >= 300) {
-          const bytes2 = await collectBody(response.body, context);
+          const bytes2 = await collectBody(response.body, context3);
           if (bytes2.byteLength > 0) {
             Object.assign(dataObject, await deserializer.read(15, bytes2));
           }
-          await this.handleError(operationSchema, context, response, dataObject, this.deserializeMetadata(response));
+          await this.handleError(operationSchema, context3, response, dataObject, this.deserializeMetadata(response));
         }
         for (const header in response.headers) {
           const value = response.headers[header];
@@ -20407,7 +20419,7 @@ var init_AwsQueryProtocol = __esm({
         }
         const shortName = operationSchema.name.split("#")[1] ?? operationSchema.name;
         const awsQueryResultKey = ns.isStructSchema() && this.useNestedResult() ? shortName + "Result" : void 0;
-        const bytes = await collectBody(response.body, context);
+        const bytes = await collectBody(response.body, context3);
         if (bytes.byteLength > 0) {
           Object.assign(dataObject, await deserializer.read(ns, bytes, awsQueryResultKey));
         }
@@ -20420,7 +20432,7 @@ var init_AwsQueryProtocol = __esm({
       useNestedResult() {
         return true;
       }
-      async handleError(operationSchema, context, response, dataObject, metadata) {
+      async handleError(operationSchema, context3, response, dataObject, metadata) {
         const errorIdentifier = this.loadQueryErrorCode(response, dataObject) ?? "Unknown";
         const errorData = this.loadQueryError(dataObject);
         const message = this.loadQueryErrorMessage(dataObject);
@@ -20501,7 +20513,7 @@ var init_parseXmlBody = __esm({
     import_xml_builder2 = __toESM(require_dist_cjs28());
     import_smithy_client5 = __toESM(require_dist_cjs27());
     init_common2();
-    parseXmlBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
+    parseXmlBody = (streamBody, context3) => collectBodyString(streamBody, context3).then((encoded) => {
       if (encoded.length) {
         let parsedObj;
         try {
@@ -20525,8 +20537,8 @@ var init_parseXmlBody = __esm({
       }
       return {};
     });
-    parseXmlErrorBody = async (errorBody, context) => {
-      const value = await parseXmlBody(errorBody, context);
+    parseXmlErrorBody = async (errorBody, context3) => {
+      const value = await parseXmlBody(errorBody, context3);
       if (value.Error) {
         value.Error.message = value.Error.message ?? value.Error.Message;
       }
@@ -20871,8 +20883,8 @@ var init_AwsRestXmlProtocol = __esm({
       getShapeId() {
         return "aws.protocols#restXml";
       }
-      async serializeRequest(operationSchema, input, context) {
-        const request = await super.serializeRequest(operationSchema, input, context);
+      async serializeRequest(operationSchema, input, context3) {
+        const request = await super.serializeRequest(operationSchema, input, context3);
         const inputSchema = NormalizedSchema.of(operationSchema.input);
         if (!request.headers["content-type"]) {
           const contentType = this.mixin.resolveRestContentType(this.getDefaultContentType(), inputSchema);
@@ -20887,17 +20899,17 @@ var init_AwsRestXmlProtocol = __esm({
         }
         return request;
       }
-      async deserializeResponse(operationSchema, context, response) {
-        return super.deserializeResponse(operationSchema, context, response);
+      async deserializeResponse(operationSchema, context3, response) {
+        return super.deserializeResponse(operationSchema, context3, response);
       }
-      async handleError(operationSchema, context, response, dataObject, metadata) {
+      async handleError(operationSchema, context3, response, dataObject, metadata) {
         const errorIdentifier = loadRestXmlErrorCode(response, dataObject) ?? "Unknown";
         const { errorSchema, errorMetadata } = await this.mixin.getErrorSchemaOrThrowBaseException(errorIdentifier, this.options.defaultNamespace, response, dataObject, metadata);
         const ns = NormalizedSchema.of(errorSchema);
         const message = dataObject.Error?.message ?? dataObject.Error?.Message ?? dataObject.message ?? dataObject.Message ?? "Unknown";
         const ErrorCtor = TypeRegistry.for(errorSchema.namespace).getErrorCtor(errorSchema) ?? Error;
         const exception = new ErrorCtor(message);
-        await this.deserializeHttpMessage(errorSchema, context, response, dataObject);
+        await this.deserializeHttpMessage(errorSchema, context3, response, dataObject);
         const output = {};
         for (const [name14, member2] of ns.structIterator()) {
           const target = member2.getMergedTraits().xmlName ?? name14;
@@ -21026,48 +21038,48 @@ var require_dist_cjs29 = __commonJS({
       });
     }
     var ACCOUNT_ID_ENDPOINT_REGEX = /\d{12}\.ddb/;
-    async function checkFeatures(context, config, args) {
+    async function checkFeatures(context3, config, args) {
       const request = args.request;
       if (request?.headers?.["smithy-protocol"] === "rpc-v2-cbor") {
-        core$1.setFeature(context, "PROTOCOL_RPC_V2_CBOR", "M");
+        core$1.setFeature(context3, "PROTOCOL_RPC_V2_CBOR", "M");
       }
       if (typeof config.retryStrategy === "function") {
         const retryStrategy = await config.retryStrategy();
         if (typeof retryStrategy.acquireInitialRetryToken === "function") {
           if (retryStrategy.constructor?.name?.includes("Adaptive")) {
-            core$1.setFeature(context, "RETRY_MODE_ADAPTIVE", "F");
+            core$1.setFeature(context3, "RETRY_MODE_ADAPTIVE", "F");
           } else {
-            core$1.setFeature(context, "RETRY_MODE_STANDARD", "E");
+            core$1.setFeature(context3, "RETRY_MODE_STANDARD", "E");
           }
         } else {
-          core$1.setFeature(context, "RETRY_MODE_LEGACY", "D");
+          core$1.setFeature(context3, "RETRY_MODE_LEGACY", "D");
         }
       }
       if (typeof config.accountIdEndpointMode === "function") {
-        const endpointV2 = context.endpointV2;
+        const endpointV2 = context3.endpointV2;
         if (String(endpointV2?.url?.hostname).match(ACCOUNT_ID_ENDPOINT_REGEX)) {
-          core$1.setFeature(context, "ACCOUNT_ID_ENDPOINT", "O");
+          core$1.setFeature(context3, "ACCOUNT_ID_ENDPOINT", "O");
         }
         switch (await config.accountIdEndpointMode?.()) {
           case "disabled":
-            core$1.setFeature(context, "ACCOUNT_ID_MODE_DISABLED", "Q");
+            core$1.setFeature(context3, "ACCOUNT_ID_MODE_DISABLED", "Q");
             break;
           case "preferred":
-            core$1.setFeature(context, "ACCOUNT_ID_MODE_PREFERRED", "P");
+            core$1.setFeature(context3, "ACCOUNT_ID_MODE_PREFERRED", "P");
             break;
           case "required":
-            core$1.setFeature(context, "ACCOUNT_ID_MODE_REQUIRED", "R");
+            core$1.setFeature(context3, "ACCOUNT_ID_MODE_REQUIRED", "R");
             break;
         }
       }
-      const identity2 = context.__smithy_context?.selectedHttpAuthScheme?.identity;
+      const identity2 = context3.__smithy_context?.selectedHttpAuthScheme?.identity;
       if (identity2?.$source) {
         const credentials = identity2;
         if (credentials.accountId) {
-          core$1.setFeature(context, "RESOLVED_ACCOUNT_ID", "T");
+          core$1.setFeature(context3, "RESOLVED_ACCOUNT_ID", "T");
         }
         for (const [key, value] of Object.entries(credentials.$source ?? {})) {
-          core$1.setFeature(context, key, value);
+          core$1.setFeature(context3, key, value);
         }
       }
     }
@@ -21095,17 +21107,17 @@ var require_dist_cjs29 = __commonJS({
       }
       return buffer;
     }
-    var userAgentMiddleware = (options) => (next, context) => async (args) => {
+    var userAgentMiddleware = (options) => (next, context3) => async (args) => {
       const { request } = args;
       if (!protocolHttp.HttpRequest.isInstance(request)) {
         return next(args);
       }
       const { headers } = request;
-      const userAgent = context?.userAgent?.map(escapeUserAgent) || [];
+      const userAgent = context3?.userAgent?.map(escapeUserAgent) || [];
       const defaultUserAgent = (await options.defaultUserAgentProvider()).map(escapeUserAgent);
-      await checkFeatures(context, options, args);
-      const awsContext = context;
-      defaultUserAgent.push(`m/${encodeFeatures(Object.assign({}, context.__smithy_context?.features, awsContext.__aws_sdk_context?.features))}`);
+      await checkFeatures(context3, options, args);
+      const awsContext = context3;
+      defaultUserAgent.push(`m/${encodeFeatures(Object.assign({}, context3.__smithy_context?.features, awsContext.__aws_sdk_context?.features))}`);
       const customUserAgent = options?.customUserAgent?.map(escapeUserAgent) || [];
       const appId = await options.userAgentAppId();
       if (appId) {
@@ -22437,7 +22449,7 @@ var require_dist_cjs37 = __commonJS({
         this.eventStreamCodec = new eventstreamCodec.EventStreamCodec(options.utf8Encoder, options.utf8Decoder);
         this.systemClockOffsetProvider = async () => options.systemClockOffset ?? 0;
       }
-      async handle(next, args, context = {}) {
+      async handle(next, args, context3 = {}) {
         const request = args.request;
         const { body: payload2, headers, query: query2 } = request;
         if (!(payload2 instanceof ReadableStream)) {
@@ -23421,7 +23433,7 @@ var require_dist_cjs44 = __commonJS({
       }
       return urlParser.parseUrl(endpoint);
     };
-    var getEndpointFromInstructions = async (commandInput, instructionsSupplier, clientConfig, context) => {
+    var getEndpointFromInstructions = async (commandInput, instructionsSupplier, clientConfig, context3) => {
       if (!clientConfig.isCustomEndpoint) {
         let endpointFromConfig;
         if (clientConfig.serviceConfiguredEndpoint) {
@@ -23438,7 +23450,7 @@ var require_dist_cjs44 = __commonJS({
       if (typeof clientConfig.endpointProvider !== "function") {
         throw new Error("config.endpointProvider is not set.");
       }
-      const endpoint = clientConfig.endpointProvider(endpointParams, context);
+      const endpoint = clientConfig.endpointProvider(endpointParams, context3);
       return endpoint;
     };
     var resolveParams = async (commandInput, instructionsSupplier, clientConfig) => {
@@ -23472,22 +23484,22 @@ var require_dist_cjs44 = __commonJS({
       return endpointParams;
     };
     var endpointMiddleware = ({ config, instructions }) => {
-      return (next, context) => async (args) => {
+      return (next, context3) => async (args) => {
         if (config.isCustomEndpoint) {
-          core.setFeature(context, "ENDPOINT_OVERRIDE", "N");
+          core.setFeature(context3, "ENDPOINT_OVERRIDE", "N");
         }
         const endpoint = await getEndpointFromInstructions(args.input, {
           getEndpointParameterInstructions() {
             return instructions;
           }
-        }, { ...config }, context);
-        context.endpointV2 = endpoint;
-        context.authSchemes = endpoint.properties?.authSchemes;
-        const authScheme = context.authSchemes?.[0];
+        }, { ...config }, context3);
+        context3.endpointV2 = endpoint;
+        context3.authSchemes = endpoint.properties?.authSchemes;
+        const authScheme = context3.authSchemes?.[0];
         if (authScheme) {
-          context["signing_region"] = authScheme.signingRegion;
-          context["signing_service"] = authScheme.signingName;
-          const smithyContext = utilMiddleware.getSmithyContext(context);
+          context3["signing_region"] = authScheme.signingRegion;
+          context3["signing_service"] = authScheme.signingName;
+          const smithyContext = utilMiddleware.getSmithyContext(context3);
           const httpAuthOption = smithyContext?.selectedHttpAuthScheme?.httpAuthOption;
           if (httpAuthOption) {
             httpAuthOption.signingProperties = Object.assign(httpAuthOption.signingProperties || {}, {
@@ -24136,12 +24148,12 @@ var require_dist_cjs47 = __commonJS({
         clientStack.addRelativeTo(omitRetryHeadersMiddleware(), omitRetryHeadersMiddlewareOptions);
       }
     });
-    var retryMiddleware = (options) => (next, context) => async (args) => {
+    var retryMiddleware = (options) => (next, context3) => async (args) => {
       let retryStrategy = await options.retryStrategy();
       const maxAttempts = await options.maxAttempts();
       if (isRetryStrategyV2(retryStrategy)) {
         retryStrategy = retryStrategy;
-        let retryToken = await retryStrategy.acquireInitialRetryToken(context["partition_id"]);
+        let retryToken = await retryStrategy.acquireInitialRetryToken(context3["partition_id"]);
         let lastError = new Error();
         let attempts = 0;
         let totalRetryDelay = 0;
@@ -24164,7 +24176,7 @@ var require_dist_cjs47 = __commonJS({
             const retryErrorInfo = getRetryErrorInfo(e3);
             lastError = asSdkError(e3);
             if (isRequest && isStreamingPayload.isStreamingPayload(request)) {
-              (context.logger instanceof smithyClient.NoOpLogger ? console : context.logger)?.warn("An error was encountered in a non-retryable streaming request.");
+              (context3.logger instanceof smithyClient.NoOpLogger ? console : context3.logger)?.warn("An error was encountered in a non-retryable streaming request.");
               throw lastError;
             }
             try {
@@ -24186,7 +24198,7 @@ var require_dist_cjs47 = __commonJS({
       } else {
         retryStrategy = retryStrategy;
         if (retryStrategy?.mode)
-          context.userAgent = [...context.userAgent || [], ["cfg/retry-mode", retryStrategy.mode]];
+          context3.userAgent = [...context3.userAgent || [], ["cfg/retry-mode", retryStrategy.mode]];
         return retryStrategy.retry(next, args);
       }
     };
@@ -24266,9 +24278,9 @@ var require_httpAuthSchemeProvider = __commonJS({
     var core_1 = (init_dist_es2(), __toCommonJS(dist_es_exports2));
     var core_2 = (init_dist_es(), __toCommonJS(dist_es_exports));
     var util_middleware_1 = require_dist_cjs7();
-    var defaultBedrockRuntimeHttpAuthSchemeParametersProvider = async (config, context, input) => {
+    var defaultBedrockRuntimeHttpAuthSchemeParametersProvider = async (config, context3, input) => {
       return {
-        operation: (0, util_middleware_1.getSmithyContext)(context).operation,
+        operation: (0, util_middleware_1.getSmithyContext)(context3).operation,
         region: await (0, util_middleware_1.normalizeProvider)(config.region)() || (() => {
           throw new Error("expected `region` to be configured for `aws.auth#sigv4`");
         })()
@@ -24282,10 +24294,10 @@ var require_httpAuthSchemeProvider = __commonJS({
           name: "bedrock",
           region: authParameters.region
         },
-        propertiesExtractor: (config, context) => ({
+        propertiesExtractor: (config, context3) => ({
           signingProperties: {
             config,
-            context
+            context: context3
           }
         })
       };
@@ -24293,7 +24305,7 @@ var require_httpAuthSchemeProvider = __commonJS({
     function createSmithyApiHttpBearerAuthHttpAuthOption(authParameters) {
       return {
         schemeId: "smithy.api#httpBearerAuth",
-        propertiesExtractor: ({ profile, filepath, configFilepath, ignoreCache }, context) => ({
+        propertiesExtractor: ({ profile, filepath, configFilepath, ignoreCache }, context3) => ({
           identityProperties: {
             profile,
             filepath,
@@ -25039,10 +25051,10 @@ function createAwsAuthSigv4HttpAuthOption(authParameters) {
       name: "sso-oauth",
       region: authParameters.region
     },
-    propertiesExtractor: (config, context) => ({
+    propertiesExtractor: (config, context3) => ({
       signingProperties: {
         config,
-        context
+        context: context3
       }
     })
   };
@@ -25057,9 +25069,9 @@ var init_httpAuthSchemeProvider = __esm({
   "node_modules/@aws-sdk/nested-clients/dist-es/submodules/sso-oidc/auth/httpAuthSchemeProvider.js"() {
     init_dist_es2();
     import_util_middleware6 = __toESM(require_dist_cjs7());
-    defaultSSOOIDCHttpAuthSchemeParametersProvider = async (config, context, input) => {
+    defaultSSOOIDCHttpAuthSchemeParametersProvider = async (config, context3, input) => {
       return {
-        operation: (0, import_util_middleware6.getSmithyContext)(context).operation,
+        operation: (0, import_util_middleware6.getSmithyContext)(context3).operation,
         region: await (0, import_util_middleware6.normalizeProvider)(config.region)() || (() => {
           throw new Error("expected `region` to be configured for `aws.auth#sigv4`");
         })()
@@ -25405,10 +25417,10 @@ var init_endpointResolver = __esm({
       size: 50,
       params: ["Endpoint", "Region", "UseDualStack", "UseFIPS"]
     });
-    defaultEndpointResolver = (endpointParams, context = {}) => {
+    defaultEndpointResolver = (endpointParams, context3 = {}) => {
       return cache.get(endpointParams, () => (0, import_util_endpoints2.resolveEndpoint)(ruleSet, {
         endpointParams,
-        logger: context.logger
+        logger: context3.logger
       }));
     };
     import_util_endpoints2.customEndpointFunctions.aws = import_util_endpoints.awsEndpointFunctions;
@@ -26018,8 +26030,8 @@ var init_Aws_restJson1 = __esm({
     import_smithy_client14 = __toESM(require_dist_cjs27());
     init_models_0();
     init_SSOOIDCServiceException();
-    se_CreateTokenCommand = async (input, context) => {
-      const b3 = requestBuilder(input, context);
+    se_CreateTokenCommand = async (input, context3) => {
+      const b3 = requestBuilder(input, context3);
       const headers = {
         "content-type": "application/json"
       };
@@ -26039,14 +26051,14 @@ var init_Aws_restJson1 = __esm({
       b3.m("POST").h(headers).b(body);
       return b3.build();
     };
-    de_CreateTokenCommand = async (output, context) => {
+    de_CreateTokenCommand = async (output, context3) => {
       if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
+        return de_CommandError(output, context3);
       }
       const contents = (0, import_smithy_client14.map)({
         $metadata: deserializeMetadata(output)
       });
-      const data2 = (0, import_smithy_client14.expectNonNull)((0, import_smithy_client14.expectObject)(await parseJsonBody(output.body, context)), "body");
+      const data2 = (0, import_smithy_client14.expectNonNull)((0, import_smithy_client14.expectObject)(await parseJsonBody(output.body, context3)), "body");
       const doc = (0, import_smithy_client14.take)(data2, {
         accessToken: import_smithy_client14.expectString,
         expiresIn: import_smithy_client14.expectInt32,
@@ -26057,46 +26069,46 @@ var init_Aws_restJson1 = __esm({
       Object.assign(contents, doc);
       return contents;
     };
-    de_CommandError = async (output, context) => {
+    de_CommandError = async (output, context3) => {
       const parsedOutput = {
         ...output,
-        body: await parseJsonErrorBody(output.body, context)
+        body: await parseJsonErrorBody(output.body, context3)
       };
       const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
       switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.ssooidc#AccessDeniedException":
-          throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+          throw await de_AccessDeniedExceptionRes(parsedOutput, context3);
         case "AuthorizationPendingException":
         case "com.amazonaws.ssooidc#AuthorizationPendingException":
-          throw await de_AuthorizationPendingExceptionRes(parsedOutput, context);
+          throw await de_AuthorizationPendingExceptionRes(parsedOutput, context3);
         case "ExpiredTokenException":
         case "com.amazonaws.ssooidc#ExpiredTokenException":
-          throw await de_ExpiredTokenExceptionRes(parsedOutput, context);
+          throw await de_ExpiredTokenExceptionRes(parsedOutput, context3);
         case "InternalServerException":
         case "com.amazonaws.ssooidc#InternalServerException":
-          throw await de_InternalServerExceptionRes(parsedOutput, context);
+          throw await de_InternalServerExceptionRes(parsedOutput, context3);
         case "InvalidClientException":
         case "com.amazonaws.ssooidc#InvalidClientException":
-          throw await de_InvalidClientExceptionRes(parsedOutput, context);
+          throw await de_InvalidClientExceptionRes(parsedOutput, context3);
         case "InvalidGrantException":
         case "com.amazonaws.ssooidc#InvalidGrantException":
-          throw await de_InvalidGrantExceptionRes(parsedOutput, context);
+          throw await de_InvalidGrantExceptionRes(parsedOutput, context3);
         case "InvalidRequestException":
         case "com.amazonaws.ssooidc#InvalidRequestException":
-          throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+          throw await de_InvalidRequestExceptionRes(parsedOutput, context3);
         case "InvalidScopeException":
         case "com.amazonaws.ssooidc#InvalidScopeException":
-          throw await de_InvalidScopeExceptionRes(parsedOutput, context);
+          throw await de_InvalidScopeExceptionRes(parsedOutput, context3);
         case "SlowDownException":
         case "com.amazonaws.ssooidc#SlowDownException":
-          throw await de_SlowDownExceptionRes(parsedOutput, context);
+          throw await de_SlowDownExceptionRes(parsedOutput, context3);
         case "UnauthorizedClientException":
         case "com.amazonaws.ssooidc#UnauthorizedClientException":
-          throw await de_UnauthorizedClientExceptionRes(parsedOutput, context);
+          throw await de_UnauthorizedClientExceptionRes(parsedOutput, context3);
         case "UnsupportedGrantTypeException":
         case "com.amazonaws.ssooidc#UnsupportedGrantTypeException":
-          throw await de_UnsupportedGrantTypeExceptionRes(parsedOutput, context);
+          throw await de_UnsupportedGrantTypeExceptionRes(parsedOutput, context3);
         default:
           const parsedBody = parsedOutput.body;
           return throwDefaultError({
@@ -26107,7 +26119,7 @@ var init_Aws_restJson1 = __esm({
       }
     };
     throwDefaultError = (0, import_smithy_client14.withBaseException)(SSOOIDCServiceException);
-    de_AccessDeniedExceptionRes = async (parsedOutput, context) => {
+    de_AccessDeniedExceptionRes = async (parsedOutput, context3) => {
       const contents = (0, import_smithy_client14.map)({});
       const data2 = parsedOutput.body;
       const doc = (0, import_smithy_client14.take)(data2, {
@@ -26122,7 +26134,7 @@ var init_Aws_restJson1 = __esm({
       });
       return (0, import_smithy_client14.decorateServiceException)(exception, parsedOutput.body);
     };
-    de_AuthorizationPendingExceptionRes = async (parsedOutput, context) => {
+    de_AuthorizationPendingExceptionRes = async (parsedOutput, context3) => {
       const contents = (0, import_smithy_client14.map)({});
       const data2 = parsedOutput.body;
       const doc = (0, import_smithy_client14.take)(data2, {
@@ -26136,7 +26148,7 @@ var init_Aws_restJson1 = __esm({
       });
       return (0, import_smithy_client14.decorateServiceException)(exception, parsedOutput.body);
     };
-    de_ExpiredTokenExceptionRes = async (parsedOutput, context) => {
+    de_ExpiredTokenExceptionRes = async (parsedOutput, context3) => {
       const contents = (0, import_smithy_client14.map)({});
       const data2 = parsedOutput.body;
       const doc = (0, import_smithy_client14.take)(data2, {
@@ -26150,7 +26162,7 @@ var init_Aws_restJson1 = __esm({
       });
       return (0, import_smithy_client14.decorateServiceException)(exception, parsedOutput.body);
     };
-    de_InternalServerExceptionRes = async (parsedOutput, context) => {
+    de_InternalServerExceptionRes = async (parsedOutput, context3) => {
       const contents = (0, import_smithy_client14.map)({});
       const data2 = parsedOutput.body;
       const doc = (0, import_smithy_client14.take)(data2, {
@@ -26164,7 +26176,7 @@ var init_Aws_restJson1 = __esm({
       });
       return (0, import_smithy_client14.decorateServiceException)(exception, parsedOutput.body);
     };
-    de_InvalidClientExceptionRes = async (parsedOutput, context) => {
+    de_InvalidClientExceptionRes = async (parsedOutput, context3) => {
       const contents = (0, import_smithy_client14.map)({});
       const data2 = parsedOutput.body;
       const doc = (0, import_smithy_client14.take)(data2, {
@@ -26178,7 +26190,7 @@ var init_Aws_restJson1 = __esm({
       });
       return (0, import_smithy_client14.decorateServiceException)(exception, parsedOutput.body);
     };
-    de_InvalidGrantExceptionRes = async (parsedOutput, context) => {
+    de_InvalidGrantExceptionRes = async (parsedOutput, context3) => {
       const contents = (0, import_smithy_client14.map)({});
       const data2 = parsedOutput.body;
       const doc = (0, import_smithy_client14.take)(data2, {
@@ -26192,7 +26204,7 @@ var init_Aws_restJson1 = __esm({
       });
       return (0, import_smithy_client14.decorateServiceException)(exception, parsedOutput.body);
     };
-    de_InvalidRequestExceptionRes = async (parsedOutput, context) => {
+    de_InvalidRequestExceptionRes = async (parsedOutput, context3) => {
       const contents = (0, import_smithy_client14.map)({});
       const data2 = parsedOutput.body;
       const doc = (0, import_smithy_client14.take)(data2, {
@@ -26207,7 +26219,7 @@ var init_Aws_restJson1 = __esm({
       });
       return (0, import_smithy_client14.decorateServiceException)(exception, parsedOutput.body);
     };
-    de_InvalidScopeExceptionRes = async (parsedOutput, context) => {
+    de_InvalidScopeExceptionRes = async (parsedOutput, context3) => {
       const contents = (0, import_smithy_client14.map)({});
       const data2 = parsedOutput.body;
       const doc = (0, import_smithy_client14.take)(data2, {
@@ -26221,7 +26233,7 @@ var init_Aws_restJson1 = __esm({
       });
       return (0, import_smithy_client14.decorateServiceException)(exception, parsedOutput.body);
     };
-    de_SlowDownExceptionRes = async (parsedOutput, context) => {
+    de_SlowDownExceptionRes = async (parsedOutput, context3) => {
       const contents = (0, import_smithy_client14.map)({});
       const data2 = parsedOutput.body;
       const doc = (0, import_smithy_client14.take)(data2, {
@@ -26235,7 +26247,7 @@ var init_Aws_restJson1 = __esm({
       });
       return (0, import_smithy_client14.decorateServiceException)(exception, parsedOutput.body);
     };
-    de_UnauthorizedClientExceptionRes = async (parsedOutput, context) => {
+    de_UnauthorizedClientExceptionRes = async (parsedOutput, context3) => {
       const contents = (0, import_smithy_client14.map)({});
       const data2 = parsedOutput.body;
       const doc = (0, import_smithy_client14.take)(data2, {
@@ -26249,7 +26261,7 @@ var init_Aws_restJson1 = __esm({
       });
       return (0, import_smithy_client14.decorateServiceException)(exception, parsedOutput.body);
     };
-    de_UnsupportedGrantTypeExceptionRes = async (parsedOutput, context) => {
+    de_UnsupportedGrantTypeExceptionRes = async (parsedOutput, context3) => {
       const contents = (0, import_smithy_client14.map)({});
       const data2 = parsedOutput.body;
       const doc = (0, import_smithy_client14.take)(data2, {
@@ -26517,9 +26529,9 @@ var require_httpAuthSchemeProvider2 = __commonJS({
     exports2.resolveHttpAuthSchemeConfig = exports2.defaultSSOHttpAuthSchemeProvider = exports2.defaultSSOHttpAuthSchemeParametersProvider = void 0;
     var core_1 = (init_dist_es2(), __toCommonJS(dist_es_exports2));
     var util_middleware_1 = require_dist_cjs7();
-    var defaultSSOHttpAuthSchemeParametersProvider = async (config, context, input) => {
+    var defaultSSOHttpAuthSchemeParametersProvider = async (config, context3, input) => {
       return {
-        operation: (0, util_middleware_1.getSmithyContext)(context).operation,
+        operation: (0, util_middleware_1.getSmithyContext)(context3).operation,
         region: await (0, util_middleware_1.normalizeProvider)(config.region)() || (() => {
           throw new Error("expected `region` to be configured for `aws.auth#sigv4`");
         })()
@@ -26533,10 +26545,10 @@ var require_httpAuthSchemeProvider2 = __commonJS({
           name: "awsssoportal",
           region: authParameters.region
         },
-        propertiesExtractor: (config, context) => ({
+        propertiesExtractor: (config, context3) => ({
           signingProperties: {
             config,
-            context
+            context: context3
           }
         })
       };
@@ -26734,10 +26746,10 @@ var require_endpointResolver = __commonJS({
       size: 50,
       params: ["Endpoint", "Region", "UseDualStack", "UseFIPS"]
     });
-    var defaultEndpointResolver3 = (endpointParams, context = {}) => {
+    var defaultEndpointResolver3 = (endpointParams, context3 = {}) => {
       return cache3.get(endpointParams, () => (0, util_endpoints_2.resolveEndpoint)(ruleset_1.ruleSet, {
         endpointParams,
-        logger: context.logger
+        logger: context3.logger
       }));
     };
     exports2.defaultEndpointResolver = defaultEndpointResolver3;
@@ -27035,8 +27047,8 @@ var require_dist_cjs57 = __commonJS({
       ...obj,
       ...obj.accessToken && { accessToken: smithyClient.SENSITIVE_STRING }
     });
-    var se_GetRoleCredentialsCommand = async (input, context) => {
-      const b3 = core.requestBuilder(input, context);
+    var se_GetRoleCredentialsCommand = async (input, context3) => {
+      const b3 = core.requestBuilder(input, context3);
       const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
         [_xasbt]: input[_aT]
       });
@@ -27049,8 +27061,8 @@ var require_dist_cjs57 = __commonJS({
       b3.m("GET").h(headers).q(query2).b(body);
       return b3.build();
     };
-    var se_ListAccountRolesCommand = async (input, context) => {
-      const b3 = core.requestBuilder(input, context);
+    var se_ListAccountRolesCommand = async (input, context3) => {
+      const b3 = core.requestBuilder(input, context3);
       const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
         [_xasbt]: input[_aT]
       });
@@ -27064,8 +27076,8 @@ var require_dist_cjs57 = __commonJS({
       b3.m("GET").h(headers).q(query2).b(body);
       return b3.build();
     };
-    var se_ListAccountsCommand = async (input, context) => {
-      const b3 = core.requestBuilder(input, context);
+    var se_ListAccountsCommand = async (input, context3) => {
+      const b3 = core.requestBuilder(input, context3);
       const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
         [_xasbt]: input[_aT]
       });
@@ -27078,8 +27090,8 @@ var require_dist_cjs57 = __commonJS({
       b3.m("GET").h(headers).q(query2).b(body);
       return b3.build();
     };
-    var se_LogoutCommand = async (input, context) => {
-      const b3 = core.requestBuilder(input, context);
+    var se_LogoutCommand = async (input, context3) => {
+      const b3 = core.requestBuilder(input, context3);
       const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
         [_xasbt]: input[_aT]
       });
@@ -27088,28 +27100,28 @@ var require_dist_cjs57 = __commonJS({
       b3.m("POST").h(headers).b(body);
       return b3.build();
     };
-    var de_GetRoleCredentialsCommand = async (output, context) => {
+    var de_GetRoleCredentialsCommand = async (output, context3) => {
       if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError3(output, context);
+        return de_CommandError3(output, context3);
       }
       const contents = smithyClient.map({
         $metadata: deserializeMetadata3(output)
       });
-      const data2 = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
+      const data2 = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context3)), "body");
       const doc = smithyClient.take(data2, {
         roleCredentials: smithyClient._json
       });
       Object.assign(contents, doc);
       return contents;
     };
-    var de_ListAccountRolesCommand = async (output, context) => {
+    var de_ListAccountRolesCommand = async (output, context3) => {
       if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError3(output, context);
+        return de_CommandError3(output, context3);
       }
       const contents = smithyClient.map({
         $metadata: deserializeMetadata3(output)
       });
-      const data2 = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
+      const data2 = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context3)), "body");
       const doc = smithyClient.take(data2, {
         nextToken: smithyClient.expectString,
         roleList: smithyClient._json
@@ -27117,14 +27129,14 @@ var require_dist_cjs57 = __commonJS({
       Object.assign(contents, doc);
       return contents;
     };
-    var de_ListAccountsCommand = async (output, context) => {
+    var de_ListAccountsCommand = async (output, context3) => {
       if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError3(output, context);
+        return de_CommandError3(output, context3);
       }
       const contents = smithyClient.map({
         $metadata: deserializeMetadata3(output)
       });
-      const data2 = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
+      const data2 = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context3)), "body");
       const doc = smithyClient.take(data2, {
         accountList: smithyClient._json,
         nextToken: smithyClient.expectString
@@ -27132,20 +27144,20 @@ var require_dist_cjs57 = __commonJS({
       Object.assign(contents, doc);
       return contents;
     };
-    var de_LogoutCommand = async (output, context) => {
+    var de_LogoutCommand = async (output, context3) => {
       if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError3(output, context);
+        return de_CommandError3(output, context3);
       }
       const contents = smithyClient.map({
         $metadata: deserializeMetadata3(output)
       });
-      await smithyClient.collectBody(output.body, context);
+      await smithyClient.collectBody(output.body, context3);
       return contents;
     };
-    var de_CommandError3 = async (output, context) => {
+    var de_CommandError3 = async (output, context3) => {
       const parsedOutput = {
         ...output,
-        body: await core$1.parseJsonErrorBody(output.body, context)
+        body: await core$1.parseJsonErrorBody(output.body, context3)
       };
       const errorCode = core$1.loadRestJsonErrorCode(output, parsedOutput.body);
       switch (errorCode) {
@@ -27171,7 +27183,7 @@ var require_dist_cjs57 = __commonJS({
       }
     };
     var throwDefaultError3 = smithyClient.withBaseException(SSOServiceException);
-    var de_InvalidRequestExceptionRes2 = async (parsedOutput, context) => {
+    var de_InvalidRequestExceptionRes2 = async (parsedOutput, context3) => {
       const contents = smithyClient.map({});
       const data2 = parsedOutput.body;
       const doc = smithyClient.take(data2, {
@@ -27184,7 +27196,7 @@ var require_dist_cjs57 = __commonJS({
       });
       return smithyClient.decorateServiceException(exception, parsedOutput.body);
     };
-    var de_ResourceNotFoundExceptionRes = async (parsedOutput, context) => {
+    var de_ResourceNotFoundExceptionRes = async (parsedOutput, context3) => {
       const contents = smithyClient.map({});
       const data2 = parsedOutput.body;
       const doc = smithyClient.take(data2, {
@@ -27197,7 +27209,7 @@ var require_dist_cjs57 = __commonJS({
       });
       return smithyClient.decorateServiceException(exception, parsedOutput.body);
     };
-    var de_TooManyRequestsExceptionRes = async (parsedOutput, context) => {
+    var de_TooManyRequestsExceptionRes = async (parsedOutput, context3) => {
       const contents = smithyClient.map({});
       const data2 = parsedOutput.body;
       const doc = smithyClient.take(data2, {
@@ -27210,7 +27222,7 @@ var require_dist_cjs57 = __commonJS({
       });
       return smithyClient.decorateServiceException(exception, parsedOutput.body);
     };
-    var de_UnauthorizedExceptionRes = async (parsedOutput, context) => {
+    var de_UnauthorizedExceptionRes = async (parsedOutput, context3) => {
       const contents = smithyClient.map({});
       const data2 = parsedOutput.body;
       const doc = smithyClient.take(data2, {
@@ -27517,10 +27529,10 @@ function createAwsAuthSigv4HttpAuthOption2(authParameters) {
       name: "sts",
       region: authParameters.region
     },
-    propertiesExtractor: (config, context) => ({
+    propertiesExtractor: (config, context3) => ({
       signingProperties: {
         config,
-        context
+        context: context3
       }
     })
   };
@@ -27536,9 +27548,9 @@ var init_httpAuthSchemeProvider2 = __esm({
     init_dist_es2();
     import_util_middleware7 = __toESM(require_dist_cjs7());
     init_STSClient();
-    defaultSTSHttpAuthSchemeParametersProvider = async (config, context, input) => {
+    defaultSTSHttpAuthSchemeParametersProvider = async (config, context3, input) => {
       return {
-        operation: (0, import_util_middleware7.getSmithyContext)(context).operation,
+        operation: (0, import_util_middleware7.getSmithyContext)(context3).operation,
         region: await (0, import_util_middleware7.normalizeProvider)(config.region)() || (() => {
           throw new Error("expected `region` to be configured for `aws.auth#sigv4`");
         })()
@@ -27648,10 +27660,10 @@ var init_endpointResolver2 = __esm({
       size: 50,
       params: ["Endpoint", "Region", "UseDualStack", "UseFIPS", "UseGlobalEndpoint"]
     });
-    defaultEndpointResolver2 = (endpointParams, context = {}) => {
+    defaultEndpointResolver2 = (endpointParams, context3 = {}) => {
       return cache2.get(endpointParams, () => (0, import_util_endpoints4.resolveEndpoint)(ruleSet2, {
         endpointParams,
-        logger: context.logger
+        logger: context3.logger
       }));
     };
     import_util_endpoints4.customEndpointFunctions.aws = import_util_endpoints3.awsEndpointFunctions;
@@ -28013,80 +28025,80 @@ var init_Aws_query = __esm({
     import_smithy_client24 = __toESM(require_dist_cjs27());
     init_models_02();
     init_STSServiceException();
-    se_AssumeRoleCommand = async (input, context) => {
+    se_AssumeRoleCommand = async (input, context3) => {
       const headers = SHARED_HEADERS;
       let body;
       body = buildFormUrlencodedString({
-        ...se_AssumeRoleRequest(input, context),
+        ...se_AssumeRoleRequest(input, context3),
         [_A]: _AR,
         [_V]: _
       });
-      return buildHttpRpcRequest(context, headers, "/", void 0, body);
+      return buildHttpRpcRequest(context3, headers, "/", void 0, body);
     };
-    se_AssumeRoleWithWebIdentityCommand = async (input, context) => {
+    se_AssumeRoleWithWebIdentityCommand = async (input, context3) => {
       const headers = SHARED_HEADERS;
       let body;
       body = buildFormUrlencodedString({
-        ...se_AssumeRoleWithWebIdentityRequest(input, context),
+        ...se_AssumeRoleWithWebIdentityRequest(input, context3),
         [_A]: _ARWWI,
         [_V]: _
       });
-      return buildHttpRpcRequest(context, headers, "/", void 0, body);
+      return buildHttpRpcRequest(context3, headers, "/", void 0, body);
     };
-    de_AssumeRoleCommand = async (output, context) => {
+    de_AssumeRoleCommand = async (output, context3) => {
       if (output.statusCode >= 300) {
-        return de_CommandError2(output, context);
+        return de_CommandError2(output, context3);
       }
-      const data2 = await parseXmlBody(output.body, context);
+      const data2 = await parseXmlBody(output.body, context3);
       let contents = {};
-      contents = de_AssumeRoleResponse(data2.AssumeRoleResult, context);
+      contents = de_AssumeRoleResponse(data2.AssumeRoleResult, context3);
       const response = {
         $metadata: deserializeMetadata2(output),
         ...contents
       };
       return response;
     };
-    de_AssumeRoleWithWebIdentityCommand = async (output, context) => {
+    de_AssumeRoleWithWebIdentityCommand = async (output, context3) => {
       if (output.statusCode >= 300) {
-        return de_CommandError2(output, context);
+        return de_CommandError2(output, context3);
       }
-      const data2 = await parseXmlBody(output.body, context);
+      const data2 = await parseXmlBody(output.body, context3);
       let contents = {};
-      contents = de_AssumeRoleWithWebIdentityResponse(data2.AssumeRoleWithWebIdentityResult, context);
+      contents = de_AssumeRoleWithWebIdentityResponse(data2.AssumeRoleWithWebIdentityResult, context3);
       const response = {
         $metadata: deserializeMetadata2(output),
         ...contents
       };
       return response;
     };
-    de_CommandError2 = async (output, context) => {
+    de_CommandError2 = async (output, context3) => {
       const parsedOutput = {
         ...output,
-        body: await parseXmlErrorBody(output.body, context)
+        body: await parseXmlErrorBody(output.body, context3)
       };
       const errorCode = loadQueryErrorCode(output, parsedOutput.body);
       switch (errorCode) {
         case "ExpiredTokenException":
         case "com.amazonaws.sts#ExpiredTokenException":
-          throw await de_ExpiredTokenExceptionRes2(parsedOutput, context);
+          throw await de_ExpiredTokenExceptionRes2(parsedOutput, context3);
         case "MalformedPolicyDocument":
         case "com.amazonaws.sts#MalformedPolicyDocumentException":
-          throw await de_MalformedPolicyDocumentExceptionRes(parsedOutput, context);
+          throw await de_MalformedPolicyDocumentExceptionRes(parsedOutput, context3);
         case "PackedPolicyTooLarge":
         case "com.amazonaws.sts#PackedPolicyTooLargeException":
-          throw await de_PackedPolicyTooLargeExceptionRes(parsedOutput, context);
+          throw await de_PackedPolicyTooLargeExceptionRes(parsedOutput, context3);
         case "RegionDisabledException":
         case "com.amazonaws.sts#RegionDisabledException":
-          throw await de_RegionDisabledExceptionRes(parsedOutput, context);
+          throw await de_RegionDisabledExceptionRes(parsedOutput, context3);
         case "IDPCommunicationError":
         case "com.amazonaws.sts#IDPCommunicationErrorException":
-          throw await de_IDPCommunicationErrorExceptionRes(parsedOutput, context);
+          throw await de_IDPCommunicationErrorExceptionRes(parsedOutput, context3);
         case "IDPRejectedClaim":
         case "com.amazonaws.sts#IDPRejectedClaimException":
-          throw await de_IDPRejectedClaimExceptionRes(parsedOutput, context);
+          throw await de_IDPRejectedClaimExceptionRes(parsedOutput, context3);
         case "InvalidIdentityToken":
         case "com.amazonaws.sts#InvalidIdentityTokenException":
-          throw await de_InvalidIdentityTokenExceptionRes(parsedOutput, context);
+          throw await de_InvalidIdentityTokenExceptionRes(parsedOutput, context3);
         default:
           const parsedBody = parsedOutput.body;
           return throwDefaultError2({
@@ -28096,70 +28108,70 @@ var init_Aws_query = __esm({
           });
       }
     };
-    de_ExpiredTokenExceptionRes2 = async (parsedOutput, context) => {
+    de_ExpiredTokenExceptionRes2 = async (parsedOutput, context3) => {
       const body = parsedOutput.body;
-      const deserialized = de_ExpiredTokenException(body.Error, context);
+      const deserialized = de_ExpiredTokenException(body.Error, context3);
       const exception = new ExpiredTokenException2({
         $metadata: deserializeMetadata2(parsedOutput),
         ...deserialized
       });
       return (0, import_smithy_client24.decorateServiceException)(exception, body);
     };
-    de_IDPCommunicationErrorExceptionRes = async (parsedOutput, context) => {
+    de_IDPCommunicationErrorExceptionRes = async (parsedOutput, context3) => {
       const body = parsedOutput.body;
-      const deserialized = de_IDPCommunicationErrorException(body.Error, context);
+      const deserialized = de_IDPCommunicationErrorException(body.Error, context3);
       const exception = new IDPCommunicationErrorException({
         $metadata: deserializeMetadata2(parsedOutput),
         ...deserialized
       });
       return (0, import_smithy_client24.decorateServiceException)(exception, body);
     };
-    de_IDPRejectedClaimExceptionRes = async (parsedOutput, context) => {
+    de_IDPRejectedClaimExceptionRes = async (parsedOutput, context3) => {
       const body = parsedOutput.body;
-      const deserialized = de_IDPRejectedClaimException(body.Error, context);
+      const deserialized = de_IDPRejectedClaimException(body.Error, context3);
       const exception = new IDPRejectedClaimException({
         $metadata: deserializeMetadata2(parsedOutput),
         ...deserialized
       });
       return (0, import_smithy_client24.decorateServiceException)(exception, body);
     };
-    de_InvalidIdentityTokenExceptionRes = async (parsedOutput, context) => {
+    de_InvalidIdentityTokenExceptionRes = async (parsedOutput, context3) => {
       const body = parsedOutput.body;
-      const deserialized = de_InvalidIdentityTokenException(body.Error, context);
+      const deserialized = de_InvalidIdentityTokenException(body.Error, context3);
       const exception = new InvalidIdentityTokenException({
         $metadata: deserializeMetadata2(parsedOutput),
         ...deserialized
       });
       return (0, import_smithy_client24.decorateServiceException)(exception, body);
     };
-    de_MalformedPolicyDocumentExceptionRes = async (parsedOutput, context) => {
+    de_MalformedPolicyDocumentExceptionRes = async (parsedOutput, context3) => {
       const body = parsedOutput.body;
-      const deserialized = de_MalformedPolicyDocumentException(body.Error, context);
+      const deserialized = de_MalformedPolicyDocumentException(body.Error, context3);
       const exception = new MalformedPolicyDocumentException({
         $metadata: deserializeMetadata2(parsedOutput),
         ...deserialized
       });
       return (0, import_smithy_client24.decorateServiceException)(exception, body);
     };
-    de_PackedPolicyTooLargeExceptionRes = async (parsedOutput, context) => {
+    de_PackedPolicyTooLargeExceptionRes = async (parsedOutput, context3) => {
       const body = parsedOutput.body;
-      const deserialized = de_PackedPolicyTooLargeException(body.Error, context);
+      const deserialized = de_PackedPolicyTooLargeException(body.Error, context3);
       const exception = new PackedPolicyTooLargeException({
         $metadata: deserializeMetadata2(parsedOutput),
         ...deserialized
       });
       return (0, import_smithy_client24.decorateServiceException)(exception, body);
     };
-    de_RegionDisabledExceptionRes = async (parsedOutput, context) => {
+    de_RegionDisabledExceptionRes = async (parsedOutput, context3) => {
       const body = parsedOutput.body;
-      const deserialized = de_RegionDisabledException(body.Error, context);
+      const deserialized = de_RegionDisabledException(body.Error, context3);
       const exception = new RegionDisabledException({
         $metadata: deserializeMetadata2(parsedOutput),
         ...deserialized
       });
       return (0, import_smithy_client24.decorateServiceException)(exception, body);
     };
-    se_AssumeRoleRequest = (input, context) => {
+    se_AssumeRoleRequest = (input, context3) => {
       const entries = {};
       if (input[_RA] != null) {
         entries[_RA] = input[_RA];
@@ -28168,7 +28180,7 @@ var init_Aws_query = __esm({
         entries[_RSN] = input[_RSN];
       }
       if (input[_PA] != null) {
-        const memberEntries = se_policyDescriptorListType(input[_PA], context);
+        const memberEntries = se_policyDescriptorListType(input[_PA], context3);
         if (input[_PA]?.length === 0) {
           entries.PolicyArns = [];
         }
@@ -28184,7 +28196,7 @@ var init_Aws_query = __esm({
         entries[_DS] = input[_DS];
       }
       if (input[_T] != null) {
-        const memberEntries = se_tagListType(input[_T], context);
+        const memberEntries = se_tagListType(input[_T], context3);
         if (input[_T]?.length === 0) {
           entries.Tags = [];
         }
@@ -28194,7 +28206,7 @@ var init_Aws_query = __esm({
         });
       }
       if (input[_TTK] != null) {
-        const memberEntries = se_tagKeyListType(input[_TTK], context);
+        const memberEntries = se_tagKeyListType(input[_TTK], context3);
         if (input[_TTK]?.length === 0) {
           entries.TransitiveTagKeys = [];
         }
@@ -28216,7 +28228,7 @@ var init_Aws_query = __esm({
         entries[_SI] = input[_SI];
       }
       if (input[_PC] != null) {
-        const memberEntries = se_ProvidedContextsListType(input[_PC], context);
+        const memberEntries = se_ProvidedContextsListType(input[_PC], context3);
         if (input[_PC]?.length === 0) {
           entries.ProvidedContexts = [];
         }
@@ -28227,7 +28239,7 @@ var init_Aws_query = __esm({
       }
       return entries;
     };
-    se_AssumeRoleWithWebIdentityRequest = (input, context) => {
+    se_AssumeRoleWithWebIdentityRequest = (input, context3) => {
       const entries = {};
       if (input[_RA] != null) {
         entries[_RA] = input[_RA];
@@ -28242,7 +28254,7 @@ var init_Aws_query = __esm({
         entries[_PI] = input[_PI];
       }
       if (input[_PA] != null) {
-        const memberEntries = se_policyDescriptorListType(input[_PA], context);
+        const memberEntries = se_policyDescriptorListType(input[_PA], context3);
         if (input[_PA]?.length === 0) {
           entries.PolicyArns = [];
         }
@@ -28259,14 +28271,14 @@ var init_Aws_query = __esm({
       }
       return entries;
     };
-    se_policyDescriptorListType = (input, context) => {
+    se_policyDescriptorListType = (input, context3) => {
       const entries = {};
       let counter = 1;
       for (const entry of input) {
         if (entry === null) {
           continue;
         }
-        const memberEntries = se_PolicyDescriptorType(entry, context);
+        const memberEntries = se_PolicyDescriptorType(entry, context3);
         Object.entries(memberEntries).forEach(([key, value]) => {
           entries[`member.${counter}.${key}`] = value;
         });
@@ -28274,14 +28286,14 @@ var init_Aws_query = __esm({
       }
       return entries;
     };
-    se_PolicyDescriptorType = (input, context) => {
+    se_PolicyDescriptorType = (input, context3) => {
       const entries = {};
       if (input[_a15] != null) {
         entries[_a15] = input[_a15];
       }
       return entries;
     };
-    se_ProvidedContext = (input, context) => {
+    se_ProvidedContext = (input, context3) => {
       const entries = {};
       if (input[_PAr] != null) {
         entries[_PAr] = input[_PAr];
@@ -28291,14 +28303,14 @@ var init_Aws_query = __esm({
       }
       return entries;
     };
-    se_ProvidedContextsListType = (input, context) => {
+    se_ProvidedContextsListType = (input, context3) => {
       const entries = {};
       let counter = 1;
       for (const entry of input) {
         if (entry === null) {
           continue;
         }
-        const memberEntries = se_ProvidedContext(entry, context);
+        const memberEntries = se_ProvidedContext(entry, context3);
         Object.entries(memberEntries).forEach(([key, value]) => {
           entries[`member.${counter}.${key}`] = value;
         });
@@ -28306,7 +28318,7 @@ var init_Aws_query = __esm({
       }
       return entries;
     };
-    se_Tag = (input, context) => {
+    se_Tag = (input, context3) => {
       const entries = {};
       if (input[_K] != null) {
         entries[_K] = input[_K];
@@ -28316,7 +28328,7 @@ var init_Aws_query = __esm({
       }
       return entries;
     };
-    se_tagKeyListType = (input, context) => {
+    se_tagKeyListType = (input, context3) => {
       const entries = {};
       let counter = 1;
       for (const entry of input) {
@@ -28328,14 +28340,14 @@ var init_Aws_query = __esm({
       }
       return entries;
     };
-    se_tagListType = (input, context) => {
+    se_tagListType = (input, context3) => {
       const entries = {};
       let counter = 1;
       for (const entry of input) {
         if (entry === null) {
           continue;
         }
-        const memberEntries = se_Tag(entry, context);
+        const memberEntries = se_Tag(entry, context3);
         Object.entries(memberEntries).forEach(([key, value]) => {
           entries[`member.${counter}.${key}`] = value;
         });
@@ -28343,7 +28355,7 @@ var init_Aws_query = __esm({
       }
       return entries;
     };
-    de_AssumedRoleUser = (output, context) => {
+    de_AssumedRoleUser = (output, context3) => {
       const contents = {};
       if (output[_ARI] != null) {
         contents[_ARI] = (0, import_smithy_client24.expectString)(output[_ARI]);
@@ -28353,13 +28365,13 @@ var init_Aws_query = __esm({
       }
       return contents;
     };
-    de_AssumeRoleResponse = (output, context) => {
+    de_AssumeRoleResponse = (output, context3) => {
       const contents = {};
       if (output[_C] != null) {
-        contents[_C] = de_Credentials(output[_C], context);
+        contents[_C] = de_Credentials(output[_C], context3);
       }
       if (output[_ARU] != null) {
-        contents[_ARU] = de_AssumedRoleUser(output[_ARU], context);
+        contents[_ARU] = de_AssumedRoleUser(output[_ARU], context3);
       }
       if (output[_PPS] != null) {
         contents[_PPS] = (0, import_smithy_client24.strictParseInt32)(output[_PPS]);
@@ -28369,16 +28381,16 @@ var init_Aws_query = __esm({
       }
       return contents;
     };
-    de_AssumeRoleWithWebIdentityResponse = (output, context) => {
+    de_AssumeRoleWithWebIdentityResponse = (output, context3) => {
       const contents = {};
       if (output[_C] != null) {
-        contents[_C] = de_Credentials(output[_C], context);
+        contents[_C] = de_Credentials(output[_C], context3);
       }
       if (output[_SFWIT] != null) {
         contents[_SFWIT] = (0, import_smithy_client24.expectString)(output[_SFWIT]);
       }
       if (output[_ARU] != null) {
-        contents[_ARU] = de_AssumedRoleUser(output[_ARU], context);
+        contents[_ARU] = de_AssumedRoleUser(output[_ARU], context3);
       }
       if (output[_PPS] != null) {
         contents[_PPS] = (0, import_smithy_client24.strictParseInt32)(output[_PPS]);
@@ -28394,7 +28406,7 @@ var init_Aws_query = __esm({
       }
       return contents;
     };
-    de_Credentials = (output, context) => {
+    de_Credentials = (output, context3) => {
       const contents = {};
       if (output[_AKI] != null) {
         contents[_AKI] = (0, import_smithy_client24.expectString)(output[_AKI]);
@@ -28410,49 +28422,49 @@ var init_Aws_query = __esm({
       }
       return contents;
     };
-    de_ExpiredTokenException = (output, context) => {
+    de_ExpiredTokenException = (output, context3) => {
       const contents = {};
       if (output[_m] != null) {
         contents[_m] = (0, import_smithy_client24.expectString)(output[_m]);
       }
       return contents;
     };
-    de_IDPCommunicationErrorException = (output, context) => {
+    de_IDPCommunicationErrorException = (output, context3) => {
       const contents = {};
       if (output[_m] != null) {
         contents[_m] = (0, import_smithy_client24.expectString)(output[_m]);
       }
       return contents;
     };
-    de_IDPRejectedClaimException = (output, context) => {
+    de_IDPRejectedClaimException = (output, context3) => {
       const contents = {};
       if (output[_m] != null) {
         contents[_m] = (0, import_smithy_client24.expectString)(output[_m]);
       }
       return contents;
     };
-    de_InvalidIdentityTokenException = (output, context) => {
+    de_InvalidIdentityTokenException = (output, context3) => {
       const contents = {};
       if (output[_m] != null) {
         contents[_m] = (0, import_smithy_client24.expectString)(output[_m]);
       }
       return contents;
     };
-    de_MalformedPolicyDocumentException = (output, context) => {
+    de_MalformedPolicyDocumentException = (output, context3) => {
       const contents = {};
       if (output[_m] != null) {
         contents[_m] = (0, import_smithy_client24.expectString)(output[_m]);
       }
       return contents;
     };
-    de_PackedPolicyTooLargeException = (output, context) => {
+    de_PackedPolicyTooLargeException = (output, context3) => {
       const contents = {};
       if (output[_m] != null) {
         contents[_m] = (0, import_smithy_client24.expectString)(output[_m]);
       }
       return contents;
     };
-    de_RegionDisabledException = (output, context) => {
+    de_RegionDisabledException = (output, context3) => {
       const contents = {};
       if (output[_m] != null) {
         contents[_m] = (0, import_smithy_client24.expectString)(output[_m]);
@@ -28466,8 +28478,8 @@ var init_Aws_query = __esm({
       cfId: output.headers["x-amz-cf-id"]
     });
     throwDefaultError2 = (0, import_smithy_client24.withBaseException)(STSServiceException);
-    buildHttpRpcRequest = async (context, headers, path7, resolvedHostname, body) => {
-      const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    buildHttpRpcRequest = async (context3, headers, path7, resolvedHostname, body) => {
+      const { hostname, protocol = "https", port, path: basePath } = await context3.endpoint();
       const contents = {
         protocol,
         hostname,
@@ -29350,7 +29362,7 @@ var require_dist_cjs63 = __commonJS({
         this.eventStreamCodec = new import_eventstream_codec.EventStreamCodec(options.utf8Encoder, options.utf8Decoder);
         this.systemClockOffsetProvider = async () => options.systemClockOffset ?? 0;
       }
-      async handle(next, args, context = {}) {
+      async handle(next, args, context3 = {}) {
         const request = args.request;
         const { body: payload2, query: query2 } = request;
         if (!(payload2 instanceof import_stream.Readable)) {
@@ -29487,10 +29499,10 @@ var require_endpointResolver2 = __commonJS({
       size: 50,
       params: ["Endpoint", "Region", "UseDualStack", "UseFIPS"]
     });
-    var defaultEndpointResolver3 = (endpointParams, context = {}) => {
+    var defaultEndpointResolver3 = (endpointParams, context3 = {}) => {
       return cache3.get(endpointParams, () => (0, util_endpoints_2.resolveEndpoint)(ruleset_1.ruleSet, {
         endpointParams,
-        logger: context.logger
+        logger: context3.logger
       }));
     };
     exports2.defaultEndpointResolver = defaultEndpointResolver3;
@@ -30898,8 +30910,8 @@ var require_dist_cjs65 = __commonJS({
       ...obj,
       ...obj.input && { input: CountTokensInputFilterSensitiveLog(obj.input) }
     });
-    var se_ApplyGuardrailCommand = async (input, context) => {
-      const b3 = core.requestBuilder(input, context);
+    var se_ApplyGuardrailCommand = async (input, context3) => {
+      const b3 = core.requestBuilder(input, context3);
       const headers = {
         "content-type": "application/json"
       };
@@ -30908,15 +30920,15 @@ var require_dist_cjs65 = __commonJS({
       b3.p("guardrailVersion", () => input.guardrailVersion, "{guardrailVersion}", false);
       let body;
       body = JSON.stringify(smithyClient.take(input, {
-        content: (_2) => se_GuardrailContentBlockList(_2, context),
+        content: (_2) => se_GuardrailContentBlockList(_2, context3),
         outputScope: [],
         source: []
       }));
       b3.m("POST").h(headers).b(body);
       return b3.build();
     };
-    var se_ConverseCommand = async (input, context) => {
-      const b3 = core.requestBuilder(input, context);
+    var se_ConverseCommand = async (input, context3) => {
+      const b3 = core.requestBuilder(input, context3);
       const headers = {
         "content-type": "application/json"
       };
@@ -30928,18 +30940,18 @@ var require_dist_cjs65 = __commonJS({
         additionalModelResponseFieldPaths: (_2) => smithyClient._json(_2),
         guardrailConfig: (_2) => smithyClient._json(_2),
         inferenceConfig: (_2) => se_InferenceConfiguration(_2),
-        messages: (_2) => se_Messages(_2, context),
+        messages: (_2) => se_Messages(_2, context3),
         performanceConfig: (_2) => smithyClient._json(_2),
         promptVariables: (_2) => smithyClient._json(_2),
         requestMetadata: (_2) => smithyClient._json(_2),
-        system: (_2) => se_SystemContentBlocks(_2, context),
+        system: (_2) => se_SystemContentBlocks(_2, context3),
         toolConfig: (_2) => se_ToolConfiguration(_2)
       }));
       b3.m("POST").h(headers).b(body);
       return b3.build();
     };
-    var se_ConverseStreamCommand = async (input, context) => {
-      const b3 = core.requestBuilder(input, context);
+    var se_ConverseStreamCommand = async (input, context3) => {
+      const b3 = core.requestBuilder(input, context3);
       const headers = {
         "content-type": "application/json"
       };
@@ -30951,18 +30963,18 @@ var require_dist_cjs65 = __commonJS({
         additionalModelResponseFieldPaths: (_2) => smithyClient._json(_2),
         guardrailConfig: (_2) => smithyClient._json(_2),
         inferenceConfig: (_2) => se_InferenceConfiguration(_2),
-        messages: (_2) => se_Messages(_2, context),
+        messages: (_2) => se_Messages(_2, context3),
         performanceConfig: (_2) => smithyClient._json(_2),
         promptVariables: (_2) => smithyClient._json(_2),
         requestMetadata: (_2) => smithyClient._json(_2),
-        system: (_2) => se_SystemContentBlocks(_2, context),
+        system: (_2) => se_SystemContentBlocks(_2, context3),
         toolConfig: (_2) => se_ToolConfiguration(_2)
       }));
       b3.m("POST").h(headers).b(body);
       return b3.build();
     };
-    var se_CountTokensCommand = async (input, context) => {
-      const b3 = core.requestBuilder(input, context);
+    var se_CountTokensCommand = async (input, context3) => {
+      const b3 = core.requestBuilder(input, context3);
       const headers = {
         "content-type": "application/json"
       };
@@ -30970,13 +30982,13 @@ var require_dist_cjs65 = __commonJS({
       b3.p("modelId", () => input.modelId, "{modelId}", false);
       let body;
       body = JSON.stringify(smithyClient.take(input, {
-        input: (_2) => se_CountTokensInput(_2, context)
+        input: (_2) => se_CountTokensInput(_2, context3)
       }));
       b3.m("POST").h(headers).b(body);
       return b3.build();
     };
-    var se_GetAsyncInvokeCommand = async (input, context) => {
-      const b3 = core.requestBuilder(input, context);
+    var se_GetAsyncInvokeCommand = async (input, context3) => {
+      const b3 = core.requestBuilder(input, context3);
       const headers = {};
       b3.bp("/async-invoke/{invocationArn}");
       b3.p("invocationArn", () => input.invocationArn, "{invocationArn}", false);
@@ -30984,8 +30996,8 @@ var require_dist_cjs65 = __commonJS({
       b3.m("GET").h(headers).b(body);
       return b3.build();
     };
-    var se_InvokeModelCommand = async (input, context) => {
-      const b3 = core.requestBuilder(input, context);
+    var se_InvokeModelCommand = async (input, context3) => {
+      const b3 = core.requestBuilder(input, context3);
       const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
         [_ct]: input[_cT] || "application/octet-stream",
         [_a16]: input[_a16],
@@ -31003,8 +31015,8 @@ var require_dist_cjs65 = __commonJS({
       b3.m("POST").h(headers).b(body);
       return b3.build();
     };
-    var se_InvokeModelWithBidirectionalStreamCommand = async (input, context) => {
-      const b3 = core.requestBuilder(input, context);
+    var se_InvokeModelWithBidirectionalStreamCommand = async (input, context3) => {
+      const b3 = core.requestBuilder(input, context3);
       const headers = {
         "content-type": "application/json"
       };
@@ -31012,13 +31024,13 @@ var require_dist_cjs65 = __commonJS({
       b3.p("modelId", () => input.modelId, "{modelId}", false);
       let body;
       if (input.body !== void 0) {
-        body = se_InvokeModelWithBidirectionalStreamInput(input.body, context);
+        body = se_InvokeModelWithBidirectionalStreamInput(input.body, context3);
       }
       b3.m("POST").h(headers).b(body);
       return b3.build();
     };
-    var se_InvokeModelWithResponseStreamCommand = async (input, context) => {
-      const b3 = core.requestBuilder(input, context);
+    var se_InvokeModelWithResponseStreamCommand = async (input, context3) => {
+      const b3 = core.requestBuilder(input, context3);
       const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
         [_ct]: input[_cT] || "application/octet-stream",
         [_xaba]: input[_a16],
@@ -31036,8 +31048,8 @@ var require_dist_cjs65 = __commonJS({
       b3.m("POST").h(headers).b(body);
       return b3.build();
     };
-    var se_ListAsyncInvokesCommand = async (input, context) => {
-      const b3 = core.requestBuilder(input, context);
+    var se_ListAsyncInvokesCommand = async (input, context3) => {
+      const b3 = core.requestBuilder(input, context3);
       const headers = {};
       b3.bp("/async-invoke");
       const query2 = smithyClient.map({
@@ -31053,8 +31065,8 @@ var require_dist_cjs65 = __commonJS({
       b3.m("GET").h(headers).q(query2).b(body);
       return b3.build();
     };
-    var se_StartAsyncInvokeCommand = async (input, context) => {
-      const b3 = core.requestBuilder(input, context);
+    var se_StartAsyncInvokeCommand = async (input, context3) => {
+      const b3 = core.requestBuilder(input, context3);
       const headers = {
         "content-type": "application/json"
       };
@@ -31070,14 +31082,14 @@ var require_dist_cjs65 = __commonJS({
       b3.m("POST").h(headers).b(body);
       return b3.build();
     };
-    var de_ApplyGuardrailCommand = async (output, context) => {
+    var de_ApplyGuardrailCommand = async (output, context3) => {
       if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError3(output, context);
+        return de_CommandError3(output, context3);
       }
       const contents = smithyClient.map({
         $metadata: deserializeMetadata3(output)
       });
-      const data2 = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
+      const data2 = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context3)), "body");
       const doc = smithyClient.take(data2, {
         action: smithyClient.expectString,
         actionReason: smithyClient.expectString,
@@ -31089,18 +31101,18 @@ var require_dist_cjs65 = __commonJS({
       Object.assign(contents, doc);
       return contents;
     };
-    var de_ConverseCommand = async (output, context) => {
+    var de_ConverseCommand = async (output, context3) => {
       if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError3(output, context);
+        return de_CommandError3(output, context3);
       }
       const contents = smithyClient.map({
         $metadata: deserializeMetadata3(output)
       });
-      const data2 = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
+      const data2 = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context3)), "body");
       const doc = smithyClient.take(data2, {
         additionalModelResponseFields: (_2) => de_Document(_2),
         metrics: smithyClient._json,
-        output: (_2) => de_ConverseOutput(core$1.awsExpectUnion(_2), context),
+        output: (_2) => de_ConverseOutput(core$1.awsExpectUnion(_2), context3),
         performanceConfig: smithyClient._json,
         stopReason: smithyClient.expectString,
         trace: (_2) => de_ConverseTrace(_2),
@@ -31109,39 +31121,39 @@ var require_dist_cjs65 = __commonJS({
       Object.assign(contents, doc);
       return contents;
     };
-    var de_ConverseStreamCommand = async (output, context) => {
+    var de_ConverseStreamCommand = async (output, context3) => {
       if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError3(output, context);
+        return de_CommandError3(output, context3);
       }
       const contents = smithyClient.map({
         $metadata: deserializeMetadata3(output)
       });
       const data2 = output.body;
-      contents.stream = de_ConverseStreamOutput(data2, context);
+      contents.stream = de_ConverseStreamOutput(data2, context3);
       return contents;
     };
-    var de_CountTokensCommand = async (output, context) => {
+    var de_CountTokensCommand = async (output, context3) => {
       if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError3(output, context);
+        return de_CommandError3(output, context3);
       }
       const contents = smithyClient.map({
         $metadata: deserializeMetadata3(output)
       });
-      const data2 = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
+      const data2 = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context3)), "body");
       const doc = smithyClient.take(data2, {
         inputTokens: smithyClient.expectInt32
       });
       Object.assign(contents, doc);
       return contents;
     };
-    var de_GetAsyncInvokeCommand = async (output, context) => {
+    var de_GetAsyncInvokeCommand = async (output, context3) => {
       if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError3(output, context);
+        return de_CommandError3(output, context3);
       }
       const contents = smithyClient.map({
         $metadata: deserializeMetadata3(output)
       });
-      const data2 = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
+      const data2 = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context3)), "body");
       const doc = smithyClient.take(data2, {
         clientRequestToken: smithyClient.expectString,
         endTime: (_2) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_2)),
@@ -31156,33 +31168,33 @@ var require_dist_cjs65 = __commonJS({
       Object.assign(contents, doc);
       return contents;
     };
-    var de_InvokeModelCommand = async (output, context) => {
+    var de_InvokeModelCommand = async (output, context3) => {
       if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError3(output, context);
+        return de_CommandError3(output, context3);
       }
       const contents = smithyClient.map({
         $metadata: deserializeMetadata3(output),
         [_cT]: [, output.headers[_ct]],
         [_pCL]: [, output.headers[_xabpl]]
       });
-      const data2 = await smithyClient.collectBody(output.body, context);
+      const data2 = await smithyClient.collectBody(output.body, context3);
       contents.body = data2;
       return contents;
     };
-    var de_InvokeModelWithBidirectionalStreamCommand = async (output, context) => {
+    var de_InvokeModelWithBidirectionalStreamCommand = async (output, context3) => {
       if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError3(output, context);
+        return de_CommandError3(output, context3);
       }
       const contents = smithyClient.map({
         $metadata: deserializeMetadata3(output)
       });
       const data2 = output.body;
-      contents.body = de_InvokeModelWithBidirectionalStreamOutput(data2, context);
+      contents.body = de_InvokeModelWithBidirectionalStreamOutput(data2, context3);
       return contents;
     };
-    var de_InvokeModelWithResponseStreamCommand = async (output, context) => {
+    var de_InvokeModelWithResponseStreamCommand = async (output, context3) => {
       if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError3(output, context);
+        return de_CommandError3(output, context3);
       }
       const contents = smithyClient.map({
         $metadata: deserializeMetadata3(output),
@@ -31190,17 +31202,17 @@ var require_dist_cjs65 = __commonJS({
         [_pCL]: [, output.headers[_xabpl]]
       });
       const data2 = output.body;
-      contents.body = de_ResponseStream(data2, context);
+      contents.body = de_ResponseStream(data2, context3);
       return contents;
     };
-    var de_ListAsyncInvokesCommand = async (output, context) => {
+    var de_ListAsyncInvokesCommand = async (output, context3) => {
       if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError3(output, context);
+        return de_CommandError3(output, context3);
       }
       const contents = smithyClient.map({
         $metadata: deserializeMetadata3(output)
       });
-      const data2 = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
+      const data2 = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context3)), "body");
       const doc = smithyClient.take(data2, {
         asyncInvokeSummaries: (_2) => de_AsyncInvokeSummaries(_2),
         nextToken: smithyClient.expectString
@@ -31208,24 +31220,24 @@ var require_dist_cjs65 = __commonJS({
       Object.assign(contents, doc);
       return contents;
     };
-    var de_StartAsyncInvokeCommand = async (output, context) => {
+    var de_StartAsyncInvokeCommand = async (output, context3) => {
       if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError3(output, context);
+        return de_CommandError3(output, context3);
       }
       const contents = smithyClient.map({
         $metadata: deserializeMetadata3(output)
       });
-      const data2 = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
+      const data2 = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context3)), "body");
       const doc = smithyClient.take(data2, {
         invocationArn: smithyClient.expectString
       });
       Object.assign(contents, doc);
       return contents;
     };
-    var de_CommandError3 = async (output, context) => {
+    var de_CommandError3 = async (output, context3) => {
       const parsedOutput = {
         ...output,
-        body: await core$1.parseJsonErrorBody(output.body, context)
+        body: await core$1.parseJsonErrorBody(output.body, context3)
       };
       const errorCode = core$1.loadRestJsonErrorCode(output, parsedOutput.body);
       switch (errorCode) {
@@ -31275,7 +31287,7 @@ var require_dist_cjs65 = __commonJS({
       }
     };
     var throwDefaultError3 = smithyClient.withBaseException(BedrockRuntimeServiceException);
-    var de_AccessDeniedExceptionRes2 = async (parsedOutput, context) => {
+    var de_AccessDeniedExceptionRes2 = async (parsedOutput, context3) => {
       const contents = smithyClient.map({});
       const data2 = parsedOutput.body;
       const doc = smithyClient.take(data2, {
@@ -31288,7 +31300,7 @@ var require_dist_cjs65 = __commonJS({
       });
       return smithyClient.decorateServiceException(exception, parsedOutput.body);
     };
-    var de_ConflictExceptionRes = async (parsedOutput, context) => {
+    var de_ConflictExceptionRes = async (parsedOutput, context3) => {
       const contents = smithyClient.map({});
       const data2 = parsedOutput.body;
       const doc = smithyClient.take(data2, {
@@ -31301,7 +31313,7 @@ var require_dist_cjs65 = __commonJS({
       });
       return smithyClient.decorateServiceException(exception, parsedOutput.body);
     };
-    var de_InternalServerExceptionRes2 = async (parsedOutput, context) => {
+    var de_InternalServerExceptionRes2 = async (parsedOutput, context3) => {
       const contents = smithyClient.map({});
       const data2 = parsedOutput.body;
       const doc = smithyClient.take(data2, {
@@ -31314,7 +31326,7 @@ var require_dist_cjs65 = __commonJS({
       });
       return smithyClient.decorateServiceException(exception, parsedOutput.body);
     };
-    var de_ModelErrorExceptionRes = async (parsedOutput, context) => {
+    var de_ModelErrorExceptionRes = async (parsedOutput, context3) => {
       const contents = smithyClient.map({});
       const data2 = parsedOutput.body;
       const doc = smithyClient.take(data2, {
@@ -31329,7 +31341,7 @@ var require_dist_cjs65 = __commonJS({
       });
       return smithyClient.decorateServiceException(exception, parsedOutput.body);
     };
-    var de_ModelNotReadyExceptionRes = async (parsedOutput, context) => {
+    var de_ModelNotReadyExceptionRes = async (parsedOutput, context3) => {
       const contents = smithyClient.map({});
       const data2 = parsedOutput.body;
       const doc = smithyClient.take(data2, {
@@ -31342,7 +31354,7 @@ var require_dist_cjs65 = __commonJS({
       });
       return smithyClient.decorateServiceException(exception, parsedOutput.body);
     };
-    var de_ModelStreamErrorExceptionRes = async (parsedOutput, context) => {
+    var de_ModelStreamErrorExceptionRes = async (parsedOutput, context3) => {
       const contents = smithyClient.map({});
       const data2 = parsedOutput.body;
       const doc = smithyClient.take(data2, {
@@ -31357,7 +31369,7 @@ var require_dist_cjs65 = __commonJS({
       });
       return smithyClient.decorateServiceException(exception, parsedOutput.body);
     };
-    var de_ModelTimeoutExceptionRes = async (parsedOutput, context) => {
+    var de_ModelTimeoutExceptionRes = async (parsedOutput, context3) => {
       const contents = smithyClient.map({});
       const data2 = parsedOutput.body;
       const doc = smithyClient.take(data2, {
@@ -31370,7 +31382,7 @@ var require_dist_cjs65 = __commonJS({
       });
       return smithyClient.decorateServiceException(exception, parsedOutput.body);
     };
-    var de_ResourceNotFoundExceptionRes = async (parsedOutput, context) => {
+    var de_ResourceNotFoundExceptionRes = async (parsedOutput, context3) => {
       const contents = smithyClient.map({});
       const data2 = parsedOutput.body;
       const doc = smithyClient.take(data2, {
@@ -31383,7 +31395,7 @@ var require_dist_cjs65 = __commonJS({
       });
       return smithyClient.decorateServiceException(exception, parsedOutput.body);
     };
-    var de_ServiceQuotaExceededExceptionRes = async (parsedOutput, context) => {
+    var de_ServiceQuotaExceededExceptionRes = async (parsedOutput, context3) => {
       const contents = smithyClient.map({});
       const data2 = parsedOutput.body;
       const doc = smithyClient.take(data2, {
@@ -31396,7 +31408,7 @@ var require_dist_cjs65 = __commonJS({
       });
       return smithyClient.decorateServiceException(exception, parsedOutput.body);
     };
-    var de_ServiceUnavailableExceptionRes = async (parsedOutput, context) => {
+    var de_ServiceUnavailableExceptionRes = async (parsedOutput, context3) => {
       const contents = smithyClient.map({});
       const data2 = parsedOutput.body;
       const doc = smithyClient.take(data2, {
@@ -31409,7 +31421,7 @@ var require_dist_cjs65 = __commonJS({
       });
       return smithyClient.decorateServiceException(exception, parsedOutput.body);
     };
-    var de_ThrottlingExceptionRes = async (parsedOutput, context) => {
+    var de_ThrottlingExceptionRes = async (parsedOutput, context3) => {
       const contents = smithyClient.map({});
       const data2 = parsedOutput.body;
       const doc = smithyClient.take(data2, {
@@ -31422,7 +31434,7 @@ var require_dist_cjs65 = __commonJS({
       });
       return smithyClient.decorateServiceException(exception, parsedOutput.body);
     };
-    var de_ValidationExceptionRes = async (parsedOutput, context) => {
+    var de_ValidationExceptionRes = async (parsedOutput, context3) => {
       const contents = smithyClient.map({});
       const data2 = parsedOutput.body;
       const doc = smithyClient.take(data2, {
@@ -31435,367 +31447,367 @@ var require_dist_cjs65 = __commonJS({
       });
       return smithyClient.decorateServiceException(exception, parsedOutput.body);
     };
-    var se_InvokeModelWithBidirectionalStreamInput = (input, context) => {
+    var se_InvokeModelWithBidirectionalStreamInput = (input, context3) => {
       const eventMarshallingVisitor = (event) => exports2.InvokeModelWithBidirectionalStreamInput.visit(event, {
-        chunk: (value) => se_BidirectionalInputPayloadPart_event(value, context),
+        chunk: (value) => se_BidirectionalInputPayloadPart_event(value, context3),
         _: (value) => value
       });
-      return context.eventStreamMarshaller.serialize(input, eventMarshallingVisitor);
+      return context3.eventStreamMarshaller.serialize(input, eventMarshallingVisitor);
     };
-    var se_BidirectionalInputPayloadPart_event = (input, context) => {
+    var se_BidirectionalInputPayloadPart_event = (input, context3) => {
       const headers = {
         ":event-type": { type: "string", value: "chunk" },
         ":message-type": { type: "string", value: "event" },
         ":content-type": { type: "string", value: "application/json" }
       };
       let body = new Uint8Array();
-      body = se_BidirectionalInputPayloadPart(input, context);
-      body = context.utf8Decoder(JSON.stringify(body));
+      body = se_BidirectionalInputPayloadPart(input, context3);
+      body = context3.utf8Decoder(JSON.stringify(body));
       return { headers, body };
     };
-    var de_ConverseStreamOutput = (output, context) => {
-      return context.eventStreamMarshaller.deserialize(output, async (event) => {
+    var de_ConverseStreamOutput = (output, context3) => {
+      return context3.eventStreamMarshaller.deserialize(output, async (event) => {
         if (event["messageStart"] != null) {
           return {
-            messageStart: await de_MessageStartEvent_event(event["messageStart"], context)
+            messageStart: await de_MessageStartEvent_event(event["messageStart"], context3)
           };
         }
         if (event["contentBlockStart"] != null) {
           return {
-            contentBlockStart: await de_ContentBlockStartEvent_event(event["contentBlockStart"], context)
+            contentBlockStart: await de_ContentBlockStartEvent_event(event["contentBlockStart"], context3)
           };
         }
         if (event["contentBlockDelta"] != null) {
           return {
-            contentBlockDelta: await de_ContentBlockDeltaEvent_event(event["contentBlockDelta"], context)
+            contentBlockDelta: await de_ContentBlockDeltaEvent_event(event["contentBlockDelta"], context3)
           };
         }
         if (event["contentBlockStop"] != null) {
           return {
-            contentBlockStop: await de_ContentBlockStopEvent_event(event["contentBlockStop"], context)
+            contentBlockStop: await de_ContentBlockStopEvent_event(event["contentBlockStop"], context3)
           };
         }
         if (event["messageStop"] != null) {
           return {
-            messageStop: await de_MessageStopEvent_event(event["messageStop"], context)
+            messageStop: await de_MessageStopEvent_event(event["messageStop"], context3)
           };
         }
         if (event["metadata"] != null) {
           return {
-            metadata: await de_ConverseStreamMetadataEvent_event(event["metadata"], context)
+            metadata: await de_ConverseStreamMetadataEvent_event(event["metadata"], context3)
           };
         }
         if (event["internalServerException"] != null) {
           return {
-            internalServerException: await de_InternalServerException_event(event["internalServerException"], context)
+            internalServerException: await de_InternalServerException_event(event["internalServerException"], context3)
           };
         }
         if (event["modelStreamErrorException"] != null) {
           return {
-            modelStreamErrorException: await de_ModelStreamErrorException_event(event["modelStreamErrorException"], context)
+            modelStreamErrorException: await de_ModelStreamErrorException_event(event["modelStreamErrorException"], context3)
           };
         }
         if (event["validationException"] != null) {
           return {
-            validationException: await de_ValidationException_event(event["validationException"], context)
+            validationException: await de_ValidationException_event(event["validationException"], context3)
           };
         }
         if (event["throttlingException"] != null) {
           return {
-            throttlingException: await de_ThrottlingException_event(event["throttlingException"], context)
+            throttlingException: await de_ThrottlingException_event(event["throttlingException"], context3)
           };
         }
         if (event["serviceUnavailableException"] != null) {
           return {
-            serviceUnavailableException: await de_ServiceUnavailableException_event(event["serviceUnavailableException"], context)
+            serviceUnavailableException: await de_ServiceUnavailableException_event(event["serviceUnavailableException"], context3)
           };
         }
         return { $unknown: event };
       });
     };
-    var de_InvokeModelWithBidirectionalStreamOutput = (output, context) => {
-      return context.eventStreamMarshaller.deserialize(output, async (event) => {
+    var de_InvokeModelWithBidirectionalStreamOutput = (output, context3) => {
+      return context3.eventStreamMarshaller.deserialize(output, async (event) => {
         if (event["chunk"] != null) {
           return {
-            chunk: await de_BidirectionalOutputPayloadPart_event(event["chunk"], context)
+            chunk: await de_BidirectionalOutputPayloadPart_event(event["chunk"], context3)
           };
         }
         if (event["internalServerException"] != null) {
           return {
-            internalServerException: await de_InternalServerException_event(event["internalServerException"], context)
+            internalServerException: await de_InternalServerException_event(event["internalServerException"], context3)
           };
         }
         if (event["modelStreamErrorException"] != null) {
           return {
-            modelStreamErrorException: await de_ModelStreamErrorException_event(event["modelStreamErrorException"], context)
+            modelStreamErrorException: await de_ModelStreamErrorException_event(event["modelStreamErrorException"], context3)
           };
         }
         if (event["validationException"] != null) {
           return {
-            validationException: await de_ValidationException_event(event["validationException"], context)
+            validationException: await de_ValidationException_event(event["validationException"], context3)
           };
         }
         if (event["throttlingException"] != null) {
           return {
-            throttlingException: await de_ThrottlingException_event(event["throttlingException"], context)
+            throttlingException: await de_ThrottlingException_event(event["throttlingException"], context3)
           };
         }
         if (event["modelTimeoutException"] != null) {
           return {
-            modelTimeoutException: await de_ModelTimeoutException_event(event["modelTimeoutException"], context)
+            modelTimeoutException: await de_ModelTimeoutException_event(event["modelTimeoutException"], context3)
           };
         }
         if (event["serviceUnavailableException"] != null) {
           return {
-            serviceUnavailableException: await de_ServiceUnavailableException_event(event["serviceUnavailableException"], context)
+            serviceUnavailableException: await de_ServiceUnavailableException_event(event["serviceUnavailableException"], context3)
           };
         }
         return { $unknown: event };
       });
     };
-    var de_ResponseStream = (output, context) => {
-      return context.eventStreamMarshaller.deserialize(output, async (event) => {
+    var de_ResponseStream = (output, context3) => {
+      return context3.eventStreamMarshaller.deserialize(output, async (event) => {
         if (event["chunk"] != null) {
           return {
-            chunk: await de_PayloadPart_event(event["chunk"], context)
+            chunk: await de_PayloadPart_event(event["chunk"], context3)
           };
         }
         if (event["internalServerException"] != null) {
           return {
-            internalServerException: await de_InternalServerException_event(event["internalServerException"], context)
+            internalServerException: await de_InternalServerException_event(event["internalServerException"], context3)
           };
         }
         if (event["modelStreamErrorException"] != null) {
           return {
-            modelStreamErrorException: await de_ModelStreamErrorException_event(event["modelStreamErrorException"], context)
+            modelStreamErrorException: await de_ModelStreamErrorException_event(event["modelStreamErrorException"], context3)
           };
         }
         if (event["validationException"] != null) {
           return {
-            validationException: await de_ValidationException_event(event["validationException"], context)
+            validationException: await de_ValidationException_event(event["validationException"], context3)
           };
         }
         if (event["throttlingException"] != null) {
           return {
-            throttlingException: await de_ThrottlingException_event(event["throttlingException"], context)
+            throttlingException: await de_ThrottlingException_event(event["throttlingException"], context3)
           };
         }
         if (event["modelTimeoutException"] != null) {
           return {
-            modelTimeoutException: await de_ModelTimeoutException_event(event["modelTimeoutException"], context)
+            modelTimeoutException: await de_ModelTimeoutException_event(event["modelTimeoutException"], context3)
           };
         }
         if (event["serviceUnavailableException"] != null) {
           return {
-            serviceUnavailableException: await de_ServiceUnavailableException_event(event["serviceUnavailableException"], context)
+            serviceUnavailableException: await de_ServiceUnavailableException_event(event["serviceUnavailableException"], context3)
           };
         }
         return { $unknown: event };
       });
     };
-    var de_BidirectionalOutputPayloadPart_event = async (output, context) => {
+    var de_BidirectionalOutputPayloadPart_event = async (output, context3) => {
       const contents = {};
-      const data2 = await core$1.parseJsonBody(output.body, context);
-      Object.assign(contents, de_BidirectionalOutputPayloadPart(data2, context));
+      const data2 = await core$1.parseJsonBody(output.body, context3);
+      Object.assign(contents, de_BidirectionalOutputPayloadPart(data2, context3));
       return contents;
     };
-    var de_ContentBlockDeltaEvent_event = async (output, context) => {
+    var de_ContentBlockDeltaEvent_event = async (output, context3) => {
       const contents = {};
-      const data2 = await core$1.parseJsonBody(output.body, context);
-      Object.assign(contents, de_ContentBlockDeltaEvent(data2, context));
+      const data2 = await core$1.parseJsonBody(output.body, context3);
+      Object.assign(contents, de_ContentBlockDeltaEvent(data2, context3));
       return contents;
     };
-    var de_ContentBlockStartEvent_event = async (output, context) => {
+    var de_ContentBlockStartEvent_event = async (output, context3) => {
       const contents = {};
-      const data2 = await core$1.parseJsonBody(output.body, context);
+      const data2 = await core$1.parseJsonBody(output.body, context3);
       Object.assign(contents, smithyClient._json(data2));
       return contents;
     };
-    var de_ContentBlockStopEvent_event = async (output, context) => {
+    var de_ContentBlockStopEvent_event = async (output, context3) => {
       const contents = {};
-      const data2 = await core$1.parseJsonBody(output.body, context);
+      const data2 = await core$1.parseJsonBody(output.body, context3);
       Object.assign(contents, smithyClient._json(data2));
       return contents;
     };
-    var de_ConverseStreamMetadataEvent_event = async (output, context) => {
+    var de_ConverseStreamMetadataEvent_event = async (output, context3) => {
       const contents = {};
-      const data2 = await core$1.parseJsonBody(output.body, context);
+      const data2 = await core$1.parseJsonBody(output.body, context3);
       Object.assign(contents, de_ConverseStreamMetadataEvent(data2));
       return contents;
     };
-    var de_InternalServerException_event = async (output, context) => {
+    var de_InternalServerException_event = async (output, context3) => {
       const parsedOutput = {
         ...output,
-        body: await core$1.parseJsonBody(output.body, context)
+        body: await core$1.parseJsonBody(output.body, context3)
       };
       return de_InternalServerExceptionRes2(parsedOutput);
     };
-    var de_MessageStartEvent_event = async (output, context) => {
+    var de_MessageStartEvent_event = async (output, context3) => {
       const contents = {};
-      const data2 = await core$1.parseJsonBody(output.body, context);
+      const data2 = await core$1.parseJsonBody(output.body, context3);
       Object.assign(contents, smithyClient._json(data2));
       return contents;
     };
-    var de_MessageStopEvent_event = async (output, context) => {
+    var de_MessageStopEvent_event = async (output, context3) => {
       const contents = {};
-      const data2 = await core$1.parseJsonBody(output.body, context);
+      const data2 = await core$1.parseJsonBody(output.body, context3);
       Object.assign(contents, de_MessageStopEvent(data2));
       return contents;
     };
-    var de_ModelStreamErrorException_event = async (output, context) => {
+    var de_ModelStreamErrorException_event = async (output, context3) => {
       const parsedOutput = {
         ...output,
-        body: await core$1.parseJsonBody(output.body, context)
+        body: await core$1.parseJsonBody(output.body, context3)
       };
       return de_ModelStreamErrorExceptionRes(parsedOutput);
     };
-    var de_ModelTimeoutException_event = async (output, context) => {
+    var de_ModelTimeoutException_event = async (output, context3) => {
       const parsedOutput = {
         ...output,
-        body: await core$1.parseJsonBody(output.body, context)
+        body: await core$1.parseJsonBody(output.body, context3)
       };
       return de_ModelTimeoutExceptionRes(parsedOutput);
     };
-    var de_PayloadPart_event = async (output, context) => {
+    var de_PayloadPart_event = async (output, context3) => {
       const contents = {};
-      const data2 = await core$1.parseJsonBody(output.body, context);
-      Object.assign(contents, de_PayloadPart(data2, context));
+      const data2 = await core$1.parseJsonBody(output.body, context3);
+      Object.assign(contents, de_PayloadPart(data2, context3));
       return contents;
     };
-    var de_ServiceUnavailableException_event = async (output, context) => {
+    var de_ServiceUnavailableException_event = async (output, context3) => {
       const parsedOutput = {
         ...output,
-        body: await core$1.parseJsonBody(output.body, context)
+        body: await core$1.parseJsonBody(output.body, context3)
       };
       return de_ServiceUnavailableExceptionRes(parsedOutput);
     };
-    var de_ThrottlingException_event = async (output, context) => {
+    var de_ThrottlingException_event = async (output, context3) => {
       const parsedOutput = {
         ...output,
-        body: await core$1.parseJsonBody(output.body, context)
+        body: await core$1.parseJsonBody(output.body, context3)
       };
       return de_ThrottlingExceptionRes(parsedOutput);
     };
-    var de_ValidationException_event = async (output, context) => {
+    var de_ValidationException_event = async (output, context3) => {
       const parsedOutput = {
         ...output,
-        body: await core$1.parseJsonBody(output.body, context)
+        body: await core$1.parseJsonBody(output.body, context3)
       };
       return de_ValidationExceptionRes(parsedOutput);
     };
-    var se_BidirectionalInputPayloadPart = (input, context) => {
+    var se_BidirectionalInputPayloadPart = (input, context3) => {
       return smithyClient.take(input, {
-        bytes: context.base64Encoder
+        bytes: context3.base64Encoder
       });
     };
-    var se_ContentBlock = (input, context) => {
+    var se_ContentBlock = (input, context3) => {
       return exports2.ContentBlock.visit(input, {
         cachePoint: (value) => ({ cachePoint: smithyClient._json(value) }),
         citationsContent: (value) => ({ citationsContent: smithyClient._json(value) }),
-        document: (value) => ({ document: se_DocumentBlock(value, context) }),
-        guardContent: (value) => ({ guardContent: se_GuardrailConverseContentBlock(value, context) }),
-        image: (value) => ({ image: se_ImageBlock(value, context) }),
-        reasoningContent: (value) => ({ reasoningContent: se_ReasoningContentBlock(value, context) }),
+        document: (value) => ({ document: se_DocumentBlock(value, context3) }),
+        guardContent: (value) => ({ guardContent: se_GuardrailConverseContentBlock(value, context3) }),
+        image: (value) => ({ image: se_ImageBlock(value, context3) }),
+        reasoningContent: (value) => ({ reasoningContent: se_ReasoningContentBlock(value, context3) }),
         text: (value) => ({ text: value }),
-        toolResult: (value) => ({ toolResult: se_ToolResultBlock(value, context) }),
+        toolResult: (value) => ({ toolResult: se_ToolResultBlock(value, context3) }),
         toolUse: (value) => ({ toolUse: se_ToolUseBlock(value) }),
-        video: (value) => ({ video: se_VideoBlock(value, context) }),
+        video: (value) => ({ video: se_VideoBlock(value, context3) }),
         _: (name14, value) => ({ [name14]: value })
       });
     };
-    var se_ContentBlocks = (input, context) => {
+    var se_ContentBlocks = (input, context3) => {
       return input.filter((e3) => e3 != null).map((entry) => {
-        return se_ContentBlock(entry, context);
+        return se_ContentBlock(entry, context3);
       });
     };
-    var se_ConverseTokensRequest = (input, context) => {
+    var se_ConverseTokensRequest = (input, context3) => {
       return smithyClient.take(input, {
-        messages: (_2) => se_Messages(_2, context),
-        system: (_2) => se_SystemContentBlocks(_2, context)
+        messages: (_2) => se_Messages(_2, context3),
+        system: (_2) => se_SystemContentBlocks(_2, context3)
       });
     };
-    var se_CountTokensInput = (input, context) => {
+    var se_CountTokensInput = (input, context3) => {
       return exports2.CountTokensInput.visit(input, {
-        converse: (value) => ({ converse: se_ConverseTokensRequest(value, context) }),
-        invokeModel: (value) => ({ invokeModel: se_InvokeModelTokensRequest(value, context) }),
+        converse: (value) => ({ converse: se_ConverseTokensRequest(value, context3) }),
+        invokeModel: (value) => ({ invokeModel: se_InvokeModelTokensRequest(value, context3) }),
         _: (name14, value) => ({ [name14]: value })
       });
     };
-    var se_DocumentBlock = (input, context) => {
+    var se_DocumentBlock = (input, context3) => {
       return smithyClient.take(input, {
         citations: smithyClient._json,
         context: [],
         format: [],
         name: [],
-        source: (_2) => se_DocumentSource(_2, context)
+        source: (_2) => se_DocumentSource(_2, context3)
       });
     };
-    var se_DocumentSource = (input, context) => {
+    var se_DocumentSource = (input, context3) => {
       return exports2.DocumentSource.visit(input, {
-        bytes: (value) => ({ bytes: context.base64Encoder(value) }),
+        bytes: (value) => ({ bytes: context3.base64Encoder(value) }),
         content: (value) => ({ content: smithyClient._json(value) }),
         s3Location: (value) => ({ s3Location: smithyClient._json(value) }),
         text: (value) => ({ text: value }),
         _: (name14, value) => ({ [name14]: value })
       });
     };
-    var se_GuardrailContentBlock = (input, context) => {
+    var se_GuardrailContentBlock = (input, context3) => {
       return exports2.GuardrailContentBlock.visit(input, {
-        image: (value) => ({ image: se_GuardrailImageBlock(value, context) }),
+        image: (value) => ({ image: se_GuardrailImageBlock(value, context3) }),
         text: (value) => ({ text: smithyClient._json(value) }),
         _: (name14, value) => ({ [name14]: value })
       });
     };
-    var se_GuardrailContentBlockList = (input, context) => {
+    var se_GuardrailContentBlockList = (input, context3) => {
       return input.filter((e3) => e3 != null).map((entry) => {
-        return se_GuardrailContentBlock(entry, context);
+        return se_GuardrailContentBlock(entry, context3);
       });
     };
-    var se_GuardrailConverseContentBlock = (input, context) => {
+    var se_GuardrailConverseContentBlock = (input, context3) => {
       return exports2.GuardrailConverseContentBlock.visit(input, {
-        image: (value) => ({ image: se_GuardrailConverseImageBlock(value, context) }),
+        image: (value) => ({ image: se_GuardrailConverseImageBlock(value, context3) }),
         text: (value) => ({ text: smithyClient._json(value) }),
         _: (name14, value) => ({ [name14]: value })
       });
     };
-    var se_GuardrailConverseImageBlock = (input, context) => {
+    var se_GuardrailConverseImageBlock = (input, context3) => {
       return smithyClient.take(input, {
         format: [],
-        source: (_2) => se_GuardrailConverseImageSource(_2, context)
+        source: (_2) => se_GuardrailConverseImageSource(_2, context3)
       });
     };
-    var se_GuardrailConverseImageSource = (input, context) => {
+    var se_GuardrailConverseImageSource = (input, context3) => {
       return exports2.GuardrailConverseImageSource.visit(input, {
-        bytes: (value) => ({ bytes: context.base64Encoder(value) }),
+        bytes: (value) => ({ bytes: context3.base64Encoder(value) }),
         _: (name14, value) => ({ [name14]: value })
       });
     };
-    var se_GuardrailImageBlock = (input, context) => {
+    var se_GuardrailImageBlock = (input, context3) => {
       return smithyClient.take(input, {
         format: [],
-        source: (_2) => se_GuardrailImageSource(_2, context)
+        source: (_2) => se_GuardrailImageSource(_2, context3)
       });
     };
-    var se_GuardrailImageSource = (input, context) => {
+    var se_GuardrailImageSource = (input, context3) => {
       return exports2.GuardrailImageSource.visit(input, {
-        bytes: (value) => ({ bytes: context.base64Encoder(value) }),
+        bytes: (value) => ({ bytes: context3.base64Encoder(value) }),
         _: (name14, value) => ({ [name14]: value })
       });
     };
-    var se_ImageBlock = (input, context) => {
+    var se_ImageBlock = (input, context3) => {
       return smithyClient.take(input, {
         format: [],
-        source: (_2) => se_ImageSource(_2, context)
+        source: (_2) => se_ImageSource(_2, context3)
       });
     };
-    var se_ImageSource = (input, context) => {
+    var se_ImageSource = (input, context3) => {
       return exports2.ImageSource.visit(input, {
-        bytes: (value) => ({ bytes: context.base64Encoder(value) }),
+        bytes: (value) => ({ bytes: context3.base64Encoder(value) }),
         s3Location: (value) => ({ s3Location: smithyClient._json(value) }),
         _: (name14, value) => ({ [name14]: value })
       });
     };
-    var se_InferenceConfiguration = (input, context) => {
+    var se_InferenceConfiguration = (input, context3) => {
       return smithyClient.take(input, {
         maxTokens: [],
         stopSequences: smithyClient._json,
@@ -31803,128 +31815,128 @@ var require_dist_cjs65 = __commonJS({
         topP: smithyClient.serializeFloat
       });
     };
-    var se_InvokeModelTokensRequest = (input, context) => {
+    var se_InvokeModelTokensRequest = (input, context3) => {
       return smithyClient.take(input, {
-        body: context.base64Encoder
+        body: context3.base64Encoder
       });
     };
-    var se_Message = (input, context) => {
+    var se_Message = (input, context3) => {
       return smithyClient.take(input, {
-        content: (_2) => se_ContentBlocks(_2, context),
+        content: (_2) => se_ContentBlocks(_2, context3),
         role: []
       });
     };
-    var se_Messages = (input, context) => {
+    var se_Messages = (input, context3) => {
       return input.filter((e3) => e3 != null).map((entry) => {
-        return se_Message(entry, context);
+        return se_Message(entry, context3);
       });
     };
-    var se_ModelInputPayload = (input, context) => {
+    var se_ModelInputPayload = (input, context3) => {
       return input;
     };
-    var se_ReasoningContentBlock = (input, context) => {
+    var se_ReasoningContentBlock = (input, context3) => {
       return exports2.ReasoningContentBlock.visit(input, {
         reasoningText: (value) => ({ reasoningText: smithyClient._json(value) }),
-        redactedContent: (value) => ({ redactedContent: context.base64Encoder(value) }),
+        redactedContent: (value) => ({ redactedContent: context3.base64Encoder(value) }),
         _: (name14, value) => ({ [name14]: value })
       });
     };
-    var se_SystemContentBlock = (input, context) => {
+    var se_SystemContentBlock = (input, context3) => {
       return exports2.SystemContentBlock.visit(input, {
         cachePoint: (value) => ({ cachePoint: smithyClient._json(value) }),
-        guardContent: (value) => ({ guardContent: se_GuardrailConverseContentBlock(value, context) }),
+        guardContent: (value) => ({ guardContent: se_GuardrailConverseContentBlock(value, context3) }),
         text: (value) => ({ text: value }),
         _: (name14, value) => ({ [name14]: value })
       });
     };
-    var se_SystemContentBlocks = (input, context) => {
+    var se_SystemContentBlocks = (input, context3) => {
       return input.filter((e3) => e3 != null).map((entry) => {
-        return se_SystemContentBlock(entry, context);
+        return se_SystemContentBlock(entry, context3);
       });
     };
-    var se_Tool = (input, context) => {
+    var se_Tool = (input, context3) => {
       return exports2.Tool.visit(input, {
         cachePoint: (value) => ({ cachePoint: smithyClient._json(value) }),
         toolSpec: (value) => ({ toolSpec: se_ToolSpecification(value) }),
         _: (name14, value) => ({ [name14]: value })
       });
     };
-    var se_ToolConfiguration = (input, context) => {
+    var se_ToolConfiguration = (input, context3) => {
       return smithyClient.take(input, {
         toolChoice: smithyClient._json,
         tools: (_2) => se_Tools(_2)
       });
     };
-    var se_ToolInputSchema = (input, context) => {
+    var se_ToolInputSchema = (input, context3) => {
       return exports2.ToolInputSchema.visit(input, {
         json: (value) => ({ json: se_Document(value) }),
         _: (name14, value) => ({ [name14]: value })
       });
     };
-    var se_ToolResultBlock = (input, context) => {
+    var se_ToolResultBlock = (input, context3) => {
       return smithyClient.take(input, {
-        content: (_2) => se_ToolResultContentBlocks(_2, context),
+        content: (_2) => se_ToolResultContentBlocks(_2, context3),
         status: [],
         toolUseId: []
       });
     };
-    var se_ToolResultContentBlock = (input, context) => {
+    var se_ToolResultContentBlock = (input, context3) => {
       return exports2.ToolResultContentBlock.visit(input, {
-        document: (value) => ({ document: se_DocumentBlock(value, context) }),
-        image: (value) => ({ image: se_ImageBlock(value, context) }),
+        document: (value) => ({ document: se_DocumentBlock(value, context3) }),
+        image: (value) => ({ image: se_ImageBlock(value, context3) }),
         json: (value) => ({ json: se_Document(value) }),
         text: (value) => ({ text: value }),
-        video: (value) => ({ video: se_VideoBlock(value, context) }),
+        video: (value) => ({ video: se_VideoBlock(value, context3) }),
         _: (name14, value) => ({ [name14]: value })
       });
     };
-    var se_ToolResultContentBlocks = (input, context) => {
+    var se_ToolResultContentBlocks = (input, context3) => {
       return input.filter((e3) => e3 != null).map((entry) => {
-        return se_ToolResultContentBlock(entry, context);
+        return se_ToolResultContentBlock(entry, context3);
       });
     };
-    var se_Tools = (input, context) => {
+    var se_Tools = (input, context3) => {
       return input.filter((e3) => e3 != null).map((entry) => {
         return se_Tool(entry);
       });
     };
-    var se_ToolSpecification = (input, context) => {
+    var se_ToolSpecification = (input, context3) => {
       return smithyClient.take(input, {
         description: [],
         inputSchema: (_2) => se_ToolInputSchema(_2),
         name: []
       });
     };
-    var se_ToolUseBlock = (input, context) => {
+    var se_ToolUseBlock = (input, context3) => {
       return smithyClient.take(input, {
         input: (_2) => se_Document(_2),
         name: [],
         toolUseId: []
       });
     };
-    var se_VideoBlock = (input, context) => {
+    var se_VideoBlock = (input, context3) => {
       return smithyClient.take(input, {
         format: [],
-        source: (_2) => se_VideoSource(_2, context)
+        source: (_2) => se_VideoSource(_2, context3)
       });
     };
-    var se_VideoSource = (input, context) => {
+    var se_VideoSource = (input, context3) => {
       return exports2.VideoSource.visit(input, {
-        bytes: (value) => ({ bytes: context.base64Encoder(value) }),
+        bytes: (value) => ({ bytes: context3.base64Encoder(value) }),
         s3Location: (value) => ({ s3Location: smithyClient._json(value) }),
         _: (name14, value) => ({ [name14]: value })
       });
     };
-    var se_Document = (input, context) => {
+    var se_Document = (input, context3) => {
       return input;
     };
-    var de_AsyncInvokeSummaries = (output, context) => {
+    var de_AsyncInvokeSummaries = (output, context3) => {
       const retVal = (output || []).filter((e3) => e3 != null).map((entry) => {
         return de_AsyncInvokeSummary(entry);
       });
       return retVal;
     };
-    var de_AsyncInvokeSummary = (output, context) => {
+    var de_AsyncInvokeSummary = (output, context3) => {
       return smithyClient.take(output, {
         clientRequestToken: smithyClient.expectString,
         endTime: (_2) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_2)),
@@ -31937,12 +31949,12 @@ var require_dist_cjs65 = __commonJS({
         submitTime: (_2) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_2))
       });
     };
-    var de_BidirectionalOutputPayloadPart = (output, context) => {
+    var de_BidirectionalOutputPayloadPart = (output, context3) => {
       return smithyClient.take(output, {
-        bytes: context.base64Decoder
+        bytes: context3.base64Decoder
       });
     };
-    var de_ContentBlock = (output, context) => {
+    var de_ContentBlock = (output, context3) => {
       if (output.cachePoint != null) {
         return {
           cachePoint: smithyClient._json(output.cachePoint)
@@ -31955,22 +31967,22 @@ var require_dist_cjs65 = __commonJS({
       }
       if (output.document != null) {
         return {
-          document: de_DocumentBlock(output.document, context)
+          document: de_DocumentBlock(output.document, context3)
         };
       }
       if (output.guardContent != null) {
         return {
-          guardContent: de_GuardrailConverseContentBlock(core$1.awsExpectUnion(output.guardContent), context)
+          guardContent: de_GuardrailConverseContentBlock(core$1.awsExpectUnion(output.guardContent), context3)
         };
       }
       if (output.image != null) {
         return {
-          image: de_ImageBlock(output.image, context)
+          image: de_ImageBlock(output.image, context3)
         };
       }
       if (output.reasoningContent != null) {
         return {
-          reasoningContent: de_ReasoningContentBlock(core$1.awsExpectUnion(output.reasoningContent), context)
+          reasoningContent: de_ReasoningContentBlock(core$1.awsExpectUnion(output.reasoningContent), context3)
         };
       }
       if (smithyClient.expectString(output.text) !== void 0) {
@@ -31978,7 +31990,7 @@ var require_dist_cjs65 = __commonJS({
       }
       if (output.toolResult != null) {
         return {
-          toolResult: de_ToolResultBlock(output.toolResult, context)
+          toolResult: de_ToolResultBlock(output.toolResult, context3)
         };
       }
       if (output.toolUse != null) {
@@ -31988,12 +32000,12 @@ var require_dist_cjs65 = __commonJS({
       }
       if (output.video != null) {
         return {
-          video: de_VideoBlock(output.video, context)
+          video: de_VideoBlock(output.video, context3)
         };
       }
       return { $unknown: Object.entries(output)[0] };
     };
-    var de_ContentBlockDelta = (output, context) => {
+    var de_ContentBlockDelta = (output, context3) => {
       if (output.citation != null) {
         return {
           citation: smithyClient._json(output.citation)
@@ -32001,7 +32013,7 @@ var require_dist_cjs65 = __commonJS({
       }
       if (output.reasoningContent != null) {
         return {
-          reasoningContent: de_ReasoningContentBlockDelta(core$1.awsExpectUnion(output.reasoningContent), context)
+          reasoningContent: de_ReasoningContentBlockDelta(core$1.awsExpectUnion(output.reasoningContent), context3)
         };
       }
       if (smithyClient.expectString(output.text) !== void 0) {
@@ -32014,27 +32026,27 @@ var require_dist_cjs65 = __commonJS({
       }
       return { $unknown: Object.entries(output)[0] };
     };
-    var de_ContentBlockDeltaEvent = (output, context) => {
+    var de_ContentBlockDeltaEvent = (output, context3) => {
       return smithyClient.take(output, {
         contentBlockIndex: smithyClient.expectInt32,
-        delta: (_2) => de_ContentBlockDelta(core$1.awsExpectUnion(_2), context)
+        delta: (_2) => de_ContentBlockDelta(core$1.awsExpectUnion(_2), context3)
       });
     };
-    var de_ContentBlocks = (output, context) => {
+    var de_ContentBlocks = (output, context3) => {
       const retVal = (output || []).filter((e3) => e3 != null).map((entry) => {
-        return de_ContentBlock(core$1.awsExpectUnion(entry), context);
+        return de_ContentBlock(core$1.awsExpectUnion(entry), context3);
       });
       return retVal;
     };
-    var de_ConverseOutput = (output, context) => {
+    var de_ConverseOutput = (output, context3) => {
       if (output.message != null) {
         return {
-          message: de_Message(output.message, context)
+          message: de_Message(output.message, context3)
         };
       }
       return { $unknown: Object.entries(output)[0] };
     };
-    var de_ConverseStreamMetadataEvent = (output, context) => {
+    var de_ConverseStreamMetadataEvent = (output, context3) => {
       return smithyClient.take(output, {
         metrics: smithyClient._json,
         performanceConfig: smithyClient._json,
@@ -32042,31 +32054,31 @@ var require_dist_cjs65 = __commonJS({
         usage: smithyClient._json
       });
     };
-    var de_ConverseStreamTrace = (output, context) => {
+    var de_ConverseStreamTrace = (output, context3) => {
       return smithyClient.take(output, {
         guardrail: (_2) => de_GuardrailTraceAssessment(_2),
         promptRouter: smithyClient._json
       });
     };
-    var de_ConverseTrace = (output, context) => {
+    var de_ConverseTrace = (output, context3) => {
       return smithyClient.take(output, {
         guardrail: (_2) => de_GuardrailTraceAssessment(_2),
         promptRouter: smithyClient._json
       });
     };
-    var de_DocumentBlock = (output, context) => {
+    var de_DocumentBlock = (output, context3) => {
       return smithyClient.take(output, {
         citations: smithyClient._json,
         context: smithyClient.expectString,
         format: smithyClient.expectString,
         name: smithyClient.expectString,
-        source: (_2) => de_DocumentSource(core$1.awsExpectUnion(_2), context)
+        source: (_2) => de_DocumentSource(core$1.awsExpectUnion(_2), context3)
       });
     };
-    var de_DocumentSource = (output, context) => {
+    var de_DocumentSource = (output, context3) => {
       if (output.bytes != null) {
         return {
-          bytes: context.base64Decoder(output.bytes)
+          bytes: context3.base64Decoder(output.bytes)
         };
       }
       if (output.content != null) {
@@ -32084,7 +32096,7 @@ var require_dist_cjs65 = __commonJS({
       }
       return { $unknown: Object.entries(output)[0] };
     };
-    var de_GuardrailAssessment = (output, context) => {
+    var de_GuardrailAssessment = (output, context3) => {
       return smithyClient.take(output, {
         automatedReasoningPolicy: (_2) => de_GuardrailAutomatedReasoningPolicyAssessment(_2),
         contentPolicy: smithyClient._json,
@@ -32095,13 +32107,13 @@ var require_dist_cjs65 = __commonJS({
         wordPolicy: smithyClient._json
       });
     };
-    var de_GuardrailAssessmentList = (output, context) => {
+    var de_GuardrailAssessmentList = (output, context3) => {
       const retVal = (output || []).filter((e3) => e3 != null).map((entry) => {
         return de_GuardrailAssessment(entry);
       });
       return retVal;
     };
-    var de_GuardrailAssessmentListMap = (output, context) => {
+    var de_GuardrailAssessmentListMap = (output, context3) => {
       return Object.entries(output).reduce((acc, [key, value]) => {
         if (value === null) {
           return acc;
@@ -32110,7 +32122,7 @@ var require_dist_cjs65 = __commonJS({
         return acc;
       }, {});
     };
-    var de_GuardrailAssessmentMap = (output, context) => {
+    var de_GuardrailAssessmentMap = (output, context3) => {
       return Object.entries(output).reduce((acc, [key, value]) => {
         if (value === null) {
           return acc;
@@ -32119,7 +32131,7 @@ var require_dist_cjs65 = __commonJS({
         return acc;
       }, {});
     };
-    var de_GuardrailAutomatedReasoningFinding = (output, context) => {
+    var de_GuardrailAutomatedReasoningFinding = (output, context3) => {
       if (output.impossible != null) {
         return {
           impossible: de_GuardrailAutomatedReasoningImpossibleFinding(output.impossible)
@@ -32157,32 +32169,32 @@ var require_dist_cjs65 = __commonJS({
       }
       return { $unknown: Object.entries(output)[0] };
     };
-    var de_GuardrailAutomatedReasoningFindingList = (output, context) => {
+    var de_GuardrailAutomatedReasoningFindingList = (output, context3) => {
       const retVal = (output || []).filter((e3) => e3 != null).map((entry) => {
         return de_GuardrailAutomatedReasoningFinding(core$1.awsExpectUnion(entry));
       });
       return retVal;
     };
-    var de_GuardrailAutomatedReasoningImpossibleFinding = (output, context) => {
+    var de_GuardrailAutomatedReasoningImpossibleFinding = (output, context3) => {
       return smithyClient.take(output, {
         contradictingRules: smithyClient._json,
         logicWarning: smithyClient._json,
         translation: (_2) => de_GuardrailAutomatedReasoningTranslation(_2)
       });
     };
-    var de_GuardrailAutomatedReasoningInvalidFinding = (output, context) => {
+    var de_GuardrailAutomatedReasoningInvalidFinding = (output, context3) => {
       return smithyClient.take(output, {
         contradictingRules: smithyClient._json,
         logicWarning: smithyClient._json,
         translation: (_2) => de_GuardrailAutomatedReasoningTranslation(_2)
       });
     };
-    var de_GuardrailAutomatedReasoningPolicyAssessment = (output, context) => {
+    var de_GuardrailAutomatedReasoningPolicyAssessment = (output, context3) => {
       return smithyClient.take(output, {
         findings: (_2) => de_GuardrailAutomatedReasoningFindingList(_2)
       });
     };
-    var de_GuardrailAutomatedReasoningSatisfiableFinding = (output, context) => {
+    var de_GuardrailAutomatedReasoningSatisfiableFinding = (output, context3) => {
       return smithyClient.take(output, {
         claimsFalseScenario: smithyClient._json,
         claimsTrueScenario: smithyClient._json,
@@ -32190,7 +32202,7 @@ var require_dist_cjs65 = __commonJS({
         translation: (_2) => de_GuardrailAutomatedReasoningTranslation(_2)
       });
     };
-    var de_GuardrailAutomatedReasoningTranslation = (output, context) => {
+    var de_GuardrailAutomatedReasoningTranslation = (output, context3) => {
       return smithyClient.take(output, {
         claims: smithyClient._json,
         confidence: smithyClient.limitedParseDouble,
@@ -32199,30 +32211,30 @@ var require_dist_cjs65 = __commonJS({
         untranslatedPremises: smithyClient._json
       });
     };
-    var de_GuardrailAutomatedReasoningTranslationAmbiguousFinding = (output, context) => {
+    var de_GuardrailAutomatedReasoningTranslationAmbiguousFinding = (output, context3) => {
       return smithyClient.take(output, {
         differenceScenarios: smithyClient._json,
         options: (_2) => de_GuardrailAutomatedReasoningTranslationOptionList(_2)
       });
     };
-    var de_GuardrailAutomatedReasoningTranslationList = (output, context) => {
+    var de_GuardrailAutomatedReasoningTranslationList = (output, context3) => {
       const retVal = (output || []).filter((e3) => e3 != null).map((entry) => {
         return de_GuardrailAutomatedReasoningTranslation(entry);
       });
       return retVal;
     };
-    var de_GuardrailAutomatedReasoningTranslationOption = (output, context) => {
+    var de_GuardrailAutomatedReasoningTranslationOption = (output, context3) => {
       return smithyClient.take(output, {
         translations: (_2) => de_GuardrailAutomatedReasoningTranslationList(_2)
       });
     };
-    var de_GuardrailAutomatedReasoningTranslationOptionList = (output, context) => {
+    var de_GuardrailAutomatedReasoningTranslationOptionList = (output, context3) => {
       const retVal = (output || []).filter((e3) => e3 != null).map((entry) => {
         return de_GuardrailAutomatedReasoningTranslationOption(entry);
       });
       return retVal;
     };
-    var de_GuardrailAutomatedReasoningValidFinding = (output, context) => {
+    var de_GuardrailAutomatedReasoningValidFinding = (output, context3) => {
       return smithyClient.take(output, {
         claimsTrueScenario: smithyClient._json,
         logicWarning: smithyClient._json,
@@ -32230,7 +32242,7 @@ var require_dist_cjs65 = __commonJS({
         translation: (_2) => de_GuardrailAutomatedReasoningTranslation(_2)
       });
     };
-    var de_GuardrailContextualGroundingFilter = (output, context) => {
+    var de_GuardrailContextualGroundingFilter = (output, context3) => {
       return smithyClient.take(output, {
         action: smithyClient.expectString,
         detected: smithyClient.expectBoolean,
@@ -32239,21 +32251,21 @@ var require_dist_cjs65 = __commonJS({
         type: smithyClient.expectString
       });
     };
-    var de_GuardrailContextualGroundingFilters = (output, context) => {
+    var de_GuardrailContextualGroundingFilters = (output, context3) => {
       const retVal = (output || []).filter((e3) => e3 != null).map((entry) => {
         return de_GuardrailContextualGroundingFilter(entry);
       });
       return retVal;
     };
-    var de_GuardrailContextualGroundingPolicyAssessment = (output, context) => {
+    var de_GuardrailContextualGroundingPolicyAssessment = (output, context3) => {
       return smithyClient.take(output, {
         filters: (_2) => de_GuardrailContextualGroundingFilters(_2)
       });
     };
-    var de_GuardrailConverseContentBlock = (output, context) => {
+    var de_GuardrailConverseContentBlock = (output, context3) => {
       if (output.image != null) {
         return {
-          image: de_GuardrailConverseImageBlock(output.image, context)
+          image: de_GuardrailConverseImageBlock(output.image, context3)
         };
       }
       if (output.text != null) {
@@ -32263,21 +32275,21 @@ var require_dist_cjs65 = __commonJS({
       }
       return { $unknown: Object.entries(output)[0] };
     };
-    var de_GuardrailConverseImageBlock = (output, context) => {
+    var de_GuardrailConverseImageBlock = (output, context3) => {
       return smithyClient.take(output, {
         format: smithyClient.expectString,
-        source: (_2) => de_GuardrailConverseImageSource(core$1.awsExpectUnion(_2), context)
+        source: (_2) => de_GuardrailConverseImageSource(core$1.awsExpectUnion(_2), context3)
       });
     };
-    var de_GuardrailConverseImageSource = (output, context) => {
+    var de_GuardrailConverseImageSource = (output, context3) => {
       if (output.bytes != null) {
         return {
-          bytes: context.base64Decoder(output.bytes)
+          bytes: context3.base64Decoder(output.bytes)
         };
       }
       return { $unknown: Object.entries(output)[0] };
     };
-    var de_GuardrailTraceAssessment = (output, context) => {
+    var de_GuardrailTraceAssessment = (output, context3) => {
       return smithyClient.take(output, {
         actionReason: smithyClient.expectString,
         inputAssessment: (_2) => de_GuardrailAssessmentMap(_2),
@@ -32285,16 +32297,16 @@ var require_dist_cjs65 = __commonJS({
         outputAssessments: (_2) => de_GuardrailAssessmentListMap(_2)
       });
     };
-    var de_ImageBlock = (output, context) => {
+    var de_ImageBlock = (output, context3) => {
       return smithyClient.take(output, {
         format: smithyClient.expectString,
-        source: (_2) => de_ImageSource(core$1.awsExpectUnion(_2), context)
+        source: (_2) => de_ImageSource(core$1.awsExpectUnion(_2), context3)
       });
     };
-    var de_ImageSource = (output, context) => {
+    var de_ImageSource = (output, context3) => {
       if (output.bytes != null) {
         return {
-          bytes: context.base64Decoder(output.bytes)
+          bytes: context3.base64Decoder(output.bytes)
         };
       }
       if (output.s3Location != null) {
@@ -32304,24 +32316,24 @@ var require_dist_cjs65 = __commonJS({
       }
       return { $unknown: Object.entries(output)[0] };
     };
-    var de_Message = (output, context) => {
+    var de_Message = (output, context3) => {
       return smithyClient.take(output, {
-        content: (_2) => de_ContentBlocks(_2, context),
+        content: (_2) => de_ContentBlocks(_2, context3),
         role: smithyClient.expectString
       });
     };
-    var de_MessageStopEvent = (output, context) => {
+    var de_MessageStopEvent = (output, context3) => {
       return smithyClient.take(output, {
         additionalModelResponseFields: (_2) => de_Document(_2),
         stopReason: smithyClient.expectString
       });
     };
-    var de_PayloadPart = (output, context) => {
+    var de_PayloadPart = (output, context3) => {
       return smithyClient.take(output, {
-        bytes: context.base64Decoder
+        bytes: context3.base64Decoder
       });
     };
-    var de_ReasoningContentBlock = (output, context) => {
+    var de_ReasoningContentBlock = (output, context3) => {
       if (output.reasoningText != null) {
         return {
           reasoningText: smithyClient._json(output.reasoningText)
@@ -32329,15 +32341,15 @@ var require_dist_cjs65 = __commonJS({
       }
       if (output.redactedContent != null) {
         return {
-          redactedContent: context.base64Decoder(output.redactedContent)
+          redactedContent: context3.base64Decoder(output.redactedContent)
         };
       }
       return { $unknown: Object.entries(output)[0] };
     };
-    var de_ReasoningContentBlockDelta = (output, context) => {
+    var de_ReasoningContentBlockDelta = (output, context3) => {
       if (output.redactedContent != null) {
         return {
-          redactedContent: context.base64Decoder(output.redactedContent)
+          redactedContent: context3.base64Decoder(output.redactedContent)
         };
       }
       if (smithyClient.expectString(output.signature) !== void 0) {
@@ -32348,22 +32360,22 @@ var require_dist_cjs65 = __commonJS({
       }
       return { $unknown: Object.entries(output)[0] };
     };
-    var de_ToolResultBlock = (output, context) => {
+    var de_ToolResultBlock = (output, context3) => {
       return smithyClient.take(output, {
-        content: (_2) => de_ToolResultContentBlocks(_2, context),
+        content: (_2) => de_ToolResultContentBlocks(_2, context3),
         status: smithyClient.expectString,
         toolUseId: smithyClient.expectString
       });
     };
-    var de_ToolResultContentBlock = (output, context) => {
+    var de_ToolResultContentBlock = (output, context3) => {
       if (output.document != null) {
         return {
-          document: de_DocumentBlock(output.document, context)
+          document: de_DocumentBlock(output.document, context3)
         };
       }
       if (output.image != null) {
         return {
-          image: de_ImageBlock(output.image, context)
+          image: de_ImageBlock(output.image, context3)
         };
       }
       if (output.json != null) {
@@ -32376,34 +32388,34 @@ var require_dist_cjs65 = __commonJS({
       }
       if (output.video != null) {
         return {
-          video: de_VideoBlock(output.video, context)
+          video: de_VideoBlock(output.video, context3)
         };
       }
       return { $unknown: Object.entries(output)[0] };
     };
-    var de_ToolResultContentBlocks = (output, context) => {
+    var de_ToolResultContentBlocks = (output, context3) => {
       const retVal = (output || []).filter((e3) => e3 != null).map((entry) => {
-        return de_ToolResultContentBlock(core$1.awsExpectUnion(entry), context);
+        return de_ToolResultContentBlock(core$1.awsExpectUnion(entry), context3);
       });
       return retVal;
     };
-    var de_ToolUseBlock = (output, context) => {
+    var de_ToolUseBlock = (output, context3) => {
       return smithyClient.take(output, {
         input: (_2) => de_Document(_2),
         name: smithyClient.expectString,
         toolUseId: smithyClient.expectString
       });
     };
-    var de_VideoBlock = (output, context) => {
+    var de_VideoBlock = (output, context3) => {
       return smithyClient.take(output, {
         format: smithyClient.expectString,
-        source: (_2) => de_VideoSource(core$1.awsExpectUnion(_2), context)
+        source: (_2) => de_VideoSource(core$1.awsExpectUnion(_2), context3)
       });
     };
-    var de_VideoSource = (output, context) => {
+    var de_VideoSource = (output, context3) => {
       if (output.bytes != null) {
         return {
-          bytes: context.base64Decoder(output.bytes)
+          bytes: context3.base64Decoder(output.bytes)
         };
       }
       if (output.s3Location != null) {
@@ -32413,7 +32425,7 @@ var require_dist_cjs65 = __commonJS({
       }
       return { $unknown: Object.entries(output)[0] };
     };
-    var de_Document = (output, context) => {
+    var de_Document = (output, context3) => {
       return output;
     };
     var deserializeMetadata3 = (output) => ({
@@ -36979,7 +36991,7 @@ var init_esm2 = __esm({
           free: c3.#free,
           // methods
           isBackgroundFetch: (p3) => c3.#isBackgroundFetch(p3),
-          backgroundFetch: (k3, index, options, context) => c3.#backgroundFetch(k3, index, options, context),
+          backgroundFetch: (k3, index, options, context3) => c3.#backgroundFetch(k3, index, options, context3),
           moveToTail: (index) => c3.#moveToTail(index),
           indexes: (options) => c3.#indexes(options),
           rindexes: (options) => c3.#rindexes(options),
@@ -37766,7 +37778,7 @@ var init_esm2 = __esm({
         const v3 = this.#valList[index];
         return this.#isBackgroundFetch(v3) ? v3.__staleWhileFetching : v3;
       }
-      #backgroundFetch(k3, index, options, context) {
+      #backgroundFetch(k3, index, options, context3) {
         const v3 = index === void 0 ? void 0 : this.#valList[index];
         if (this.#isBackgroundFetch(v3)) {
           return v3;
@@ -37779,7 +37791,7 @@ var init_esm2 = __esm({
         const fetchOpts = {
           signal: ac.signal,
           options,
-          context
+          context: context3
         };
         const cb = (v4, updateCache = false) => {
           const { aborted } = ac.signal;
@@ -37896,7 +37908,7 @@ var init_esm2 = __esm({
           allowStaleOnFetchRejection = this.allowStaleOnFetchRejection,
           ignoreFetchAbort = this.ignoreFetchAbort,
           allowStaleOnFetchAbort = this.allowStaleOnFetchAbort,
-          context,
+          context: context3,
           forceRefresh = false,
           status,
           signal
@@ -37931,7 +37943,7 @@ var init_esm2 = __esm({
         if (index === void 0) {
           if (status)
             status.fetch = "miss";
-          const p3 = this.#backgroundFetch(k3, index, options, context);
+          const p3 = this.#backgroundFetch(k3, index, options, context3);
           return p3.__returned = p3;
         } else {
           const v3 = this.#valList[index];
@@ -37956,7 +37968,7 @@ var init_esm2 = __esm({
               this.#statusTTL(status, index);
             return v3;
           }
-          const p3 = this.#backgroundFetch(k3, index, options, context);
+          const p3 = this.#backgroundFetch(k3, index, options, context3);
           const hasStale = p3.__staleWhileFetching !== void 0;
           const staleVal = hasStale && allowStale;
           if (status) {
@@ -37978,13 +37990,13 @@ var init_esm2 = __esm({
         if (!memoMethod) {
           throw new Error("no memoMethod provided to constructor");
         }
-        const { context, forceRefresh, ...options } = memoOptions;
+        const { context: context3, forceRefresh, ...options } = memoOptions;
         const v3 = this.get(k3, options);
         if (!forceRefresh && v3 !== void 0)
           return v3;
         const vv = memoMethod(k3, v3, {
           options,
-          context
+          context: context3
         });
         this.set(k3, vv, options);
         return vv;
@@ -55239,8 +55251,8 @@ function mapFlowchartParserError(err, text) {
     };
   }
   if (tokType === "QuotedString") {
-    const context = err?.context;
-    const inLinkRule = context?.ruleStack?.includes("linkTextInline") || context?.ruleStack?.includes("link") || false;
+    const context3 = err?.context;
+    const inLinkRule = context3?.ruleStack?.includes("linkTextInline") || context3?.ruleStack?.includes("link") || false;
     const lineContent = allLines[Math.max(0, line - 1)] || "";
     const beforeQuote = lineContent.slice(0, Math.max(0, column - 1));
     const hasLinkBefore = beforeQuote.match(/--\s*$|==\s*$|-\.\s*$|-\.-\s*$|\[\s*$/);
@@ -72831,7 +72843,7 @@ ${fixedContent}
     };
   }
 }
-var HTML_ENTITY_MAP, JsonFixingAgent, MermaidFixingAgent;
+var HTML_ENTITY_MAP, sessionIdCounter, JsonFixingAgent, MermaidFixingAgent;
 var init_schemaUtils = __esm({
   "src/agent/schemaUtils.js"() {
     "use strict";
@@ -72847,11 +72859,12 @@ var init_schemaUtils = __esm({
       // Also handle XML/HTML5 apostrophe entity
       "&nbsp;": " "
     };
+    sessionIdCounter = 0;
     JsonFixingAgent = class {
       constructor(options = {}) {
         this.ProbeAgent = null;
         this.options = {
-          sessionId: options.sessionId || `json-fixer-${Date.now()}`,
+          sessionId: options.sessionId || `json-fixer-${Date.now()}-${sessionIdCounter++}`,
           path: options.path || process.cwd(),
           provider: options.provider,
           model: options.model,
@@ -73001,7 +73014,7 @@ Provide only the corrected JSON without any markdown formatting or explanations.
       constructor(options = {}) {
         this.ProbeAgent = null;
         this.options = {
-          sessionId: options.sessionId || `mermaid-fixer-${Date.now()}`,
+          sessionId: options.sessionId || `mermaid-fixer-${Date.now()}-${sessionIdCounter++}`,
           path: options.path || process.cwd(),
           provider: options.provider,
           model: options.model,
@@ -75224,16 +75237,14 @@ Remember: Use proper XML format with BOTH opening and closing tags:
 <parameter>value</parameter>
 </tool_name>
 
-IMPORTANT: A schema was provided for the final output format. You have two options:
+IMPORTANT: A schema was provided for the final output format.
 
-Option 1 - Use attempt_completion with your complete answer:
+You MUST use attempt_completion to provide your answer:
 <attempt_completion>
-[Your complete answer here - will be automatically formatted to match the schema]
+[Your complete answer here - provide in natural language, it will be automatically formatted to match the schema]
 </attempt_completion>
 
-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.`;
+Your response will be automatically formatted to JSON. You can provide your answer in natural language or as JSON - either will work.`;
               } 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.
 
@@ -75470,7 +75481,7 @@ Convert your previous response content into actual JSON data that follows this s
             }
           } else if (reachedMaxIterations && options.schema && this.debug) {
             console.log("[DEBUG] Skipping schema formatting due to max iterations reached without completion");
-          } else if (completionAttempted && options.schema && !options._schemaFormatted) {
+          } else if (completionAttempted && options.schema && !options._schemaFormatted && !options._skipValidation) {
             try {
               finalResult = cleanSchemaResponse(finalResult);
               if (!this.disableMermaidValidation) {
@@ -75524,7 +75535,9 @@ Convert your previous response content into actual JSON data that follows this s
                   );
                   finalResult = await this.answer(schemaDefinitionPrompt, [], {
                     ...options,
-                    _schemaFormatted: true
+                    _schemaFormatted: true,
+                    _skipValidation: true
+                    // Skip validation in recursive correction calls to prevent loops
                   });
                   finalResult = cleanSchemaResponse(finalResult);
                   validation = validateJsonResponse(finalResult);
@@ -75564,7 +75577,9 @@ Convert your previous response content into actual JSON data that follows this s
                   }
                   finalResult = await this.answer(correctionPrompt, [], {
                     ...options,
-                    _schemaFormatted: true
+                    _schemaFormatted: true,
+                    _skipValidation: true
+                    // Skip validation in recursive correction calls to prevent loops
                   });
                   finalResult = cleanSchemaResponse(finalResult);
                   validation = validateJsonResponse(finalResult, { debug: this.debug });
@@ -76095,6 +76110,667 @@ var init_simpleTelemetry = __esm({
   }
 });
 
+// src/agent/fileSpanExporter.js
+var import_fs9, import_core17, ExportResultCode, FileSpanExporter;
+var init_fileSpanExporter = __esm({
+  "src/agent/fileSpanExporter.js"() {
+    "use strict";
+    import_fs9 = require("fs");
+    import_core17 = __toESM(require("@opentelemetry/core"), 1);
+    ({ ExportResultCode } = import_core17.default);
+    FileSpanExporter = class {
+      constructor(filePath = "./traces.jsonl") {
+        this.filePath = filePath;
+        this.stream = (0, import_fs9.createWriteStream)(filePath, { flags: "a" });
+        this.stream.on("error", (error2) => {
+          console.error(`[FileSpanExporter] Stream error: ${error2.message}`);
+        });
+      }
+      /**
+       * Export spans to file
+       * @param {ReadableSpan[]} spans - Array of spans to export
+       * @param {function} resultCallback - Callback to call with the export result
+       */
+      export(spans, resultCallback) {
+        if (!spans || spans.length === 0) {
+          resultCallback({ code: ExportResultCode.SUCCESS });
+          return;
+        }
+        try {
+          const timestamp = Date.now();
+          spans.forEach((span, index) => {
+            let parentSpanId = void 0;
+            if (span.parentSpanContext) {
+              parentSpanId = span.parentSpanContext.spanId;
+            } else if (span._parentSpanContext) {
+              parentSpanId = span._parentSpanContext.spanId;
+            } else if (span.parent) {
+              parentSpanId = span.parent.spanId;
+            } else if (span._parent) {
+              parentSpanId = span._parent.spanId;
+            } else if (span._parentId) {
+              parentSpanId = span._parentId;
+            } else if (span.parentSpanId) {
+              parentSpanId = span.parentSpanId;
+            }
+            const spanData = {
+              traceId: span.spanContext().traceId,
+              spanId: span.spanContext().spanId,
+              parentSpanId,
+              name: span.name,
+              kind: span.kind,
+              startTimeUnixNano: span.startTime[0] * 1e9 + span.startTime[1],
+              endTimeUnixNano: span.endTime[0] * 1e9 + span.endTime[1],
+              attributes: this.convertAttributes(span.attributes),
+              status: span.status,
+              events: span.events?.map((event) => ({
+                timeUnixNano: event.time[0] * 1e9 + event.time[1],
+                name: event.name,
+                attributes: this.convertAttributes(event.attributes)
+              })) || [],
+              links: span.links?.map((link) => ({
+                traceId: link.context.traceId,
+                spanId: link.context.spanId,
+                attributes: this.convertAttributes(link.attributes)
+              })) || [],
+              resource: {
+                attributes: this.convertAttributes(span.resource?.attributes || {})
+              },
+              instrumentationLibrary: {
+                name: span.instrumentationLibrary?.name || "unknown",
+                version: span.instrumentationLibrary?.version || "unknown"
+              },
+              timestamp
+            };
+            this.stream.write(JSON.stringify(spanData) + "\n");
+          });
+          resultCallback({ code: ExportResultCode.SUCCESS });
+        } catch (error2) {
+          console.error(`[FileSpanExporter] Export error: ${error2.message}`);
+          resultCallback({
+            code: ExportResultCode.FAILED,
+            error: error2
+          });
+        }
+      }
+      /**
+       * Convert OpenTelemetry attributes to plain object
+       * @param {Object} attributes - OpenTelemetry attributes
+       * @returns {Object} Plain object with string values
+       */
+      convertAttributes(attributes) {
+        if (!attributes) return {};
+        const result = {};
+        for (const [key, value] of Object.entries(attributes)) {
+          if (typeof value === "object" && value !== null) {
+            result[key] = JSON.stringify(value);
+          } else {
+            result[key] = String(value);
+          }
+        }
+        return result;
+      }
+      /**
+       * Shutdown the exporter
+       * @returns {Promise<void>}
+       */
+      async shutdown() {
+        return new Promise((resolve4) => {
+          if (this.stream) {
+            this.stream.end(() => {
+              console.log(`[FileSpanExporter] File stream closed: ${this.filePath}`);
+              resolve4();
+            });
+          } else {
+            resolve4();
+          }
+        });
+      }
+      /**
+       * Force flush any pending spans
+       * @returns {Promise<void>}
+       */
+      async forceFlush() {
+        return new Promise((resolve4, reject2) => {
+          if (this.stream) {
+            const flushTimeout = setTimeout(() => {
+              console.warn("[FileSpanExporter] Flush timeout after 5 seconds");
+              resolve4();
+            }, 5e3);
+            if (this.stream.writableCorked) {
+              this.stream.uncork();
+            }
+            if (this.stream.writableNeedDrain) {
+              this.stream.once("drain", () => {
+                clearTimeout(flushTimeout);
+                resolve4();
+              });
+            } else {
+              setImmediate(() => {
+                clearTimeout(flushTimeout);
+                resolve4();
+              });
+            }
+          } else {
+            resolve4();
+          }
+        });
+      }
+    };
+  }
+});
+
+// src/agent/telemetry.js
+function initializeTelemetryFromOptions(options) {
+  const config = new TelemetryConfig({
+    serviceName: "probe-agent",
+    serviceVersion: "1.0.0",
+    enableFile: options.traceFile !== void 0,
+    enableRemote: options.traceRemote !== void 0,
+    enableConsole: options.traceConsole,
+    filePath: options.traceFile || "./traces.jsonl",
+    remoteEndpoint: options.traceRemote || "http://localhost:4318/v1/traces"
+  });
+  config.initialize();
+  return config;
+}
+var import_sdk_node, import_resources, import_semantic_conventions, import_api, import_exporter_trace_otlp_http, import_sdk_trace_base, import_fs10, import_path11, NodeSDK, Resource, OTLPTraceExporter, BatchSpanProcessor, ConsoleSpanExporter, TelemetryConfig;
+var init_telemetry = __esm({
+  "src/agent/telemetry.js"() {
+    "use strict";
+    import_sdk_node = __toESM(require("@opentelemetry/sdk-node"), 1);
+    import_resources = __toESM(require("@opentelemetry/resources"), 1);
+    import_semantic_conventions = require("@opentelemetry/semantic-conventions");
+    import_api = require("@opentelemetry/api");
+    import_exporter_trace_otlp_http = __toESM(require("@opentelemetry/exporter-trace-otlp-http"), 1);
+    import_sdk_trace_base = __toESM(require("@opentelemetry/sdk-trace-base"), 1);
+    import_fs10 = require("fs");
+    import_path11 = require("path");
+    init_fileSpanExporter();
+    ({ NodeSDK } = import_sdk_node.default);
+    ({ Resource } = import_resources.default);
+    ({ OTLPTraceExporter } = import_exporter_trace_otlp_http.default);
+    ({ BatchSpanProcessor, ConsoleSpanExporter } = import_sdk_trace_base.default);
+    TelemetryConfig = class {
+      constructor(options = {}) {
+        this.serviceName = options.serviceName || "probe-agent";
+        this.serviceVersion = options.serviceVersion || "1.0.0";
+        this.enableFile = options.enableFile || false;
+        this.enableRemote = options.enableRemote || false;
+        this.enableConsole = options.enableConsole || false;
+        this.filePath = options.filePath || "./traces.jsonl";
+        this.remoteEndpoint = options.remoteEndpoint || "http://localhost:4318/v1/traces";
+        this.sdk = null;
+        this.tracer = null;
+      }
+      /**
+       * Initialize OpenTelemetry SDK
+       */
+      initialize() {
+        if (this.sdk) {
+          console.warn("Telemetry already initialized");
+          return;
+        }
+        const resource = new Resource({
+          [import_semantic_conventions.ATTR_SERVICE_NAME]: this.serviceName,
+          [import_semantic_conventions.ATTR_SERVICE_VERSION]: this.serviceVersion
+        });
+        const spanProcessors = [];
+        if (this.enableFile) {
+          try {
+            const dir = (0, import_path11.dirname)(this.filePath);
+            if (!(0, import_fs10.existsSync)(dir)) {
+              (0, import_fs10.mkdirSync)(dir, { recursive: true });
+            }
+            const fileExporter = new FileSpanExporter(this.filePath);
+            spanProcessors.push(new BatchSpanProcessor(fileExporter, {
+              maxQueueSize: 2048,
+              maxExportBatchSize: 512,
+              scheduledDelayMillis: 500,
+              exportTimeoutMillis: 3e4
+            }));
+            console.log(`[Telemetry] File exporter enabled, writing to: ${this.filePath}`);
+          } catch (error2) {
+            console.error(`[Telemetry] Failed to initialize file exporter: ${error2.message}`);
+          }
+        }
+        if (this.enableRemote) {
+          try {
+            const remoteExporter = new OTLPTraceExporter({
+              url: this.remoteEndpoint
+            });
+            spanProcessors.push(new BatchSpanProcessor(remoteExporter, {
+              maxQueueSize: 2048,
+              maxExportBatchSize: 512,
+              scheduledDelayMillis: 500,
+              exportTimeoutMillis: 3e4
+            }));
+            console.log(`[Telemetry] Remote exporter enabled, endpoint: ${this.remoteEndpoint}`);
+          } catch (error2) {
+            console.error(`[Telemetry] Failed to initialize remote exporter: ${error2.message}`);
+          }
+        }
+        if (this.enableConsole) {
+          const consoleExporter = new ConsoleSpanExporter();
+          spanProcessors.push(new BatchSpanProcessor(consoleExporter, {
+            maxQueueSize: 2048,
+            maxExportBatchSize: 512,
+            scheduledDelayMillis: 500,
+            exportTimeoutMillis: 3e4
+          }));
+          console.log(`[Telemetry] Console exporter enabled`);
+        }
+        if (spanProcessors.length === 0) {
+          console.log("[Telemetry] No exporters configured, telemetry will not be collected");
+          return;
+        }
+        this.sdk = new NodeSDK({
+          resource,
+          spanProcessors
+        });
+        try {
+          this.sdk.start();
+          this.tracer = import_api.trace.getTracer(this.serviceName, this.serviceVersion);
+          console.log(`[Telemetry] OpenTelemetry SDK initialized successfully`);
+        } catch (error2) {
+          console.error(`[Telemetry] Failed to start OpenTelemetry SDK: ${error2.message}`);
+        }
+      }
+      /**
+       * Get the tracer instance
+       */
+      getTracer() {
+        return this.tracer;
+      }
+      /**
+       * Create a span with the given name and attributes
+       */
+      createSpan(name14, attributes = {}) {
+        if (!this.tracer) {
+          return null;
+        }
+        return this.tracer.startSpan(name14, {
+          attributes
+        });
+      }
+      /**
+       * Wrap a function to automatically create spans
+       */
+      wrapFunction(name14, fn, attributes = {}) {
+        if (!this.tracer) {
+          return fn;
+        }
+        return async (...args) => {
+          const span = this.createSpan(name14, attributes);
+          if (!span) {
+            return fn(...args);
+          }
+          try {
+            const result = await import_api.context.with(import_api.trace.setSpan(import_api.context.active(), span), () => fn(...args));
+            span.setStatus({ code: import_api.SpanStatusCode.OK });
+            return result;
+          } catch (error2) {
+            span.setStatus({
+              code: import_api.SpanStatusCode.ERROR,
+              message: error2.message
+            });
+            span.recordException(error2);
+            throw error2;
+          } finally {
+            span.end();
+          }
+        };
+      }
+      /**
+       * Force flush all pending spans
+       */
+      async forceFlush() {
+        if (this.sdk) {
+          try {
+            const tracerProvider = import_api.trace.getTracerProvider();
+            if (tracerProvider && typeof tracerProvider.forceFlush === "function") {
+              await tracerProvider.forceFlush();
+            }
+            await new Promise((resolve4) => setTimeout(resolve4, 100));
+            console.log("[Telemetry] OpenTelemetry spans flushed successfully");
+          } catch (error2) {
+            console.error(`[Telemetry] Failed to flush OpenTelemetry spans: ${error2.message}`);
+          }
+        }
+      }
+      /**
+       * Shutdown telemetry
+       */
+      async shutdown() {
+        if (this.sdk) {
+          try {
+            await this.sdk.shutdown();
+            console.log("[Telemetry] OpenTelemetry SDK shutdown successfully");
+          } catch (error2) {
+            console.error(`[Telemetry] Failed to shutdown OpenTelemetry SDK: ${error2.message}`);
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/agent/appTracer.js
+var import_api2, AppTracer;
+var init_appTracer = __esm({
+  "src/agent/appTracer.js"() {
+    "use strict";
+    import_api2 = require("@opentelemetry/api");
+    AppTracer = class {
+      constructor(telemetryConfig, sessionId = null) {
+        this.telemetryConfig = telemetryConfig;
+        this.tracer = telemetryConfig?.getTracer();
+        this.sessionId = sessionId || this.generateSessionId();
+        this.traceId = this.generateTraceId();
+      }
+      /**
+       * Generate a unique session ID
+       */
+      generateSessionId() {
+        return Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
+      }
+      /**
+       * Generate trace ID from session ID for consistent tracing
+       */
+      generateTraceId() {
+        if (!this.sessionId) return null;
+        const hash = this.hashString(this.sessionId);
+        return hash.padEnd(32, "0").substring(0, 32);
+      }
+      /**
+       * Simple hash function for session ID
+       */
+      hashString(str) {
+        let hash = 0;
+        for (let i3 = 0; i3 < str.length; i3++) {
+          const char = str.charCodeAt(i3);
+          hash = (hash << 5) - hash + char;
+          hash = hash & hash;
+        }
+        return Math.abs(hash).toString(16);
+      }
+      /**
+       * Check if tracing is enabled
+       */
+      isEnabled() {
+        return this.tracer !== null;
+      }
+      /**
+       * Create a root span for the agent session
+       */
+      createSessionSpan(attributes = {}) {
+        if (!this.isEnabled()) return null;
+        return this.tracer.startSpan("agent.session", {
+          attributes: {
+            "session.id": this.sessionId,
+            "trace.id": this.traceId,
+            ...attributes
+          }
+        });
+      }
+      /**
+       * Create a span for AI model requests
+       */
+      createAISpan(modelName, provider, attributes = {}) {
+        if (!this.isEnabled()) return null;
+        return this.tracer.startSpan("ai.request", {
+          attributes: {
+            "ai.model": modelName,
+            "ai.provider": provider,
+            "session.id": this.sessionId,
+            ...attributes
+          }
+        });
+      }
+      /**
+       * Create a span for tool calls
+       */
+      createToolSpan(toolName, attributes = {}) {
+        if (!this.isEnabled()) return null;
+        return this.tracer.startSpan("tool.call", {
+          attributes: {
+            "tool.name": toolName,
+            "session.id": this.sessionId,
+            ...attributes
+          }
+        });
+      }
+      /**
+       * Create a span for code search operations
+       */
+      createSearchSpan(query2, attributes = {}) {
+        if (!this.isEnabled()) return null;
+        return this.tracer.startSpan("search.query", {
+          attributes: {
+            "search.query": query2,
+            "session.id": this.sessionId,
+            ...attributes
+          }
+        });
+      }
+      /**
+       * Create a span for code extraction operations
+       */
+      createExtractSpan(files, attributes = {}) {
+        if (!this.isEnabled()) return null;
+        return this.tracer.startSpan("extract.files", {
+          attributes: {
+            "extract.file_count": Array.isArray(files) ? files.length : 1,
+            "extract.files": Array.isArray(files) ? files.join(",") : files,
+            "session.id": this.sessionId,
+            ...attributes
+          }
+        });
+      }
+      /**
+       * Create a span for agent iterations
+       */
+      createIterationSpan(iteration, attributes = {}) {
+        if (!this.isEnabled()) return null;
+        return this.tracer.startSpan("agent.iteration", {
+          attributes: {
+            "iteration.number": iteration,
+            "session.id": this.sessionId,
+            ...attributes
+          }
+        });
+      }
+      /**
+       * Create a span for delegation operations
+       */
+      createDelegationSpan(task, attributes = {}) {
+        if (!this.isEnabled()) return null;
+        return this.tracer.startSpan("agent.delegation", {
+          attributes: {
+            "delegation.task": task.substring(0, 200) + (task.length > 200 ? "..." : ""),
+            "delegation.task_length": task.length,
+            "session.id": this.sessionId,
+            ...attributes
+          }
+        });
+      }
+      /**
+       * Create a span for JSON validation operations
+       */
+      createJsonValidationSpan(responseLength, attributes = {}) {
+        if (!this.isEnabled()) return null;
+        return this.tracer.startSpan("validation.json", {
+          attributes: {
+            "validation.response_length": responseLength,
+            "session.id": this.sessionId,
+            ...attributes
+          }
+        });
+      }
+      /**
+       * Create a span for Mermaid validation operations
+       */
+      createMermaidValidationSpan(diagramCount, attributes = {}) {
+        if (!this.isEnabled()) return null;
+        return this.tracer.startSpan("validation.mermaid", {
+          attributes: {
+            "validation.diagram_count": diagramCount,
+            "session.id": this.sessionId,
+            ...attributes
+          }
+        });
+      }
+      /**
+       * Create a span for schema processing operations
+       */
+      createSchemaProcessingSpan(schemaType, attributes = {}) {
+        if (!this.isEnabled()) return null;
+        return this.tracer.startSpan("schema.processing", {
+          attributes: {
+            "schema.type": schemaType,
+            "session.id": this.sessionId,
+            ...attributes
+          }
+        });
+      }
+      /**
+       * Record delegation events
+       */
+      recordDelegationEvent(eventType, data2 = {}) {
+        if (!this.isEnabled()) return;
+        this.addEvent(`delegation.${eventType}`, {
+          "session.id": this.sessionId,
+          ...data2
+        });
+      }
+      /**
+       * Record JSON validation events
+       */
+      recordJsonValidationEvent(eventType, data2 = {}) {
+        if (!this.isEnabled()) return;
+        this.addEvent(`json_validation.${eventType}`, {
+          "session.id": this.sessionId,
+          ...data2
+        });
+      }
+      /**
+       * Record Mermaid validation events
+       */
+      recordMermaidValidationEvent(eventType, data2 = {}) {
+        if (!this.isEnabled()) return;
+        this.addEvent(`mermaid_validation.${eventType}`, {
+          "session.id": this.sessionId,
+          ...data2
+        });
+      }
+      /**
+       * Add an event to the current or most recent span
+       */
+      addEvent(name14, attributes = {}) {
+        if (!this.isEnabled()) return;
+        const activeSpan = import_api2.trace.getActiveSpan();
+        if (activeSpan) {
+          activeSpan.addEvent(name14, {
+            "session.id": this.sessionId,
+            ...attributes
+          });
+        } else {
+          if (this.telemetryConfig?.enableConsole) {
+            console.log(`[Event] ${name14}:`, attributes);
+          }
+        }
+      }
+      /**
+       * Set attributes on the current span
+       */
+      setAttributes(attributes) {
+        if (!this.isEnabled()) return;
+        const activeSpan = import_api2.trace.getActiveSpan();
+        if (activeSpan) {
+          activeSpan.setAttributes({
+            "session.id": this.sessionId,
+            ...attributes
+          });
+        }
+      }
+      /**
+       * Wrap a function with automatic span creation
+       */
+      wrapFunction(spanName, fn, attributes = {}) {
+        if (!this.isEnabled()) {
+          return fn;
+        }
+        return async (...args) => {
+          const span = this.tracer.startSpan(spanName, {
+            attributes: {
+              "session.id": this.sessionId,
+              ...attributes
+            }
+          });
+          try {
+            const result = await import_api2.context.with(import_api2.trace.setSpan(import_api2.context.active(), span), () => fn(...args));
+            span.setStatus({ code: import_api2.SpanStatusCode.OK });
+            return result;
+          } catch (error2) {
+            span.setStatus({
+              code: import_api2.SpanStatusCode.ERROR,
+              message: error2.message
+            });
+            span.recordException(error2);
+            throw error2;
+          } finally {
+            span.end();
+          }
+        };
+      }
+      /**
+       * Execute a function within a span context
+       */
+      async withSpan(spanName, fn, attributes = {}) {
+        if (!this.isEnabled()) {
+          return fn();
+        }
+        const span = this.tracer.startSpan(spanName, {
+          attributes: {
+            "session.id": this.sessionId,
+            ...attributes
+          }
+        });
+        try {
+          const result = await import_api2.context.with(import_api2.trace.setSpan(import_api2.context.active(), span), () => fn());
+          span.setStatus({ code: import_api2.SpanStatusCode.OK });
+          return result;
+        } catch (error2) {
+          span.setStatus({
+            code: import_api2.SpanStatusCode.ERROR,
+            message: error2.message
+          });
+          span.recordException(error2);
+          throw error2;
+        } finally {
+          span.end();
+        }
+      }
+      /**
+       * Force flush all pending spans
+       */
+      async flush() {
+        if (this.telemetryConfig) {
+          await this.telemetryConfig.forceFlush();
+        }
+      }
+      /**
+       * Shutdown tracing
+       */
+      async shutdown() {
+        if (this.telemetryConfig) {
+          await this.telemetryConfig.shutdown();
+        }
+      }
+    };
+  }
+});
+
 // src/agent/storage/index.js
 var init_storage = __esm({
   "src/agent/storage/index.js"() {
@@ -76115,6 +76791,7 @@ var init_hooks = __esm({
 // src/index.js
 var index_exports = {};
 __export(index_exports, {
+  AppTracer: () => AppTracer,
   DEFAULT_SYSTEM_MESSAGE: () => DEFAULT_SYSTEM_MESSAGE,
   HOOK_TYPES: () => HOOK_TYPES,
   HookManager: () => HookManager,
@@ -76123,6 +76800,7 @@ __export(index_exports, {
   SimpleAppTracer: () => SimpleAppTracer,
   SimpleTelemetry: () => SimpleTelemetry,
   StorageAdapter: () => StorageAdapter,
+  TelemetryConfig: () => TelemetryConfig,
   attemptCompletionSchema: () => attemptCompletionSchema,
   attemptCompletionToolDefinition: () => attemptCompletionToolDefinition,
   bashSchema: () => bashSchema,
@@ -76139,6 +76817,7 @@ __export(index_exports, {
   getBinaryPath: () => getBinaryPath,
   grep: () => grep,
   initializeSimpleTelemetryFromOptions: () => initializeSimpleTelemetryFromOptions,
+  initializeTelemetryFromOptions: () => initializeTelemetryFromOptions,
   listFilesByLevel: () => listFilesByLevel,
   listFilesToolInstance: () => listFilesToolInstance,
   parseXmlToolCall: () => parseXmlToolCall,
@@ -76171,6 +76850,8 @@ var init_index = __esm({
     init_bash();
     init_ProbeAgent();
     init_simpleTelemetry();
+    init_telemetry();
+    init_appTracer();
     init_probeTool();
     init_storage();
     init_hooks();
@@ -76179,6 +76860,7 @@ var init_index = __esm({
 init_index();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AppTracer,
   DEFAULT_SYSTEM_MESSAGE,
   HOOK_TYPES,
   HookManager,
@@ -76187,6 +76869,7 @@ init_index();
   SimpleAppTracer,
   SimpleTelemetry,
   StorageAdapter,
+  TelemetryConfig,
   attemptCompletionSchema,
   attemptCompletionToolDefinition,
   bashSchema,
@@ -76203,6 +76886,7 @@ init_index();
   getBinaryPath,
   grep,
   initializeSimpleTelemetryFromOptions,
+  initializeTelemetryFromOptions,
   listFilesByLevel,
   listFilesToolInstance,
   parseXmlToolCall,