@skilder-ai/runtime 0.6.1 → 0.6.2

package/dist/index.js

@@ -3327,14 +3327,14 @@ var require_quick_format_unescaped = __commonJS({
               if (args[a3] === void 0) break;
               if (lastPos < i2)
                 str += f2.slice(lastPos, i2);
-              var type17 = typeof args[a3];
-              if (type17 === "string") {
+              var type18 = typeof args[a3];
+              if (type18 === "string") {
                 str += "'" + args[a3] + "'";
                 lastPos = i2 + 2;
                 i2++;
                 break;
               }
-              if (type17 === "function") {
+              if (type18 === "function") {
                 str += args[a3].name || "<anonymous>";
                 lastPos = i2 + 2;
                 i2++;
@@ -7506,8 +7506,8 @@ var require_cjs = __commonJS({
       if (stringTag) {
         return stringTag;
       }
-      const type17 = toStringObject.call(value);
-      return type17.substring(8, type17.length - 1);
+      const type18 = toStringObject.call(value);
+      return type18.substring(8, type18.length - 1);
     }
     var { hasOwnProperty, propertyIsEnumerable } = Object.prototype;
     function copyOwnDescriptor(original, clone2, property, state) {
@@ -25243,8 +25243,8 @@ var require_applicability = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.shouldUseRule = exports2.shouldUseGroup = exports2.schemaHasRulesForType = void 0;
-    function schemaHasRulesForType({ schema, self: self2 }, type17) {
-      const group = self2.RULES.types[type17];
+    function schemaHasRulesForType({ schema, self: self2 }, type18) {
+      const group = self2.RULES.types[type18];
       return group && group !== true && shouldUseGroup(schema, group);
     }
     exports2.schemaHasRulesForType = schemaHasRulesForType;
@@ -26345,9 +26345,9 @@ var require_validate = __commonJS({
       for (const keyword in rules) {
         const rule = rules[keyword];
         if (typeof rule == "object" && (0, applicability_1.shouldUseRule)(it2.schema, rule)) {
-          const { type: type17 } = rule.definition;
-          if (type17.length && !type17.some((t4) => hasApplicableType(ts, t4))) {
-            strictTypesError(it2, `missing type "${type17.join(",")}" for keyword "${keyword}"`);
+          const { type: type18 } = rule.definition;
+          if (type18.length && !type18.some((t4) => hasApplicableType(ts, t4))) {
+            strictTypesError(it2, `missing type "${type18.join(",")}" for keyword "${keyword}"`);
           }
         }
       }
@@ -42769,7 +42769,7 @@ var require_server = __commonJS({
         session.once("close", function() {
           http2Server[kHttp2ServerSessions].delete(session);
         });
-        session.once("frameError", function(type17, code, streamId) {
+        session.once("frameError", function(type18, code, streamId) {
           if (streamId === 0) {
             http2Server[kHttp2ServerSessions].delete(session);
           }
@@ -44613,8 +44613,8 @@ var require_reply = __commonJS({
       this[kReplySerializer] = fn;
       return this;
     };
-    Reply.prototype.type = function(type17) {
-      this[kReplyHeaders]["content-type"] = type17;
+    Reply.prototype.type = function(type18) {
+      this[kReplyHeaders]["content-type"] = type18;
       return this;
     };
     Reply.prototype.redirect = function(url2, code) {
@@ -47364,7 +47364,7 @@ var require_content_type_parser = __commonJS({
       if (!opts) opts = {};
       if (!opts.bodyLimit) opts.bodyLimit = this[kBodyLimit];
       if (Array.isArray(contentType2)) {
-        contentType2.forEach((type17) => this[kContentTypeParser].add(type17, opts, parser));
+        contentType2.forEach((type18) => this[kContentTypeParser].add(type18, opts, parser));
       } else {
         this[kContentTypeParser].add(contentType2, opts, parser);
       }
@@ -47378,8 +47378,8 @@ var require_content_type_parser = __commonJS({
         throw new FST_ERR_CTP_INSTANCE_ALREADY_STARTED("removeContentTypeParser");
       }
       if (Array.isArray(contentType2)) {
-        for (const type17 of contentType2) {
-          this[kContentTypeParser].remove(type17);
+        for (const type18 of contentType2) {
+          this[kContentTypeParser].remove(type18);
         }
       } else {
         this[kContentTypeParser].remove(contentType2);
@@ -49908,9 +49908,9 @@ ${contextFunctionCode}`,
       context.functions.push(functionCode);
       return functionName;
     }
-    function buildArrayTypeCondition(type17, accessor) {
+    function buildArrayTypeCondition(type18, accessor) {
       let condition;
-      switch (type17) {
+      switch (type18) {
         case "null":
           condition = "value === null";
           break;
@@ -49941,8 +49941,8 @@ ${contextFunctionCode}`,
           condition = "Array.isArray(value)";
           break;
         default:
-          if (Array.isArray(type17)) {
-            const conditions = type17.map((subType) => {
+          if (Array.isArray(type18)) {
+            const conditions = type18.map((subType) => {
               return buildArrayTypeCondition(subType, accessor);
             });
             condition = `(${conditions.join(" || ")})`;
@@ -49957,11 +49957,11 @@ ${contextFunctionCode}`,
       const schema = location.schema;
       const types = schema.type.sort((t1) => t1 === "null" ? -1 : 1);
       let code = "";
-      types.forEach((type17, index) => {
-        location.schema = { ...location.schema, type: type17 };
+      types.forEach((type18, index) => {
+        location.schema = { ...location.schema, type: type18 };
         const nestedResult = buildSingleTypeSerializer(context, location, input);
         const statement = index === 0 ? "if" : "else if";
-        switch (type17) {
+        switch (type18) {
           case "null":
             code += `
           ${statement} (${input} === null)
@@ -50001,7 +50001,7 @@ ${contextFunctionCode}`,
           }
           default: {
             code += `
-          ${statement}(typeof ${input} === "${type17}" || ${input} === null)
+          ${statement}(typeof ${input} === "${type18}" || ${input} === null)
             ${nestedResult}
         `;
             break;
@@ -50071,8 +50071,8 @@ ${contextFunctionCode}`,
     }
     function buildConstSerializer(location, input) {
       const schema = location.schema;
-      const type17 = schema.type;
-      const hasNullType = Array.isArray(type17) && type17.includes("null");
+      const type18 = schema.type;
+      const hasNullType = Array.isArray(type18) && type18.includes("null");
       let code = "";
       if (hasNullType) {
         code += `
@@ -50116,14 +50116,14 @@ ${contextFunctionCode}`,
     function buildOneOf(context, location, input) {
       context.validatorSchemasIds.add(location.schemaId);
       const schema = location.schema;
-      const type17 = schema.anyOf ? "anyOf" : "oneOf";
-      const { [type17]: oneOfs, ...schemaWithoutAnyOf } = location.schema;
+      const type18 = schema.anyOf ? "anyOf" : "oneOf";
+      const { [type18]: oneOfs, ...schemaWithoutAnyOf } = location.schema;
       const locationWithoutOneOf = new Location(
         schemaWithoutAnyOf,
         location.schemaId,
         location.jsonPointer
       );
-      const oneOfsLocation = location.getPropertyLocation(type17);
+      const oneOfsLocation = location.getPropertyLocation(type18);
       let code = "";
       for (let index = 0; index < oneOfs.length; index++) {
         const optionLocation = oneOfsLocation.getPropertyLocation(index);
@@ -50239,7 +50239,7 @@ ${contextFunctionCode}`,
         }
       }
       let code = "";
-      const type17 = schema.type;
+      const type18 = schema.type;
       const nullable2 = schema.nullable === true;
       if (nullable2) {
         code += `
@@ -50250,7 +50250,7 @@ ${contextFunctionCode}`,
       }
       if (schema.const !== void 0) {
         code += buildConstSerializer(location, input);
-      } else if (Array.isArray(type17)) {
+      } else if (Array.isArray(type18)) {
         code += buildMultiTypeSerializer(context, location, input);
       } else {
         code += buildSingleTypeSerializer(context, location, input);
@@ -54909,9 +54909,9 @@ var require_fast_decode_uri_component = __commonJS({
         var high = hexCodeToInt(uri[percentPosition + 1], 4);
         var low = hexCodeToInt(uri[percentPosition + 2], 0);
         var byte = high | low;
-        var type17 = UTF8_DATA[byte];
-        state = UTF8_DATA[256 + state + type17];
-        codepoint = codepoint << 6 | byte & UTF8_DATA[364 + type17];
+        var type18 = UTF8_DATA[byte];
+        state = UTF8_DATA[256 + state + type18];
+        codepoint = codepoint << 6 | byte & UTF8_DATA[364 + type18];
         if (state === UTF8_ACCEPT) {
           decoded += uri.slice(last, startOfOctets);
           decoded += codepoint <= 65535 ? String.fromCharCode(codepoint) : String.fromCharCode(
@@ -55252,14 +55252,14 @@ var require_stringify = __commonJS({
     "use strict";
     var { encodeString } = require_querystring();
     function getAsPrimitive(value) {
-      const type17 = typeof value;
-      if (type17 === "string") {
+      const type18 = typeof value;
+      if (type18 === "string") {
         return encodeString(value);
-      } else if (type17 === "bigint") {
+      } else if (type18 === "bigint") {
         return value.toString();
-      } else if (type17 === "boolean") {
+      } else if (type18 === "boolean") {
         return value ? "true" : "false";
-      } else if (type17 === "number" && Number.isFinite(value)) {
+      } else if (type18 === "number" && Number.isFinite(value)) {
         return value < 1e21 ? "" + value : encodeString("" + value);
       }
       return "";
@@ -56097,11 +56097,11 @@ var require_http_method = __commonJS({
       storage: function() {
         const handlers = /* @__PURE__ */ new Map();
         return {
-          get: (type17) => {
-            return handlers.get(type17) || null;
+          get: (type18) => {
+            return handlers.get(type18) || null;
           },
-          set: (type17, store) => {
-            handlers.set(type17, store);
+          set: (type18, store) => {
+            handlers.set(type18, store);
           }
         };
       },
@@ -62884,8 +62884,8 @@ var require_depd = __commonJS({
       deprecate.property = wrapproperty;
       return deprecate;
     }
-    function eehaslisteners(emitter, type17) {
-      var count = typeof emitter.listenerCount !== "function" ? emitter.listeners(type17).length : emitter.listenerCount(type17);
+    function eehaslisteners(emitter, type18) {
+      var count = typeof emitter.listenerCount !== "function" ? emitter.listeners(type18).length : emitter.listenerCount(type18);
       return count > 0;
     }
     function isignored(namespace) {
@@ -63365,18 +63365,18 @@ var require_http_errors = __commonJS({
       var props = {};
       for (var i2 = 0; i2 < arguments.length; i2++) {
         var arg = arguments[i2];
-        var type17 = typeof arg;
-        if (type17 === "object" && arg instanceof Error) {
+        var type18 = typeof arg;
+        if (type18 === "object" && arg instanceof Error) {
           err = arg;
           status = err.status || err.statusCode || status;
-        } else if (type17 === "number" && i2 === 0) {
+        } else if (type18 === "number" && i2 === 0) {
           status = arg;
-        } else if (type17 === "string") {
+        } else if (type18 === "string") {
           msg = arg;
-        } else if (type17 === "object") {
+        } else if (type18 === "object") {
           props = arg;
         } else {
-          throw new TypeError("argument #" + (i2 + 1) + " unsupported type " + type17);
+          throw new TypeError("argument #" + (i2 + 1) + " unsupported type " + type18);
         }
       }
       if (typeof status === "number" && (status < 400 || status >= 600)) {
@@ -67533,11 +67533,11 @@ var require_content_type = __commonJS({
         throw new TypeError("argument obj is required");
       }
       var parameters = obj.parameters;
-      var type17 = obj.type;
-      if (!type17 || !TYPE_REGEXP.test(type17)) {
+      var type18 = obj.type;
+      if (!type18 || !TYPE_REGEXP.test(type18)) {
         throw new TypeError("invalid type");
       }
-      var string4 = type17;
+      var string4 = type18;
       if (parameters && typeof parameters === "object") {
         var param;
         var params = Object.keys(parameters).sort();
@@ -67560,11 +67560,11 @@ var require_content_type = __commonJS({
         throw new TypeError("argument string is required to be a string");
       }
       var index = header.indexOf(";");
-      var type17 = index !== -1 ? header.slice(0, index).trim() : header.trim();
-      if (!TYPE_REGEXP.test(type17)) {
+      var type18 = index !== -1 ? header.slice(0, index).trim() : header.trim();
+      if (!TYPE_REGEXP.test(type18)) {
         throw new TypeError("invalid media type");
       }
-      var obj = new ContentType(type17.toLowerCase());
+      var obj = new ContentType(type18.toLowerCase());
       if (index !== -1) {
         var key;
         var match;
@@ -67613,9 +67613,9 @@ var require_content_type = __commonJS({
       }
       return '"' + str.replace(QUOTE_REGEXP, "\\$1") + '"';
     }
-    function ContentType(type17) {
+    function ContentType(type18) {
       this.parameters = /* @__PURE__ */ Object.create(null);
-      this.type = type17;
+      this.type = type18;
     }
   }
 });
@@ -83829,9 +83829,9 @@ function convertBaseSchema(schema, ctx) {
   if (schema.const !== void 0) {
     return z3.literal(schema.const);
   }
-  const type17 = schema.type;
-  if (Array.isArray(type17)) {
-    const typeSchemas = type17.map((t4) => {
+  const type18 = schema.type;
+  if (Array.isArray(type18)) {
+    const typeSchemas = type18.map((t4) => {
       const typeSchema = { ...schema, type: t4 };
       return convertBaseSchema(typeSchema, ctx);
     });
@@ -83843,11 +83843,11 @@ function convertBaseSchema(schema, ctx) {
     }
     return z3.union(typeSchemas);
   }
-  if (!type17) {
+  if (!type18) {
     return z3.any();
   }
   let zodSchema2;
-  switch (type17) {
+  switch (type18) {
     case "string": {
       let stringSchema = z3.string();
       if (schema.format) {
@@ -83914,7 +83914,7 @@ function convertBaseSchema(schema, ctx) {
     }
     case "number":
     case "integer": {
-      let numberSchema = type17 === "integer" ? z3.number().int() : z3.number();
+      let numberSchema = type18 === "integer" ? z3.number().int() : z3.number();
       if (typeof schema.minimum === "number") {
         numberSchema = numberSchema.min(schema.minimum);
       }
@@ -84049,7 +84049,7 @@ function convertBaseSchema(schema, ctx) {
       break;
     }
     default:
-      throw new Error(`Unsupported type: ${type17}`);
+      throw new Error(`Unsupported type: ${type18}`);
   }
   if (schema.description) {
     zodSchema2 = zodSchema2.describe(schema.description);
@@ -87998,33 +87998,33 @@ ZodUnion2.create = (types, params) => {
     ...processCreateParams(params)
   });
 };
-var getDiscriminator = (type17) => {
-  if (type17 instanceof ZodLazy2) {
-    return getDiscriminator(type17.schema);
-  } else if (type17 instanceof ZodEffects) {
-    return getDiscriminator(type17.innerType());
-  } else if (type17 instanceof ZodLiteral2) {
-    return [type17.value];
-  } else if (type17 instanceof ZodEnum2) {
-    return type17.options;
-  } else if (type17 instanceof ZodNativeEnum) {
-    return util.objectValues(type17.enum);
-  } else if (type17 instanceof ZodDefault2) {
-    return getDiscriminator(type17._def.innerType);
-  } else if (type17 instanceof ZodUndefined2) {
+var getDiscriminator = (type18) => {
+  if (type18 instanceof ZodLazy2) {
+    return getDiscriminator(type18.schema);
+  } else if (type18 instanceof ZodEffects) {
+    return getDiscriminator(type18.innerType());
+  } else if (type18 instanceof ZodLiteral2) {
+    return [type18.value];
+  } else if (type18 instanceof ZodEnum2) {
+    return type18.options;
+  } else if (type18 instanceof ZodNativeEnum) {
+    return util.objectValues(type18.enum);
+  } else if (type18 instanceof ZodDefault2) {
+    return getDiscriminator(type18._def.innerType);
+  } else if (type18 instanceof ZodUndefined2) {
     return [void 0];
-  } else if (type17 instanceof ZodNull2) {
+  } else if (type18 instanceof ZodNull2) {
     return [null];
-  } else if (type17 instanceof ZodOptional2) {
-    return [void 0, ...getDiscriminator(type17.unwrap())];
-  } else if (type17 instanceof ZodNullable2) {
-    return [null, ...getDiscriminator(type17.unwrap())];
-  } else if (type17 instanceof ZodBranded) {
-    return getDiscriminator(type17.unwrap());
-  } else if (type17 instanceof ZodReadonly2) {
-    return getDiscriminator(type17.unwrap());
-  } else if (type17 instanceof ZodCatch2) {
-    return getDiscriminator(type17._def.innerType);
+  } else if (type18 instanceof ZodOptional2) {
+    return [void 0, ...getDiscriminator(type18.unwrap())];
+  } else if (type18 instanceof ZodNullable2) {
+    return [null, ...getDiscriminator(type18.unwrap())];
+  } else if (type18 instanceof ZodBranded) {
+    return getDiscriminator(type18.unwrap());
+  } else if (type18 instanceof ZodReadonly2) {
+    return getDiscriminator(type18.unwrap());
+  } else if (type18 instanceof ZodCatch2) {
+    return getDiscriminator(type18._def.innerType);
   } else {
     return [];
   }
@@ -88084,8 +88084,8 @@ var ZodDiscriminatedUnion2 = class _ZodDiscriminatedUnion extends ZodType2 {
    */
   static create(discriminator, options, params) {
     const optionsMap = /* @__PURE__ */ new Map();
-    for (const type17 of options) {
-      const discriminatorValues = getDiscriminator(type17.shape[discriminator]);
+    for (const type18 of options) {
+      const discriminatorValues = getDiscriminator(type18.shape[discriminator]);
       if (!discriminatorValues.length) {
         throw new Error(`A discriminator value for key \`${discriminator}\` could not be extracted from all schema options`);
       }
@@ -88093,7 +88093,7 @@ var ZodDiscriminatedUnion2 = class _ZodDiscriminatedUnion extends ZodType2 {
         if (optionsMap.has(value)) {
           throw new Error(`Discriminator property ${String(discriminator)} has duplicate value ${String(value)}`);
         }
-        optionsMap.set(value, type17);
+        optionsMap.set(value, type18);
       }
     }
     return new _ZodDiscriminatedUnion({
@@ -88904,9 +88904,9 @@ var ZodOptional2 = class extends ZodType2 {
     return this._def.innerType;
   }
 };
-ZodOptional2.create = (type17, params) => {
+ZodOptional2.create = (type18, params) => {
   return new ZodOptional2({
-    innerType: type17,
+    innerType: type18,
     typeName: ZodFirstPartyTypeKind2.ZodOptional,
     ...processCreateParams(params)
   });
@@ -88923,9 +88923,9 @@ var ZodNullable2 = class extends ZodType2 {
     return this._def.innerType;
   }
 };
-ZodNullable2.create = (type17, params) => {
+ZodNullable2.create = (type18, params) => {
   return new ZodNullable2({
-    innerType: type17,
+    innerType: type18,
     typeName: ZodFirstPartyTypeKind2.ZodNullable,
     ...processCreateParams(params)
   });
@@ -88947,9 +88947,9 @@ var ZodDefault2 = class extends ZodType2 {
     return this._def.innerType;
   }
 };
-ZodDefault2.create = (type17, params) => {
+ZodDefault2.create = (type18, params) => {
   return new ZodDefault2({
-    innerType: type17,
+    innerType: type18,
     typeName: ZodFirstPartyTypeKind2.ZodDefault,
     defaultValue: typeof params.default === "function" ? params.default : () => params.default,
     ...processCreateParams(params)
@@ -89000,9 +89000,9 @@ var ZodCatch2 = class extends ZodType2 {
     return this._def.innerType;
   }
 };
-ZodCatch2.create = (type17, params) => {
+ZodCatch2.create = (type18, params) => {
   return new ZodCatch2({
-    innerType: type17,
+    innerType: type18,
     typeName: ZodFirstPartyTypeKind2.ZodCatch,
     catchValue: typeof params.catch === "function" ? params.catch : () => params.catch,
     ...processCreateParams(params)
@@ -89113,9 +89113,9 @@ var ZodReadonly2 = class extends ZodType2 {
     return this._def.innerType;
   }
 };
-ZodReadonly2.create = (type17, params) => {
+ZodReadonly2.create = (type18, params) => {
   return new ZodReadonly2({
-    innerType: type17,
+    innerType: type18,
     typeName: ZodFirstPartyTypeKind2.ZodReadonly,
     ...processCreateParams(params)
   });
@@ -90031,9 +90031,9 @@ function parseEnumDef(def) {
     enum: Array.from(def.values)
   };
 }
-var isJsonSchema7AllOfType = (type17) => {
-  if ("type" in type17 && type17.type === "string") return false;
-  return "allOf" in type17;
+var isJsonSchema7AllOfType = (type18) => {
+  if ("type" in type18 && type18.type === "string") return false;
+  return "allOf" in type18;
 };
 function parseIntersectionDef(def, refs) {
   const allOf = [
@@ -90417,7 +90417,7 @@ function parseRecordDef(def, refs) {
     })) != null ? _a210 : refs.allowedAdditionalProperties
   };
   if (((_b210 = def.keyType) == null ? void 0 : _b210._def.typeName) === ZodFirstPartyTypeKind2.ZodString && ((_c9 = def.keyType._def.checks) == null ? void 0 : _c9.length)) {
-    const { type: type17, ...keyType } = parseStringDef(def.keyType._def, refs);
+    const { type: type18, ...keyType } = parseStringDef(def.keyType._def, refs);
     return {
       ...schema,
       propertyNames: keyType
@@ -90430,7 +90430,7 @@ function parseRecordDef(def, refs) {
       }
     };
   } else if (((_e6 = def.keyType) == null ? void 0 : _e6._def.typeName) === ZodFirstPartyTypeKind2.ZodBranded && def.keyType._def.type._def.typeName === ZodFirstPartyTypeKind2.ZodString && ((_f5 = def.keyType._def.type._def.checks) == null ? void 0 : _f5.length)) {
-    const { type: type17, ...keyType } = parseBrandedDef(
+    const { type: type18, ...keyType } = parseBrandedDef(
       def.keyType._def,
       refs
     );
@@ -90499,8 +90499,8 @@ function parseUnionDef(def, refs) {
     (x3) => x3._def.typeName in primitiveMappings && (!x3._def.checks || !x3._def.checks.length)
   )) {
     const types = options.reduce((types2, x3) => {
-      const type17 = primitiveMappings[x3._def.typeName];
-      return type17 && !types2.includes(type17) ? [...types2, type17] : types2;
+      const type18 = primitiveMappings[x3._def.typeName];
+      return type18 && !types2.includes(type18) ? [...types2, type18] : types2;
     }, []);
     return {
       type: types.length > 1 ? types : types[0]
@@ -90508,12 +90508,12 @@ function parseUnionDef(def, refs) {
   } else if (options.every((x3) => x3._def.typeName === "ZodLiteral" && !x3.description)) {
     const types = options.reduce(
       (acc, x3) => {
-        const type17 = typeof x3._def.value;
-        switch (type17) {
+        const type18 = typeof x3._def.value;
+        switch (type18) {
           case "string":
           case "number":
           case "boolean":
-            return [...acc, type17];
+            return [...acc, type18];
           case "bigint":
             return [...acc, "integer"];
           case "object":
@@ -92472,7 +92472,7 @@ var isCompatible = _makeCompatibilityCheck(VERSION3);
 var major = VERSION3.split(".")[0];
 var GLOBAL_OPENTELEMETRY_API_KEY = /* @__PURE__ */ Symbol.for("opentelemetry.js.api." + major);
 var _global = _globalThis;
-function registerGlobal(type17, instance, diag, allowOverride) {
+function registerGlobal(type18, instance, diag, allowOverride) {
   var _a39;
   if (allowOverride === void 0) {
     allowOverride = false;
@@ -92480,33 +92480,33 @@ function registerGlobal(type17, instance, diag, allowOverride) {
   var api = _global[GLOBAL_OPENTELEMETRY_API_KEY] = (_a39 = _global[GLOBAL_OPENTELEMETRY_API_KEY]) !== null && _a39 !== void 0 ? _a39 : {
     version: VERSION3
   };
-  if (!allowOverride && api[type17]) {
-    var err = new Error("@opentelemetry/api: Attempted duplicate registration of API: " + type17);
+  if (!allowOverride && api[type18]) {
+    var err = new Error("@opentelemetry/api: Attempted duplicate registration of API: " + type18);
     diag.error(err.stack || err.message);
     return false;
   }
   if (api.version !== VERSION3) {
-    var err = new Error("@opentelemetry/api: Registration of version v" + api.version + " for " + type17 + " does not match previously registered API v" + VERSION3);
+    var err = new Error("@opentelemetry/api: Registration of version v" + api.version + " for " + type18 + " does not match previously registered API v" + VERSION3);
     diag.error(err.stack || err.message);
     return false;
   }
-  api[type17] = instance;
-  diag.debug("@opentelemetry/api: Registered a global for " + type17 + " v" + VERSION3 + ".");
+  api[type18] = instance;
+  diag.debug("@opentelemetry/api: Registered a global for " + type18 + " v" + VERSION3 + ".");
   return true;
 }
-function getGlobal(type17) {
+function getGlobal(type18) {
   var _a39, _b31;
   var globalVersion = (_a39 = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _a39 === void 0 ? void 0 : _a39.version;
   if (!globalVersion || !isCompatible(globalVersion)) {
     return;
   }
-  return (_b31 = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _b31 === void 0 ? void 0 : _b31[type17];
+  return (_b31 = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _b31 === void 0 ? void 0 : _b31[type18];
 }
-function unregisterGlobal(type17, diag) {
-  diag.debug("@opentelemetry/api: Unregistering a global for " + type17 + " v" + VERSION3 + ".");
+function unregisterGlobal(type18, diag) {
+  diag.debug("@opentelemetry/api: Unregistering a global for " + type18 + " v" + VERSION3 + ".");
   var api = _global[GLOBAL_OPENTELEMETRY_API_KEY];
   if (api) {
-    delete api[type17];
+    delete api[type18];
   }
 }
 
@@ -93989,8 +93989,8 @@ function convertPartToLanguageModelPart(part, downloadedAssets) {
     };
   }
   let originalData;
-  const type17 = part.type;
-  switch (type17) {
+  const type18 = part.type;
+  switch (type18) {
     case "image":
       originalData = part.image;
       break;
@@ -93998,7 +93998,7 @@ function convertPartToLanguageModelPart(part, downloadedAssets) {
       originalData = part.data;
       break;
     default:
-      throw new Error(`Unsupported part type: ${type17}`);
+      throw new Error(`Unsupported part type: ${type18}`);
   }
   const { data: convertedData, mediaType: convertedMediaType } = convertToLanguageModelV3DataContent(originalData);
   let mediaType = convertedMediaType != null ? convertedMediaType : part.mediaType;
@@ -94010,7 +94010,7 @@ function convertPartToLanguageModelPart(part, downloadedAssets) {
       mediaType != null ? mediaType : mediaType = downloadedFile.mediaType;
     }
   }
-  switch (type17) {
+  switch (type18) {
     case "image": {
       if (data instanceof Uint8Array || typeof data === "string") {
         mediaType = (_a162 = detectMediaType({ data, signatures: imageMediaTypeSignatures })) != null ? _a162 : mediaType;
@@ -100495,12 +100495,12 @@ function prepareChatTools({
   if (toolChoice == null) {
     return { tools: openaiTools2, toolChoice: void 0, toolWarnings };
   }
-  const type17 = toolChoice.type;
-  switch (type17) {
+  const type18 = toolChoice.type;
+  switch (type18) {
     case "auto":
     case "none":
     case "required":
-      return { tools: openaiTools2, toolChoice: type17, toolWarnings };
+      return { tools: openaiTools2, toolChoice: type18, toolWarnings };
     case "tool":
       return {
         tools: openaiTools2,
@@ -100513,7 +100513,7 @@ function prepareChatTools({
         toolWarnings
       };
     default: {
-      const _exhaustiveCheck = type17;
+      const _exhaustiveCheck = type18;
       throw new UnsupportedFunctionalityError({
         functionality: `tool choice type: ${_exhaustiveCheck}`
       });
@@ -103717,12 +103717,12 @@ async function prepareResponsesTools({
   if (toolChoice == null) {
     return { tools: openaiTools2, toolChoice: void 0, toolWarnings };
   }
-  const type17 = toolChoice.type;
-  switch (type17) {
+  const type18 = toolChoice.type;
+  switch (type18) {
     case "auto":
     case "none":
     case "required":
-      return { tools: openaiTools2, toolChoice: type17, toolWarnings };
+      return { tools: openaiTools2, toolChoice: type18, toolWarnings };
     case "tool":
       return {
         tools: openaiTools2,
@@ -103730,7 +103730,7 @@ async function prepareResponsesTools({
         toolWarnings
       };
     default: {
-      const _exhaustiveCheck = type17;
+      const _exhaustiveCheck = type18;
       throw new UnsupportedFunctionalityError({
         functionality: `tool choice type: ${_exhaustiveCheck}`
       });
@@ -106810,8 +106810,8 @@ async function prepareTools({
       betas
     };
   }
-  const type17 = toolChoice.type;
-  switch (type17) {
+  const type18 = toolChoice.type;
+  switch (type18) {
     case "auto":
       return {
         tools: anthropicTools2,
@@ -106846,7 +106846,7 @@ async function prepareTools({
         betas
       };
     default: {
-      const _exhaustiveCheck = type17;
+      const _exhaustiveCheck = type18;
       throw new UnsupportedFunctionalityError({
         functionality: `tool choice type: ${_exhaustiveCheck}`
       });
@@ -107101,8 +107101,8 @@ async function convertToAnthropicMessagesPrompt({
   for (let i2 = 0; i2 < blocks.length; i2++) {
     const block = blocks[i2];
     const isLastBlock = i2 === blocks.length - 1;
-    const type17 = block.type;
-    switch (type17) {
+    const type18 = block.type;
+    switch (type18) {
       case "system": {
         if (system != null) {
           throw new UnsupportedFunctionalityError({
@@ -107738,7 +107738,7 @@ async function convertToAnthropicMessagesPrompt({
         break;
       }
       default: {
-        const _exhaustiveCheck = type17;
+        const _exhaustiveCheck = type18;
         throw new Error(`content type: ${_exhaustiveCheck}`);
       }
     }
@@ -109962,7 +109962,7 @@ function convertJSONSchemaToOpenAPISchema(jsonSchema2, isRoot = true) {
     return { type: "boolean", properties: {} };
   }
   const {
-    type: type17,
+    type: type18,
     description,
     required: required2,
     properties,
@@ -109982,10 +109982,10 @@ function convertJSONSchemaToOpenAPISchema(jsonSchema2, isRoot = true) {
   if (constValue !== void 0) {
     result.enum = [constValue];
   }
-  if (type17) {
-    if (Array.isArray(type17)) {
-      const hasNull = type17.includes("null");
-      const nonNullTypes = type17.filter((t4) => t4 !== "null");
+  if (type18) {
+    if (Array.isArray(type18)) {
+      const hasNull = type18.includes("null");
+      const nonNullTypes = type18.filter((t4) => t4 !== "null");
       if (nonNullTypes.length === 0) {
         result.type = "null";
       } else {
@@ -109995,7 +109995,7 @@ function convertJSONSchemaToOpenAPISchema(jsonSchema2, isRoot = true) {
         }
       }
     } else {
-      result.type = type17;
+      result.type = type18;
     }
   }
   if (enumValues !== void 0) {
@@ -110506,8 +110506,8 @@ function prepareTools2({
       toolWarnings
     };
   }
-  const type17 = toolChoice.type;
-  switch (type17) {
+  const type18 = toolChoice.type;
+  switch (type18) {
     case "auto":
       return {
         tools: [{ functionDeclarations }],
@@ -110538,7 +110538,7 @@ function prepareTools2({
         toolWarnings
       };
     default: {
-      const _exhaustiveCheck = type17;
+      const _exhaustiveCheck = type18;
       throw new UnsupportedFunctionalityError({
         functionality: `tool choice type: ${_exhaustiveCheck}`
       });
@@ -112553,12 +112553,12 @@ function prepareResponsesTools2({
   if (toolChoice == null) {
     return { tools: ollamaTools, toolChoice: void 0, toolWarnings };
   }
-  const type17 = toolChoice.type;
-  switch (type17) {
+  const type18 = toolChoice.type;
+  switch (type18) {
     case "auto":
     case "none":
     case "required":
-      return { tools: ollamaTools, toolChoice: type17, toolWarnings };
+      return { tools: ollamaTools, toolChoice: type18, toolWarnings };
     case "tool":
       return {
         tools: ollamaTools,
@@ -112566,7 +112566,7 @@ function prepareResponsesTools2({
         toolWarnings
       };
     default: {
-      const _exhaustiveCheck = type17;
+      const _exhaustiveCheck = type18;
       throw new UnsupportedFunctionalityError({
         functionality: `tool choice type: ${_exhaustiveCheck}`
       });
@@ -113216,12 +113216,12 @@ function prepareTools3({
   if (toolChoice == null) {
     return { tools: openaiCompatTools, toolChoice: void 0, toolWarnings };
   }
-  const type17 = toolChoice.type;
-  switch (type17) {
+  const type18 = toolChoice.type;
+  switch (type18) {
     case "auto":
     case "none":
     case "required":
-      return { tools: openaiCompatTools, toolChoice: type17, toolWarnings };
+      return { tools: openaiCompatTools, toolChoice: type18, toolWarnings };
     case "tool":
       return {
         tools: openaiCompatTools,
@@ -113232,7 +113232,7 @@ function prepareTools3({
         toolWarnings
       };
     default: {
-      const _exhaustiveCheck = type17;
+      const _exhaustiveCheck = type18;
       throw new UnsupportedFunctionalityError({
         functionality: `tool choice type: ${_exhaustiveCheck}`
       });
@@ -115844,6 +115844,28 @@ var SkillFetchScriptResponse = class extends NatsResponse {
 };
 NatsMessage.register(SkillFetchScriptResponse);
 
+// ../common/src/messages/client-connection.publish.ts
+var type17 = "client-connection";
+var ClientConnectionPublish = class extends NatsPublish {
+  constructor() {
+    super(...arguments);
+    this.type = type17;
+  }
+  static {
+    this.type = type17;
+  }
+  validate(data) {
+    return typeof data.workspaceId === "string" && data.workspaceId.length > 0 && typeof data.clientName === "string" && data.clientName.length > 0 && typeof data.protocolVersion === "string" && data.protocolVersion.length > 0;
+  }
+  getSubject() {
+    return `${this.data.workspaceId}.${type17}`;
+  }
+  static subscribeToAll() {
+    return `*.${type17}`;
+  }
+};
+NatsMessage.register(ClientConnectionPublish);
+
 // ../common/src/graphql/dgraph.resolvers.types.ts
 var dgraph_resolvers_types_exports = {};
 __export(dgraph_resolvers_types_exports, {
@@ -120349,6 +120371,36 @@ Scripts run based on their configured execution target (AGENT or EDGE).`,
   getIdentity() {
     return this.identity;
   }
+  /**
+   * Publish a client connection event for monitoring.
+   * Called when an MCP client completes the initialize handshake.
+   */
+  publishClientConnection(clientInfo, protocolVersion) {
+    const { name: name17, ...metadata } = clientInfo;
+    const metadataStr = JSON.stringify(metadata);
+    let safeMetadata = { ...metadata };
+    if (metadataStr.length > 10240) {
+      this.logger.warn({ metadataSize: metadataStr.length }, "Client connection metadata exceeds 10KB limit, truncating");
+      safeMetadata = {};
+    }
+    if (this.identity.publishAllTools != null) {
+      safeMetadata.publishAllTools = this.identity.publishAllTools;
+    }
+    if (this.identity.preloadedSkillIds != null) {
+      safeMetadata.skillIds = this.identity.preloadedSkillIds;
+    }
+    if (this.identity.preloadedHatIds != null) {
+      safeMetadata.hatIds = this.identity.preloadedHatIds;
+    }
+    const message = ClientConnectionPublish.create({
+      workspaceId: this.identity.workspaceId,
+      clientName: String(name17 || "unknown"),
+      protocolVersion: String(protocolVersion || "unknown"),
+      metadata: safeMetadata,
+      userId: this.identity.id
+    });
+    this.natsService.publish(message);
+  }
   /**
    * Set publishAllTools from a client-detection default.
    * If the user explicitly provided publishAllTools via query param, this is a no-op.
@@ -121317,6 +121369,12 @@ var McpStdioService = class McpStdioService2 extends Service {
           }
         }
       };
+      try {
+        const rawClientInfo = request.params.clientInfo || {};
+        this.skillService.publishClientConnection(rawClientInfo, negotiatedVersion);
+      } catch (error48) {
+        this.logger.error({ err: error48 }, "Failed to publish client connection event");
+      }
       await this.skillService.waitForTools();
       return response;
     });
@@ -121354,8 +121412,8 @@ var McpStdioService = class McpStdioService2 extends Service {
         const result = await this.skillService.callTool(request.params.name, request.params.arguments);
         return result;
       } catch (error48) {
-        this.logger.error(`Error listing tools: ${error48 instanceof Error ? error48.message : String(error48)}`);
-        throw new Error(`Error listing tools: ${error48 instanceof Error ? error48.message : String(error48)}`);
+        this.logger.error(`Error calling tool: ${error48 instanceof Error ? error48.message : String(error48)}`);
+        throw new Error(`Error calling tool: ${error48 instanceof Error ? error48.message : String(error48)}`);
       }
     });
   }
@@ -121937,6 +121995,12 @@ var McpRequestHandlers = class {
     const negotiatedVersion = negotiateProtocolVersion(initRequest.params.protocolVersion);
     session.negotiatedProtocolVersion = negotiatedVersion;
     logger.debug(`Negotiated protocol version: ${negotiatedVersion}`);
+    try {
+      const rawClientInfo = initRequest.params.clientInfo || {};
+      session.skillService.publishClientConnection(rawClientInfo, negotiatedVersion);
+    } catch (error48) {
+      logger.error({ err: error48 }, "Failed to publish client connection event");
+    }
     const identity = session.skillService.getIdentity();
     const response = {
       serverInfo: {
@@ -125162,8 +125226,8 @@ function extractWWWAuthenticateParams(res) {
   if (!authenticateHeader) {
     return {};
   }
-  const [type17, scheme] = authenticateHeader.split(" ");
-  if (type17.toLowerCase() !== "bearer" || !scheme) {
+  const [type18, scheme] = authenticateHeader.split(" ");
+  if (type18.toLowerCase() !== "bearer" || !scheme) {
     return {};
   }
   const resourceMetadataMatch = extractFieldFromWwwAuth(res, "resource_metadata") || void 0;
@@ -125295,7 +125359,7 @@ async function discoverAuthorizationServerMetadata(authorizationServerUrl, { fet
     Accept: "application/json"
   };
   const urlsToTry = buildDiscoveryUrls(authorizationServerUrl);
-  for (const { url: endpointUrl, type: type17 } of urlsToTry) {
+  for (const { url: endpointUrl, type: type18 } of urlsToTry) {
     const response = await fetchWithCorsRetry(endpointUrl, headers, fetchFn);
     if (!response) {
       continue;
@@ -125305,9 +125369,9 @@ async function discoverAuthorizationServerMetadata(authorizationServerUrl, { fet
       if (response.status >= 400 && response.status < 500) {
         continue;
       }
-      throw new Error(`HTTP ${response.status} trying to load ${type17 === "oauth" ? "OAuth" : "OpenID provider"} metadata from ${endpointUrl}`);
+      throw new Error(`HTTP ${response.status} trying to load ${type18 === "oauth" ? "OAuth" : "OpenID provider"} metadata from ${endpointUrl}`);
     }
-    if (type17 === "oauth") {
+    if (type18 === "oauth") {
       return OAuthMetadataSchema.parse(await response.json());
     } else {
       return OpenIdProviderDiscoveryMetadataSchema.parse(await response.json());
@@ -125853,9 +125917,9 @@ var ErrorEvent = class extends Event {
    * @param type - The type of the event (should be "error")
    * @param errorEventInitDict - Optional properties to include in the error event
    */
-  constructor(type17, errorEventInitDict) {
+  constructor(type18, errorEventInitDict) {
     var _a39, _b31;
-    super(type17), this.code = (_a39 = errorEventInitDict == null ? void 0 : errorEventInitDict.code) != null ? _a39 : void 0, this.message = (_b31 = errorEventInitDict == null ? void 0 : errorEventInitDict.message) != null ? _b31 : void 0;
+    super(type18), this.code = (_a39 = errorEventInitDict == null ? void 0 : errorEventInitDict.code) != null ? _a39 : void 0, this.message = (_b31 = errorEventInitDict == null ? void 0 : errorEventInitDict.message) != null ? _b31 : void 0;
   }
   /**
    * Node.js "hides" the `message` and `code` properties of the `ErrorEvent` instance,
@@ -126050,13 +126114,13 @@ var EventSource = class extends EventTarget {
   set onopen(value) {
     __privateSet(this, _onOpen, value);
   }
-  addEventListener(type17, listener, options) {
+  addEventListener(type18, listener, options) {
     const listen = listener;
-    super.addEventListener(type17, listen, options);
+    super.addEventListener(type18, listen, options);
   }
-  removeEventListener(type17, listener, options) {
+  removeEventListener(type18, listener, options) {
     const listen = listener;
-    super.removeEventListener(type17, listen, options);
+    super.removeEventListener(type18, listen, options);
   }
   /**
    * Aborts any instances of the fetch algorithm started for this EventSource object, and sets the readyState attribute to CLOSED.