@dylanrussell/agent-router 2.0.1 → 2.1.0

package/dist/plugin.js

@@ -729,9 +729,9 @@ function floatSafeRemainder(val, step) {
   return ratio - roundedRatio;
 }
 var EVALUATING = /* @__PURE__ */ Symbol("evaluating");
-function defineLazy(object2, key, getter) {
+function defineLazy(object2, key2, getter) {
   let value = void 0;
-  Object.defineProperty(object2, key, {
+  Object.defineProperty(object2, key2, {
     get() {
       if (value === EVALUATING) {
         return void 0;
@@ -743,7 +743,7 @@ function defineLazy(object2, key, getter) {
       return value;
     },
     set(v) {
-      Object.defineProperty(object2, key, {
+      Object.defineProperty(object2, key2, {
         value: v
         // configurable: true,
       });
@@ -776,11 +776,11 @@ function cloneDef(schema) {
 function getElementAtPath(obj, path8) {
   if (!path8)
     return obj;
-  return path8.reduce((acc, key) => acc?.[key], obj);
+  return path8.reduce((acc, key2) => acc?.[key2], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
-  const promises = keys.map((key) => promisesObj[key]);
+  const promises = keys.map((key2) => promisesObj[key2]);
   return Promise.all(promises).then((results) => {
     const resolvedObj = {};
     for (let i = 0; i < keys.length; i++) {
@@ -852,8 +852,8 @@ function shallowClone(o) {
 }
 function numKeys(data) {
   let keyCount = 0;
-  for (const key in data) {
-    if (Object.prototype.hasOwnProperty.call(data, key)) {
+  for (const key2 in data) {
+    if (Object.prototype.hasOwnProperty.call(data, key2)) {
       keyCount++;
     }
   }
@@ -1003,13 +1003,13 @@ function pick(schema, mask) {
   const def = mergeDefs(schema._zod.def, {
     get shape() {
       const newShape = {};
-      for (const key in mask) {
-        if (!(key in currDef.shape)) {
-          throw new Error(`Unrecognized key: "${key}"`);
+      for (const key2 in mask) {
+        if (!(key2 in currDef.shape)) {
+          throw new Error(`Unrecognized key: "${key2}"`);
         }
-        if (!mask[key])
+        if (!mask[key2])
           continue;
-        newShape[key] = currDef.shape[key];
+        newShape[key2] = currDef.shape[key2];
       }
       assignProp(this, "shape", newShape);
       return newShape;
@@ -1028,13 +1028,13 @@ function omit(schema, mask) {
   const def = mergeDefs(schema._zod.def, {
     get shape() {
       const newShape = { ...schema._zod.def.shape };
-      for (const key in mask) {
-        if (!(key in currDef.shape)) {
-          throw new Error(`Unrecognized key: "${key}"`);
+      for (const key2 in mask) {
+        if (!(key2 in currDef.shape)) {
+          throw new Error(`Unrecognized key: "${key2}"`);
         }
-        if (!mask[key])
+        if (!mask[key2])
           continue;
-        delete newShape[key];
+        delete newShape[key2];
       }
       assignProp(this, "shape", newShape);
       return newShape;
@@ -1051,8 +1051,8 @@ function extend(schema, shape) {
   const hasChecks = checks && checks.length > 0;
   if (hasChecks) {
     const existingShape = schema._zod.def.shape;
-    for (const key in shape) {
-      if (Object.getOwnPropertyDescriptor(existingShape, key) !== void 0) {
+    for (const key2 in shape) {
+      if (Object.getOwnPropertyDescriptor(existingShape, key2) !== void 0) {
         throw new Error("Cannot overwrite keys on object schemas containing refinements. Use `.safeExtend()` instead.");
       }
     }
@@ -1108,23 +1108,23 @@ function partial(Class2, schema, mask) {
       const oldShape = schema._zod.def.shape;
       const shape = { ...oldShape };
       if (mask) {
-        for (const key in mask) {
-          if (!(key in oldShape)) {
-            throw new Error(`Unrecognized key: "${key}"`);
+        for (const key2 in mask) {
+          if (!(key2 in oldShape)) {
+            throw new Error(`Unrecognized key: "${key2}"`);
           }
-          if (!mask[key])
+          if (!mask[key2])
             continue;
-          shape[key] = Class2 ? new Class2({
+          shape[key2] = Class2 ? new Class2({
             type: "optional",
-            innerType: oldShape[key]
-          }) : oldShape[key];
+            innerType: oldShape[key2]
+          }) : oldShape[key2];
         }
       } else {
-        for (const key in oldShape) {
-          shape[key] = Class2 ? new Class2({
+        for (const key2 in oldShape) {
+          shape[key2] = Class2 ? new Class2({
             type: "optional",
-            innerType: oldShape[key]
-          }) : oldShape[key];
+            innerType: oldShape[key2]
+          }) : oldShape[key2];
         }
       }
       assignProp(this, "shape", shape);
@@ -1140,22 +1140,22 @@ function required(Class2, schema, mask) {
       const oldShape = schema._zod.def.shape;
       const shape = { ...oldShape };
       if (mask) {
-        for (const key in mask) {
-          if (!(key in shape)) {
-            throw new Error(`Unrecognized key: "${key}"`);
+        for (const key2 in mask) {
+          if (!(key2 in shape)) {
+            throw new Error(`Unrecognized key: "${key2}"`);
           }
-          if (!mask[key])
+          if (!mask[key2])
             continue;
-          shape[key] = new Class2({
+          shape[key2] = new Class2({
             type: "nonoptional",
-            innerType: oldShape[key]
+            innerType: oldShape[key2]
           });
         }
       } else {
-        for (const key in oldShape) {
-          shape[key] = new Class2({
+        for (const key2 in oldShape) {
+          shape[key2] = new Class2({
             type: "nonoptional",
-            innerType: oldShape[key]
+            innerType: oldShape[key2]
           });
         }
       }
@@ -2936,13 +2936,13 @@ var $ZodArray = /* @__PURE__ */ $constructor("$ZodArray", (inst, def) => {
     return payload;
   };
 });
-function handlePropertyResult(result, final, key, input, isOptionalIn, isOptionalOut) {
-  const isPresent = key in input;
+function handlePropertyResult(result, final, key2, input, isOptionalIn, isOptionalOut) {
+  const isPresent = key2 in input;
   if (result.issues.length) {
     if (isOptionalIn && isOptionalOut && !isPresent) {
       return;
     }
-    final.issues.push(...prefixIssues(key, result.issues));
+    final.issues.push(...prefixIssues(key2, result.issues));
   }
   if (!isPresent && !isOptionalIn) {
     if (!result.issues.length) {
@@ -2950,17 +2950,17 @@ function handlePropertyResult(result, final, key, input, isOptionalIn, isOptiona
         code: "invalid_type",
         expected: "nonoptional",
         input: void 0,
-        path: [key]
+        path: [key2]
       });
     }
     return;
   }
   if (result.value === void 0) {
     if (isPresent) {
-      final.value[key] = void 0;
+      final.value[key2] = void 0;
     }
   } else {
-    final.value[key] = result.value;
+    final.value[key2] = result.value;
   }
 }
 function normalizeDef(def) {
@@ -2986,20 +2986,20 @@ function handleCatchall(proms, input, payload, ctx, def, inst) {
   const t = _catchall.def.type;
   const isOptionalIn = _catchall.optin === "optional";
   const isOptionalOut = _catchall.optout === "optional";
-  for (const key in input) {
-    if (key === "__proto__")
+  for (const key2 in input) {
+    if (key2 === "__proto__")
       continue;
-    if (keySet.has(key))
+    if (keySet.has(key2))
       continue;
     if (t === "never") {
-      unrecognized.push(key);
+      unrecognized.push(key2);
       continue;
     }
-    const r = _catchall.run({ value: input[key], issues: [] }, ctx);
+    const r = _catchall.run({ value: input[key2], issues: [] }, ctx);
     if (r instanceof Promise) {
-      proms.push(r.then((r2) => handlePropertyResult(r2, payload, key, input, isOptionalIn, isOptionalOut)));
+      proms.push(r.then((r2) => handlePropertyResult(r2, payload, key2, input, isOptionalIn, isOptionalOut)));
     } else {
-      handlePropertyResult(r, payload, key, input, isOptionalIn, isOptionalOut);
+      handlePropertyResult(r, payload, key2, input, isOptionalIn, isOptionalOut);
     }
   }
   if (unrecognized.length) {
@@ -3035,12 +3035,12 @@ var $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => {
   defineLazy(inst._zod, "propValues", () => {
     const shape = def.shape;
     const propValues = {};
-    for (const key in shape) {
-      const field = shape[key]._zod;
+    for (const key2 in shape) {
+      const field = shape[key2]._zod;
       if (field.values) {
-        propValues[key] ?? (propValues[key] = /* @__PURE__ */ new Set());
+        propValues[key2] ?? (propValues[key2] = /* @__PURE__ */ new Set());
         for (const v of field.values)
-          propValues[key].add(v);
+          propValues[key2].add(v);
       }
     }
     return propValues;
@@ -3063,15 +3063,15 @@ var $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => {
     payload.value = {};
     const proms = [];
     const shape = value.shape;
-    for (const key of value.keys) {
-      const el = shape[key];
+    for (const key2 of value.keys) {
+      const el = shape[key2];
       const isOptionalIn = el._zod.optin === "optional";
       const isOptionalOut = el._zod.optout === "optional";
-      const r = el._zod.run({ value: input[key], issues: [] }, ctx);
+      const r = el._zod.run({ value: input[key2], issues: [] }, ctx);
       if (r instanceof Promise) {
-        proms.push(r.then((r2) => handlePropertyResult(r2, payload, key, input, isOptionalIn, isOptionalOut)));
+        proms.push(r.then((r2) => handlePropertyResult(r2, payload, key2, input, isOptionalIn, isOptionalOut)));
       } else {
-        handlePropertyResult(r, payload, key, input, isOptionalIn, isOptionalOut);
+        handlePropertyResult(r, payload, key2, input, isOptionalIn, isOptionalOut);
       }
     }
     if (!catchall) {
@@ -3087,24 +3087,24 @@ var $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def) =>
   const generateFastpass = (shape) => {
     const doc = new Doc(["shape", "payload", "ctx"]);
     const normalized = _normalized.value;
-    const parseStr = (key) => {
-      const k = esc(key);
+    const parseStr = (key2) => {
+      const k = esc(key2);
       return `shape[${k}]._zod.run({ value: input[${k}], issues: [] }, ctx)`;
     };
     doc.write(`const input = payload.value;`);
     const ids = /* @__PURE__ */ Object.create(null);
     let counter = 0;
-    for (const key of normalized.keys) {
-      ids[key] = `key_${counter++}`;
+    for (const key2 of normalized.keys) {
+      ids[key2] = `key_${counter++}`;
     }
     doc.write(`const newResult = {};`);
-    for (const key of normalized.keys) {
-      const id = ids[key];
-      const k = esc(key);
-      const schema = shape[key];
+    for (const key2 of normalized.keys) {
+      const id = ids[key2];
+      const k = esc(key2);
+      const schema = shape[key2];
       const isOptionalIn = schema?._zod?.optin === "optional";
       const isOptionalOut = schema?._zod?.optout === "optional";
-      doc.write(`const ${id} = ${parseStr(key)};`);
+      doc.write(`const ${id} = ${parseStr(key2)};`);
       if (isOptionalIn && isOptionalOut) {
         doc.write(`
         if (${id}.issues.length) {
@@ -3416,17 +3416,17 @@ function mergeValues(a, b) {
   }
   if (isPlainObject(a) && isPlainObject(b)) {
     const bKeys = Object.keys(b);
-    const sharedKeys = Object.keys(a).filter((key) => bKeys.indexOf(key) !== -1);
+    const sharedKeys = Object.keys(a).filter((key2) => bKeys.indexOf(key2) !== -1);
     const newObj = { ...a, ...b };
-    for (const key of sharedKeys) {
-      const sharedValue = mergeValues(a[key], b[key]);
+    for (const key2 of sharedKeys) {
+      const sharedValue = mergeValues(a[key2], b[key2]);
       if (!sharedValue.valid) {
         return {
           valid: false,
-          mergeErrorPath: [key, ...sharedValue.mergeErrorPath]
+          mergeErrorPath: [key2, ...sharedValue.mergeErrorPath]
         };
       }
-      newObj[key] = sharedValue.data;
+      newObj[key2] = sharedValue.data;
     }
     return { valid: true, data: newObj };
   }
@@ -3561,9 +3561,9 @@ var $ZodTuple = /* @__PURE__ */ $constructor("$ZodTuple", (inst, def) => {
     return handleTupleResults(itemResults, payload, items, input, optoutStart);
   };
 });
-function getTupleOptStart(items, key) {
+function getTupleOptStart(items, key2) {
   for (let i = items.length - 1; i >= 0; i--) {
-    if (items[i]._zod[key] !== "optional")
+    if (items[i]._zod[key2] !== "optional")
       return i + 1;
   }
   return 0;
@@ -3614,10 +3614,10 @@ var $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
     if (values) {
       payload.value = {};
       const recordKeys = /* @__PURE__ */ new Set();
-      for (const key of values) {
-        if (typeof key === "string" || typeof key === "number" || typeof key === "symbol") {
-          recordKeys.add(typeof key === "number" ? key.toString() : key);
-          const keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx);
+      for (const key2 of values) {
+        if (typeof key2 === "string" || typeof key2 === "number" || typeof key2 === "symbol") {
+          recordKeys.add(typeof key2 === "number" ? key2.toString() : key2);
+          const keyResult = def.keyType._zod.run({ value: key2, issues: [] }, ctx);
           if (keyResult instanceof Promise) {
             throw new Error("Async schemas not supported in object keys currently");
           }
@@ -3626,34 +3626,34 @@ var $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
               code: "invalid_key",
               origin: "record",
               issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config())),
-              input: key,
-              path: [key],
+              input: key2,
+              path: [key2],
               inst
             });
             continue;
           }
           const outKey = keyResult.value;
-          const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);
+          const result = def.valueType._zod.run({ value: input[key2], issues: [] }, ctx);
           if (result instanceof Promise) {
             proms.push(result.then((result2) => {
               if (result2.issues.length) {
-                payload.issues.push(...prefixIssues(key, result2.issues));
+                payload.issues.push(...prefixIssues(key2, result2.issues));
               }
               payload.value[outKey] = result2.value;
             }));
           } else {
             if (result.issues.length) {
-              payload.issues.push(...prefixIssues(key, result.issues));
+              payload.issues.push(...prefixIssues(key2, result.issues));
             }
             payload.value[outKey] = result.value;
           }
         }
       }
       let unrecognized;
-      for (const key in input) {
-        if (!recordKeys.has(key)) {
+      for (const key2 in input) {
+        if (!recordKeys.has(key2)) {
           unrecognized = unrecognized ?? [];
-          unrecognized.push(key);
+          unrecognized.push(key2);
         }
       }
       if (unrecognized && unrecognized.length > 0) {
@@ -3666,18 +3666,18 @@ var $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
       }
     } else {
       payload.value = {};
-      for (const key of Reflect.ownKeys(input)) {
-        if (key === "__proto__")
+      for (const key2 of Reflect.ownKeys(input)) {
+        if (key2 === "__proto__")
           continue;
-        if (!Object.prototype.propertyIsEnumerable.call(input, key))
+        if (!Object.prototype.propertyIsEnumerable.call(input, key2))
           continue;
-        let keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx);
+        let keyResult = def.keyType._zod.run({ value: key2, issues: [] }, ctx);
         if (keyResult instanceof Promise) {
           throw new Error("Async schemas not supported in object keys currently");
         }
-        const checkNumericKey = typeof key === "string" && number.test(key) && keyResult.issues.length;
+        const checkNumericKey = typeof key2 === "string" && number.test(key2) && keyResult.issues.length;
         if (checkNumericKey) {
-          const retryResult = def.keyType._zod.run({ value: Number(key), issues: [] }, ctx);
+          const retryResult = def.keyType._zod.run({ value: Number(key2), issues: [] }, ctx);
           if (retryResult instanceof Promise) {
             throw new Error("Async schemas not supported in object keys currently");
           }
@@ -3687,30 +3687,30 @@ var $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
         }
         if (keyResult.issues.length) {
           if (def.mode === "loose") {
-            payload.value[key] = input[key];
+            payload.value[key2] = input[key2];
           } else {
             payload.issues.push({
               code: "invalid_key",
               origin: "record",
               issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config())),
-              input: key,
-              path: [key],
+              input: key2,
+              path: [key2],
               inst
             });
           }
           continue;
         }
-        const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);
+        const result = def.valueType._zod.run({ value: input[key2], issues: [] }, ctx);
         if (result instanceof Promise) {
           proms.push(result.then((result2) => {
             if (result2.issues.length) {
-              payload.issues.push(...prefixIssues(key, result2.issues));
+              payload.issues.push(...prefixIssues(key2, result2.issues));
             }
             payload.value[keyResult.value] = result2.value;
           }));
         } else {
           if (result.issues.length) {
-            payload.issues.push(...prefixIssues(key, result.issues));
+            payload.issues.push(...prefixIssues(key2, result.issues));
           }
           payload.value[keyResult.value] = result.value;
         }
@@ -3737,15 +3737,15 @@ var $ZodMap = /* @__PURE__ */ $constructor("$ZodMap", (inst, def) => {
     }
     const proms = [];
     payload.value = /* @__PURE__ */ new Map();
-    for (const [key, value] of input) {
-      const keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx);
+    for (const [key2, value] of input) {
+      const keyResult = def.keyType._zod.run({ value: key2, issues: [] }, ctx);
       const valueResult = def.valueType._zod.run({ value, issues: [] }, ctx);
       if (keyResult instanceof Promise || valueResult instanceof Promise) {
         proms.push(Promise.all([keyResult, valueResult]).then(([keyResult2, valueResult2]) => {
-          handleMapResult(keyResult2, valueResult2, payload, key, input, inst, ctx);
+          handleMapResult(keyResult2, valueResult2, payload, key2, input, inst, ctx);
         }));
       } else {
-        handleMapResult(keyResult, valueResult, payload, key, input, inst, ctx);
+        handleMapResult(keyResult, valueResult, payload, key2, input, inst, ctx);
       }
     }
     if (proms.length)
@@ -3753,10 +3753,10 @@ var $ZodMap = /* @__PURE__ */ $constructor("$ZodMap", (inst, def) => {
     return payload;
   };
 });
-function handleMapResult(keyResult, valueResult, final, key, input, inst, ctx) {
+function handleMapResult(keyResult, valueResult, final, key2, input, inst, ctx) {
   if (keyResult.issues.length) {
-    if (propertyKeyTypes.has(typeof key)) {
-      final.issues.push(...prefixIssues(key, keyResult.issues));
+    if (propertyKeyTypes.has(typeof key2)) {
+      final.issues.push(...prefixIssues(key2, keyResult.issues));
     } else {
       final.issues.push({
         code: "invalid_key",
@@ -3768,15 +3768,15 @@ function handleMapResult(keyResult, valueResult, final, key, input, inst, ctx) {
     }
   }
   if (valueResult.issues.length) {
-    if (propertyKeyTypes.has(typeof key)) {
-      final.issues.push(...prefixIssues(key, valueResult.issues));
+    if (propertyKeyTypes.has(typeof key2)) {
+      final.issues.push(...prefixIssues(key2, valueResult.issues));
     } else {
       final.issues.push({
         origin: "map",
         code: "invalid_element",
         input,
         inst,
-        key,
+        key: key2,
         issues: valueResult.issues.map((iss) => finalizeIssue(iss, ctx, config()))
       });
     }
@@ -11537,8 +11537,8 @@ function extractDefs(ctx, schema) {
     if (defId)
       seen.defId = defId;
     const schema2 = seen.schema;
-    for (const key in schema2) {
-      delete schema2[key];
+    for (const key2 in schema2) {
+      delete schema2[key2];
     }
     schema2.$ref = ref;
   };
@@ -11607,20 +11607,20 @@ function finalize(ctx, schema) {
       Object.assign(schema2, _cached);
       const isParentRef = zodSchema._zod.parent === ref;
       if (isParentRef) {
-        for (const key in schema2) {
-          if (key === "$ref" || key === "allOf")
+        for (const key2 in schema2) {
+          if (key2 === "$ref" || key2 === "allOf")
             continue;
-          if (!(key in _cached)) {
-            delete schema2[key];
+          if (!(key2 in _cached)) {
+            delete schema2[key2];
           }
         }
       }
       if (refSchema.$ref && refSeen.def) {
-        for (const key in schema2) {
-          if (key === "$ref" || key === "allOf")
+        for (const key2 in schema2) {
+          if (key2 === "$ref" || key2 === "allOf")
             continue;
-          if (key in refSeen.def && JSON.stringify(schema2[key]) === JSON.stringify(refSeen.def[key])) {
-            delete schema2[key];
+          if (key2 in refSeen.def && JSON.stringify(schema2[key2]) === JSON.stringify(refSeen.def[key2])) {
+            delete schema2[key2];
           }
         }
       }
@@ -11632,11 +11632,11 @@ function finalize(ctx, schema) {
       if (parentSeen?.schema.$ref) {
         schema2.$ref = parentSeen.schema.$ref;
         if (parentSeen.def) {
-          for (const key in schema2) {
-            if (key === "$ref" || key === "allOf")
+          for (const key2 in schema2) {
+            if (key2 === "$ref" || key2 === "allOf")
               continue;
-            if (key in parentSeen.def && JSON.stringify(schema2[key]) === JSON.stringify(parentSeen.def[key])) {
-              delete schema2[key];
+            if (key2 in parentSeen.def && JSON.stringify(schema2[key2]) === JSON.stringify(parentSeen.def[key2])) {
+              delete schema2[key2];
             }
           }
         }
@@ -11737,8 +11737,8 @@ function isTransforming(_schema, _ctx) {
     return isTransforming(def.in, ctx) || isTransforming(def.out, ctx);
   }
   if (def.type === "object") {
-    for (const key in def.shape) {
-      if (isTransforming(def.shape[key], ctx))
+    for (const key2 in def.shape) {
+      if (isTransforming(def.shape[key2], ctx))
         return true;
     }
     return false;
@@ -12027,15 +12027,15 @@ var objectProcessor = (schema, ctx, _json, params) => {
   json2.type = "object";
   json2.properties = {};
   const shape = def.shape;
-  for (const key in shape) {
-    json2.properties[key] = process2(shape[key], ctx, {
+  for (const key2 in shape) {
+    json2.properties[key2] = process2(shape[key2], ctx, {
       ...params,
-      path: [...params.path, "properties", key]
+      path: [...params.path, "properties", key2]
     });
   }
   const allKeys = new Set(Object.keys(shape));
-  const requiredKeys = new Set([...allKeys].filter((key) => {
-    const v = def.shape[key]._zod;
+  const requiredKeys = new Set([...allKeys].filter((key2) => {
+    const v = def.shape[key2]._zod;
     if (ctx.io === "input") {
       return v.optin === void 0;
     } else {
@@ -12301,9 +12301,9 @@ function toJSONSchema(input, params) {
     };
     ctx2.external = external;
     for (const entry of registry2._idmap.entries()) {
-      const [key, schema] = entry;
+      const [key2, schema] = entry;
       extractDefs(ctx2, schema);
-      schemas[key] = finalize(ctx2, schema);
+      schemas[key2] = finalize(ctx2, schema);
     }
     if (Object.keys(defs).length > 0) {
       const defsSegment = ctx2.target === "draft-2020-12" ? "$defs" : "definitions";
@@ -12709,14 +12709,14 @@ function _installLazyMethods(inst, group, methods) {
   if (installed.has(group))
     return;
   installed.add(group);
-  for (const key in methods) {
-    const fn = methods[key];
-    Object.defineProperty(proto, key, {
+  for (const key2 in methods) {
+    const fn = methods[key2];
+    Object.defineProperty(proto, key2, {
       configurable: true,
       enumerable: false,
       get() {
         const bound = fn.bind(this);
-        Object.defineProperty(this, key, {
+        Object.defineProperty(this, key2, {
           configurable: true,
           writable: true,
           enumerable: true,
@@ -12725,7 +12725,7 @@ function _installLazyMethods(inst, group, methods) {
         return bound;
       },
       set(v) {
-        Object.defineProperty(this, key, {
+        Object.defineProperty(this, key2, {
           configurable: true,
           writable: true,
           enumerable: true,
@@ -14113,11 +14113,11 @@ function resolveRef(ref, ctx) {
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
   if (path8[0] === defsKey) {
-    const key = path8[1];
-    if (!key || !ctx.defs[key]) {
+    const key2 = path8[1];
+    if (!key2 || !ctx.defs[key2]) {
       throw new Error(`Reference not found: ${ref}`);
     }
-    return ctx.defs[key];
+    return ctx.defs[key2];
   }
   throw new Error(`Reference not found: ${ref}`);
 }
@@ -14303,9 +14303,9 @@ function convertBaseSchema(schema, ctx) {
       const shape = {};
       const properties = schema.properties || {};
       const requiredSet = new Set(schema.required || []);
-      for (const [key, propSchema] of Object.entries(properties)) {
+      for (const [key2, propSchema] of Object.entries(properties)) {
         const propZodSchema = convertSchema(propSchema, ctx);
-        shape[key] = requiredSet.has(key) ? propZodSchema : propZodSchema.optional();
+        shape[key2] = requiredSet.has(key2) ? propZodSchema : propZodSchema.optional();
       }
       if (schema.propertyNames) {
         const keySchema = convertSchema(schema.propertyNames, ctx);
@@ -14446,20 +14446,20 @@ function convertSchema(schema, ctx) {
   }
   const extraMeta = {};
   const coreMetadataKeys = ["$id", "id", "$comment", "$anchor", "$vocabulary", "$dynamicRef", "$dynamicAnchor"];
-  for (const key of coreMetadataKeys) {
-    if (key in schema) {
-      extraMeta[key] = schema[key];
+  for (const key2 of coreMetadataKeys) {
+    if (key2 in schema) {
+      extraMeta[key2] = schema[key2];
     }
   }
   const contentMetadataKeys = ["contentEncoding", "contentMediaType", "contentSchema"];
-  for (const key of contentMetadataKeys) {
-    if (key in schema) {
-      extraMeta[key] = schema[key];
+  for (const key2 of contentMetadataKeys) {
+    if (key2 in schema) {
+      extraMeta[key2] = schema[key2];
     }
   }
-  for (const key of Object.keys(schema)) {
-    if (!RECOGNIZED_KEYS.has(key)) {
-      extraMeta[key] = schema[key];
+  for (const key2 of Object.keys(schema)) {
+    if (!RECOGNIZED_KEYS.has(key2)) {
+      extraMeta[key2] = schema[key2];
     }
   }
   if (Object.keys(extraMeta).length > 0) {
@@ -14776,10 +14776,32 @@ function createFailover(routes, notice) {
   const notify = (message) => notice(`agent-router: ${message}`).catch(() => {
   });
   return {
+    pending(sessionID) {
+      const state = sessions.get(sessionID);
+      return enabled && !state?.disabled && state?.pending ? { ...state.pending } : void 0;
+    },
     active(sessionID) {
       const state = sessions.get(sessionID);
       return enabled && Boolean(state?.turn) && !state?.disabled;
     },
+    /** Register an admission already selected by a separate policy; no retry occurs. */
+    admit(sessionID, message) {
+      if (!enabled) return;
+      const chain = chains.get(message.agent);
+      const index = chain?.findIndex((candidate) => same(candidate, message.model)) ?? -1;
+      if (index < 0 || !sessions.has(sessionID) && sessions.size >= 1024) return;
+      const state = sessions.get(sessionID) ?? { disabled: false, indices: /* @__PURE__ */ new Map() };
+      state.disabled = false;
+      state.indices.set(message.agent, index);
+      state.pending = void 0;
+      state.turn = {
+        agent: message.agent,
+        parent: message.id,
+        model: { ...message.model },
+        handled: false
+      };
+      sessions.set(sessionID, state);
+    },
     disable() {
       enabled = false;
       sessions.clear();
@@ -15142,29 +15164,29 @@ function parseMapping(lines, startIdx, indent) {
       i++;
       continue;
     }
-    const key = stripKeyQuotes(line.text.slice(0, colon).trim());
-    if (key === "") {
+    const key2 = stripKeyQuotes(line.text.slice(0, colon).trim());
+    if (key2 === "") {
       i++;
       continue;
     }
     const rest = line.text.slice(colon + 1).trim();
     if (rest !== "") {
-      out[key] = parseFlowValue(rest);
+      out[key2] = parseFlowValue(rest);
       i++;
     } else {
       const childIndent = lines[i + 1]?.indent ?? line.indent + 1;
       let j = i + 1;
       while (j < lines.length && (lines[j]?.indent ?? -1) >= childIndent) j++;
       if (j === i + 1) {
-        out[key] = null;
+        out[key2] = null;
         i++;
       } else {
         const childBlock = lines.slice(i + 1, j);
         const firstChild = childBlock[0];
         if (firstChild?.text.trimStart().startsWith("- ")) {
-          out[key] = parseSequence(childBlock, childIndent);
+          out[key2] = parseSequence(childBlock, childIndent);
         } else {
-          out[key] = parseMapping(childBlock, 0, childIndent).value;
+          out[key2] = parseMapping(childBlock, 0, childIndent).value;
         }
         i = j;
       }
@@ -15276,24 +15298,24 @@ function setFrontmatterOptions(content, options) {
   for (let i = 0; i < lines.length; i++) {
     const m = /^([A-Za-z0-9_-]+):[ \t]*(.*)$/.exec(lines[i] ?? "");
     if (!m) continue;
-    const key = m[1] ?? "";
-    if (!(key in options)) continue;
-    handled.add(key);
+    const key2 = m[1] ?? "";
+    if (!(key2 in options)) continue;
+    handled.add(key2);
     let end = i + 1;
     while (end < lines.length && /^[ \t]+/.test(lines[end] ?? "")) end++;
-    const value = options[key];
+    const value = options[key2];
     if (value === null || value === void 0) {
       lines.splice(i, end - i);
       i--;
     } else {
-      lines.splice(i, end - i, `${key}: ${serializeOptionValue(value)}`);
+      lines.splice(i, end - i, `${key2}: ${serializeOptionValue(value)}`);
     }
   }
   const appended = [];
-  for (const [key, value] of Object.entries(options)) {
-    if (handled.has(key)) continue;
+  for (const [key2, value] of Object.entries(options)) {
+    if (handled.has(key2)) continue;
     if (value === null || value === void 0) continue;
-    appended.push(`${key}: ${serializeOptionValue(value)}`);
+    appended.push(`${key2}: ${serializeOptionValue(value)}`);
   }
   const nextBlock = appended.length > 0 ? lines.join(eol) + eol + appended.join(eol) : lines.join(eol);
   if (nextBlock === block) return content;
@@ -15731,6 +15753,364 @@ async function captureStack(paths, name, options = {}) {
   return { name, path: dest, agents: Object.keys(agents).length };
 }
 
+// src/core/pin-store.ts
+var Pins = external_exports.object({ version: external_exports.literal(1), sessionIDs: external_exports.array(external_exports.string().min(1)).max(1024) }).strict();
+var PIN_STORE_KEY = "quota-pins-v1";
+function createPinStore(storage) {
+  let lane = Promise.resolve();
+  let pending = 0;
+  const read = async () => {
+    const value = await storage.get(PIN_STORE_KEY);
+    return new Set(value === void 0 ? [] : Pins.parse(value).sessionIDs);
+  };
+  const mutate = (sessionID, add, valid) => {
+    if (pending >= 65) return Promise.reject(new Error("Session pin storage is busy; try again."));
+    pending++;
+    const operation = lane.then(async () => {
+      const pins = await read();
+      if (!valid()) throw new Error("Session pin operation was cancelled.");
+      if (add) {
+        if (!pins.has(sessionID) && pins.size >= 1024)
+          throw new Error("Session pin capacity reached.");
+        pins.add(sessionID);
+      } else if (!pins.delete(sessionID)) return;
+      await storage.set(PIN_STORE_KEY, { version: 1, sessionIDs: [...pins] });
+    });
+    lane = operation.then(
+      () => {
+        pending--;
+      },
+      () => {
+        pending--;
+      }
+    );
+    return operation;
+  };
+  return {
+    async has(sessionID) {
+      await lane;
+      return (await read()).has(sessionID);
+    },
+    add: (sessionID, valid) => mutate(sessionID, true, valid),
+    remove: (sessionID, valid = () => true) => mutate(sessionID, false, valid),
+    drain: () => lane
+  };
+}
+
+// src/core/quota-preflight.ts
+import { Rpc } from "@opencode/plugin/rpc";
+var ID = external_exports.string().max(200).regex(/^[a-zA-Z0-9][a-zA-Z0-9._:/+-]*$/);
+var Candidate = external_exports.object({ providerID: ID, id: ID }).strict();
+var Result = Candidate.extend({
+  status: external_exports.enum(["available", "exhausted", "unknown"]),
+  checkedAt: external_exports.number().finite().nullable(),
+  validUntil: external_exports.number().finite().nullable(),
+  resetAt: external_exports.number().finite().nullable(),
+  reason: external_exports.string(),
+  accountRef: external_exports.string().nullable(),
+  scopeRef: external_exports.string().nullable()
+}).strict();
+var QuotaOutput = external_exports.object({ candidates: external_exports.array(Result).max(64) }).strict();
+var UsageQuota = Rpc.define({
+  id: "direct-api-usage",
+  methods: {
+    query: {
+      input: external_exports.object({ candidates: external_exports.array(Candidate).max(64) }).strict(),
+      output: QuotaOutput
+    }
+  },
+  events: {}
+});
+var QuotaOptions = external_exports.object({ enabled: external_exports.boolean().default(false), allowPaidFallbacks: external_exports.boolean().default(false) }).strict();
+function quotaCandidate(entry) {
+  const slash = entry.model.indexOf("/");
+  return { providerID: entry.model.slice(0, slash), id: entry.model.slice(slash + 1) };
+}
+function effectiveQuotaStatus(candidate, results, now = Date.now()) {
+  const matches = results.filter(
+    (r) => r.providerID === candidate.providerID && r.id === candidate.id
+  );
+  const result = matches.length === 1 ? matches[0] : void 0;
+  const bound = Boolean(result?.accountRef && result.scopeRef);
+  const fresh = bound && result?.checkedAt !== null && result?.checkedAt !== void 0 && result.checkedAt > 0 && result.checkedAt <= now && result.validUntil !== null && result.validUntil > now && (result.resetAt === null || result.resetAt > now);
+  return { status: fresh ? result?.status ?? "unknown" : "unknown", bound };
+}
+function chooseQuotaRoute(route, results, allowPaidFallbacks, now = Date.now(), startIndex = 0) {
+  for (const [index, entry] of [route, ...route.fallbacks ?? []].entries()) {
+    if (index < startIndex) continue;
+    const candidate = quotaCandidate(entry);
+    const { status, bound } = effectiveQuotaStatus(candidate, results, now);
+    if (status === "exhausted") continue;
+    if (index === 0 || bound || allowPaidFallbacks) return entry;
+  }
+  return void 0;
+}
+function createQuotaQuery(query, deadlineMs = 3e3, capacity = 16) {
+  const pending = /* @__PURE__ */ new Set();
+  let disposed = false;
+  return {
+    async read(candidates) {
+      if (disposed || pending.size >= capacity) return [];
+      const controller = new AbortController();
+      pending.add(controller);
+      let timer;
+      const request = Promise.resolve().then(() => query({ candidates }, { signal: controller.signal })).then((value) => {
+        const parsed = QuotaOutput.safeParse(value);
+        return parsed.success ? parsed.data.candidates : [];
+      }).catch(() => []).finally(() => pending.delete(controller));
+      const timeout = new Promise((resolve) => {
+        const stop = () => resolve([]);
+        controller.signal.addEventListener("abort", stop, { once: true });
+        timer = setTimeout(() => controller.abort(), deadlineMs);
+      });
+      try {
+        return await Promise.race([request, timeout]);
+      } finally {
+        clearTimeout(timer);
+      }
+    },
+    dispose() {
+      disposed = true;
+      for (const controller of pending) controller.abort();
+    }
+  };
+}
+
+// src/quota-v2.ts
+var key = (model) => model ? `${model.providerID}/${model.id}#${model.variant === "default" ? "" : model.variant ?? ""}` : "";
+function createQuotaAdmission(ctx, routes, current) {
+  const parsed = QuotaOptions.safeParse(ctx.options?.quotaPreflight ?? {});
+  if (!parsed.success || !parsed.data.enabled) return void 0;
+  const options = parsed.data;
+  const query = createQuotaQuery((input, request) => ctx.rpc(UsageQuota).query(input, request));
+  const owned = /* @__PURE__ */ new Map();
+  const expected = /* @__PURE__ */ new Map();
+  const busy = /* @__PURE__ */ new Set();
+  const versions = /* @__PURE__ */ new Map();
+  const controls = /* @__PURE__ */ new Set();
+  const pinned = /* @__PURE__ */ new Set();
+  const deletedControls = /* @__PURE__ */ new Set();
+  const pinStore = createPinStore(ctx.storage);
+  const reasons = /* @__PURE__ */ new Map();
+  let disposed = false;
+  const invalidate = (sessionID) => {
+    if (busy.has(sessionID)) versions.set(sessionID, (versions.get(sessionID) ?? 0) + 1);
+  };
+  const reason = (sessionID, value, model) => {
+    if (disposed) return;
+    if (reasons.has(sessionID) || reasons.size < 1024) reasons.set(sessionID, value);
+    console.info(`agent-router: [${sessionID}] ${value}${model ? ` ${key(model)}` : ""}`);
+  };
+  const isPinned = async (sessionID) => {
+    if (pinned.has(sessionID)) return true;
+    try {
+      return await pinStore.has(sessionID);
+    } catch {
+      return true;
+    }
+  };
+  const evaluate = async (route, pending) => {
+    const candidates = [route, ...route.fallbacks ?? []].map(quotaCandidate).filter(
+      (entry, index, all) => all.findIndex(
+        (other) => other.providerID === entry.providerID && other.id === entry.id
+      ) === index
+    );
+    const results = await query.read(candidates);
+    return () => {
+      const now = Date.now();
+      const startIndex = pending ? Math.max(
+        0,
+        [route, ...route.fallbacks ?? []].findIndex(
+          (entry) => key({
+            ...quotaCandidate(entry),
+            ...entry.variant ? { variant: entry.variant } : {}
+          }) === key(pending)
+        )
+      ) : 0;
+      const choice = chooseQuotaRoute(route, results, options.allowPaidFallbacks, now, startIndex);
+      return {
+        choice,
+        reason: !choice ? "no_eligible_fallback" : pending ? "staged_reactive_fallback" : choice.model !== route.model ? "known_exhaustion_fallback" : effectiveQuotaStatus(quotaCandidate(route), results, now).status === "available" ? "primary_available" : "primary_unknown"
+      };
+    };
+  };
+  return {
+    isPinned,
+    async status(sessionID) {
+      const session = await ctx.session.get({ sessionID });
+      const explicit = await isPinned(sessionID);
+      const automatic = !explicit && (!session.model || owned.get(sessionID)?.model === key(session.model));
+      const resolved = session.model ?? (session.agent ? (await ctx.agent.get({ agentID: session.agent })).data.model : void 0) ?? (await ctx.model.default()).data;
+      return {
+        sessionID,
+        mode: automatic ? "automatic" : "pinned",
+        model: resolved ? {
+          providerID: resolved.providerID,
+          id: resolved.id,
+          ..."variant" in resolved && typeof resolved.variant === "string" ? { variant: resolved.variant } : {}
+        } : null,
+        reason: explicit ? "explicit_pin" : automatic ? reasons.get(sessionID) ?? "awaiting_next_turn" : "manual_or_preexisting_selection"
+      };
+    },
+    async control(sessionID, action, pause) {
+      if (disposed || !current())
+        throw new Error("Router configuration changed; reload before changing session routing.");
+      if (controls.has(sessionID) || controls.size >= 64)
+        throw new Error("Session routing control is busy; try again.");
+      if (action === "pin" && !pinned.has(sessionID) && pinned.size >= 1024)
+        throw new Error("Session pin capacity reached.");
+      controls.add(sessionID);
+      invalidate(sessionID);
+      const live = () => !disposed && current() && !deletedControls.has(sessionID);
+      try {
+        await pause();
+        const session = await ctx.session.get({ sessionID });
+        if (!live())
+          throw new Error("Router stopped or session deleted before the control completed.");
+        if (!session.agent || !routes[session.agent])
+          throw new Error("No configured route for this session agent.");
+        if (action === "pin") {
+          owned.delete(sessionID);
+          expected.delete(sessionID);
+          await pinStore.add(sessionID, live);
+          if (!live()) throw new Error("Router stopped or session deleted during pinning.");
+          pinned.add(sessionID);
+          if (!session.model) {
+            const agent = await ctx.agent.get({ agentID: session.agent });
+            const resolved = agent.data.model ?? (await ctx.model.default()).data;
+            if (!resolved) throw new Error("No native model is resolved; routing remains pinned.");
+            const latest = await ctx.session.get({ sessionID });
+            if (!live()) throw new Error("Router stopped or session deleted during pinning.");
+            if (latest.agent !== session.agent || key(latest.model) !== key(session.model))
+              throw new Error(
+                "Session selection changed while pinning; current selection remains pinned."
+              );
+            const model = {
+              providerID: resolved.providerID,
+              id: resolved.id,
+              ..."variant" in resolved && typeof resolved.variant === "string" ? { variant: resolved.variant } : {}
+            };
+            await ctx.session.switchModel({ sessionID, model });
+          }
+          if (!live()) throw new Error("Router stopped or session deleted during pinning.");
+          reason(sessionID, "explicit_pin", (await ctx.session.get({ sessionID })).model);
+        } else {
+          if (!owned.has(sessionID) && owned.size >= 1024)
+            throw new Error("Automatic session capacity reached.");
+          await pinStore.remove(sessionID, live);
+          if (!live()) throw new Error("Router stopped; automatic routing was not resumed.");
+          pinned.delete(sessionID);
+          owned.set(sessionID, { agent: session.agent, model: key(session.model) });
+          reason(sessionID, "automatic_next_explicit_turn", session.model);
+        }
+      } finally {
+        controls.delete(sessionID);
+        deletedControls.delete(sessionID);
+      }
+    },
+    /** Called for every selection event, including before the first prompt. */
+    event(sessionID, type, model) {
+      if (type === "session.model.selected" && expected.get(sessionID) === key(model)) {
+        expected.delete(sessionID);
+        return true;
+      }
+      if ([
+        "session.model.selected",
+        "session.agent.selected",
+        "session.execution.interrupted",
+        "session.deleted"
+      ].includes(type)) {
+        owned.delete(sessionID);
+        expected.delete(sessionID);
+        invalidate(sessionID);
+        if (type === "session.deleted") {
+          if (controls.has(sessionID)) deletedControls.add(sessionID);
+          pinned.delete(sessionID);
+          reasons.delete(sessionID);
+          return pinStore.remove(sessionID).then(() => false);
+        }
+      }
+      return false;
+    },
+    async main(sessionID, session, pending) {
+      if (disposed || !current() || session.parentID || !session.agent || busy.has(sessionID))
+        return;
+      if (busy.size >= 64) return;
+      busy.add(sessionID);
+      const generation = versions.get(sessionID) ?? 0;
+      try {
+        if (controls.has(sessionID) || await isPinned(sessionID)) return;
+        if (disposed || controls.has(sessionID) || pinned.has(sessionID) || (versions.get(sessionID) ?? 0) !== generation)
+          return;
+        const route = routes[session.agent];
+        if (!route) return;
+        const previous = owned.get(sessionID);
+        if (session.model && (!previous || previous.agent !== session.agent || previous.model !== key(session.model)))
+          return;
+        if (!owned.has(sessionID) && owned.size >= 1024) return;
+        const choose = await evaluate(route, pending);
+        if (disposed || !current() || (versions.get(sessionID) ?? 0) !== generation) return;
+        const latest = await ctx.session.get({ sessionID });
+        if (disposed || controls.has(sessionID) || pinned.has(sessionID) || latest.agent !== session.agent || key(latest.model) !== key(session.model) || (versions.get(sessionID) ?? 0) !== generation || !current())
+          return;
+        const decision = choose();
+        const { choice } = decision;
+        if (!choice) {
+          reason(sessionID, decision.reason, session.model);
+          return;
+        }
+        const model = {
+          ...quotaCandidate(choice),
+          ...choice.variant && choice.variant !== "default" ? { variant: choice.variant } : {}
+        };
+        if (key(model) !== key(session.model) && (session.model || choice.model !== route.model || choice.variant !== route.variant)) {
+          expected.set(sessionID, key(model));
+          try {
+            await ctx.session.switchModel({ sessionID, model });
+          } catch {
+            expected.delete(sessionID);
+            return;
+          }
+        }
+        if (disposed || controls.has(sessionID) || pinned.has(sessionID) || (versions.get(sessionID) ?? 0) !== generation)
+          return;
+        owned.set(sessionID, { agent: session.agent, model: key(model) });
+        reason(sessionID, decision.reason, model);
+        return model;
+      } finally {
+        busy.delete(sessionID);
+        versions.delete(sessionID);
+      }
+    },
+    async child(event) {
+      if (disposed || !current() || event.tool !== "subagent" || !event.input || typeof event.input !== "object")
+        return;
+      const input = event.input;
+      if ("model" in input || "sessionID" in input || "session_id" in input || "task_id" in input || typeof input.agent !== "string")
+        return;
+      const route = routes[input.agent];
+      if (!route) return;
+      const originalAgent = input.agent;
+      const choose = await evaluate(route);
+      const { choice } = choose();
+      if (!choice || disposed || !current() || input.agent !== originalAgent || "model" in input)
+        return;
+      input.model = choice.model + (choice.variant && choice.variant !== "default" ? `#${choice.variant}` : "");
+    },
+    async dispose() {
+      disposed = true;
+      query.dispose();
+      owned.clear();
+      expected.clear();
+      versions.clear();
+      controls.clear();
+      pinned.clear();
+      reasons.clear();
+      await pinStore.drain();
+    }
+  };
+}
+
 // src/v2.ts
 var variant = (value) => value === "default" ? void 0 : value ?? void 0;
 async function setupV2(ctx) {
@@ -15793,11 +16173,50 @@ async function setupV2(ctx) {
   const turns = /* @__PURE__ */ new Map();
   const kinds = /* @__PURE__ */ new Map();
   const ownSelections = /* @__PURE__ */ new Map();
+  const quota = createQuotaAdmission(ctx, routes, () => state() === initial);
+  if (quota) {
+    await ctx.tool.transform((editor) => {
+      const input = { type: "object", properties: {}, additionalProperties: false };
+      for (const action of ["pin", "auto"])
+        editor.add({
+          name: `router_${action}`,
+          description: action === "pin" ? "Only on an explicit user request: pin this session's current model and disable automatic quota/reactive routing. Takes no model or session arguments." : "Only on an explicit user request: resume quota-aware routing for this session on its NEXT explicit user turn. Does not send a prompt or switch immediately.",
+          input,
+          async execute(_input, context) {
+            await quota.control(context.sessionID, action, async () => {
+              turns.delete(context.sessionID);
+              kinds.delete(context.sessionID);
+              await failover.event({
+                event: {
+                  type: "session.next.model.switched",
+                  properties: { sessionID: context.sessionID }
+                }
+              });
+            });
+            return { content: JSON.stringify(await quota.status(context.sessionID)) };
+          }
+        });
+      editor.add({
+        name: "router_routing_status",
+        description: "Show this session's automatic/pinned routing mode, current model, and routing reason.",
+        input,
+        async execute(_input, context) {
+          return { content: JSON.stringify(await quota.status(context.sessionID)) };
+        }
+      });
+    });
+  }
   const controller = new AbortController();
   const events = (async () => {
     for await (const event of ctx.event.subscribe({ signal: controller.signal })) {
       if (!("sessionID" in event.data)) continue;
       const sessionID = String(event.data.sessionID);
+      if (await quota?.event(
+        sessionID,
+        event.type,
+        event.type === "session.model.selected" ? event.data.model : void 0
+      ))
+        continue;
       if (!turns.has(sessionID)) continue;
       if (event.type === "session.model.selected") {
         const model = event.data.model;
@@ -15825,6 +16244,7 @@ async function setupV2(ctx) {
   await ctx.session.hook("model.request", (event) => {
     if (turns.has(event.sessionID)) kinds.set(event.sessionID, event.kind);
   });
+  if (quota) await ctx.tool.hook("execute.before", (event) => quota.child(event));
   await ctx.session.hook("prompt", async (event) => {
     if (turns.get(event.sessionID)?.id === event.messageID) return;
     if (state() !== initial) {
@@ -15833,6 +16253,40 @@ async function setupV2(ctx) {
       return;
     }
     const session = await ctx.session.get({ sessionID: event.sessionID });
+    if (turns.get(event.sessionID)?.id === event.messageID) return;
+    if (quota) {
+      if (session.parentID && await quota.isPinned(event.sessionID)) {
+        turns.delete(event.sessionID);
+        return;
+      }
+      const pending = failover.pending(event.sessionID);
+      const selected = session.parentID ? session.model : await quota.main(
+        event.sessionID,
+        session,
+        pending ? {
+          providerID: pending.providerID,
+          id: pending.modelID,
+          variant: pending.variant
+        } : void 0
+      );
+      if (!selected || !session.agent || !routes[session.agent]) {
+        turns.delete(event.sessionID);
+        return;
+      }
+      const message2 = {
+        id: event.messageID,
+        agent: session.agent,
+        model: {
+          providerID: selected.providerID,
+          modelID: selected.id,
+          variant: variant(selected.variant)
+        }
+      };
+      failover.admit(event.sessionID, message2);
+      if (!failover.active(event.sessionID)) return;
+      turns.set(event.sessionID, message2);
+      return;
+    }
     if (!session.agent || !session.model || !routes[session.agent]) return;
     const message = {
       id: event.messageID,
@@ -15909,6 +16363,7 @@ async function setupV2(ctx) {
   });
   return async () => {
     controller.abort();
+    await quota?.dispose();
     failover.disable();
     turns.clear();
     kinds.clear();
@@ -15918,7 +16373,7 @@ async function setupV2(ctx) {
 }
 
 // src/version.ts
-var VERSION = "2.0.1";
+var VERSION = "2.1.0";
 
 // src/plugin.ts
 var tool = Object.assign(