@dylanrussell/agent-router 2.1.1 → 2.2.0

package/dist/plugin.js

@@ -729,9 +729,9 @@ function floatSafeRemainder(val, step) {
   return ratio - roundedRatio;
 }
 var EVALUATING = /* @__PURE__ */ Symbol("evaluating");
-function defineLazy(object2, key2, getter) {
+function defineLazy(object2, key3, getter) {
   let value = void 0;
-  Object.defineProperty(object2, key2, {
+  Object.defineProperty(object2, key3, {
     get() {
       if (value === EVALUATING) {
         return void 0;
@@ -743,7 +743,7 @@ function defineLazy(object2, key2, getter) {
       return value;
     },
     set(v) {
-      Object.defineProperty(object2, key2, {
+      Object.defineProperty(object2, key3, {
         value: v
         // configurable: true,
       });
@@ -776,11 +776,11 @@ function cloneDef(schema) {
 function getElementAtPath(obj, path8) {
   if (!path8)
     return obj;
-  return path8.reduce((acc, key2) => acc?.[key2], obj);
+  return path8.reduce((acc, key3) => acc?.[key3], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
-  const promises = keys.map((key2) => promisesObj[key2]);
+  const promises = keys.map((key3) => promisesObj[key3]);
   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 key2 in data) {
-    if (Object.prototype.hasOwnProperty.call(data, key2)) {
+  for (const key3 in data) {
+    if (Object.prototype.hasOwnProperty.call(data, key3)) {
       keyCount++;
     }
   }
@@ -1003,13 +1003,13 @@ function pick(schema, mask) {
   const def = mergeDefs(schema._zod.def, {
     get shape() {
       const newShape = {};
-      for (const key2 in mask) {
-        if (!(key2 in currDef.shape)) {
-          throw new Error(`Unrecognized key: "${key2}"`);
+      for (const key3 in mask) {
+        if (!(key3 in currDef.shape)) {
+          throw new Error(`Unrecognized key: "${key3}"`);
         }
-        if (!mask[key2])
+        if (!mask[key3])
           continue;
-        newShape[key2] = currDef.shape[key2];
+        newShape[key3] = currDef.shape[key3];
       }
       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 key2 in mask) {
-        if (!(key2 in currDef.shape)) {
-          throw new Error(`Unrecognized key: "${key2}"`);
+      for (const key3 in mask) {
+        if (!(key3 in currDef.shape)) {
+          throw new Error(`Unrecognized key: "${key3}"`);
         }
-        if (!mask[key2])
+        if (!mask[key3])
           continue;
-        delete newShape[key2];
+        delete newShape[key3];
       }
       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 key2 in shape) {
-      if (Object.getOwnPropertyDescriptor(existingShape, key2) !== void 0) {
+    for (const key3 in shape) {
+      if (Object.getOwnPropertyDescriptor(existingShape, key3) !== 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 key2 in mask) {
-          if (!(key2 in oldShape)) {
-            throw new Error(`Unrecognized key: "${key2}"`);
+        for (const key3 in mask) {
+          if (!(key3 in oldShape)) {
+            throw new Error(`Unrecognized key: "${key3}"`);
           }
-          if (!mask[key2])
+          if (!mask[key3])
             continue;
-          shape[key2] = Class2 ? new Class2({
+          shape[key3] = Class2 ? new Class2({
             type: "optional",
-            innerType: oldShape[key2]
-          }) : oldShape[key2];
+            innerType: oldShape[key3]
+          }) : oldShape[key3];
         }
       } else {
-        for (const key2 in oldShape) {
-          shape[key2] = Class2 ? new Class2({
+        for (const key3 in oldShape) {
+          shape[key3] = Class2 ? new Class2({
             type: "optional",
-            innerType: oldShape[key2]
-          }) : oldShape[key2];
+            innerType: oldShape[key3]
+          }) : oldShape[key3];
         }
       }
       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 key2 in mask) {
-          if (!(key2 in shape)) {
-            throw new Error(`Unrecognized key: "${key2}"`);
+        for (const key3 in mask) {
+          if (!(key3 in shape)) {
+            throw new Error(`Unrecognized key: "${key3}"`);
           }
-          if (!mask[key2])
+          if (!mask[key3])
             continue;
-          shape[key2] = new Class2({
+          shape[key3] = new Class2({
             type: "nonoptional",
-            innerType: oldShape[key2]
+            innerType: oldShape[key3]
           });
         }
       } else {
-        for (const key2 in oldShape) {
-          shape[key2] = new Class2({
+        for (const key3 in oldShape) {
+          shape[key3] = new Class2({
             type: "nonoptional",
-            innerType: oldShape[key2]
+            innerType: oldShape[key3]
           });
         }
       }
@@ -2936,13 +2936,13 @@ var $ZodArray = /* @__PURE__ */ $constructor("$ZodArray", (inst, def) => {
     return payload;
   };
 });
-function handlePropertyResult(result, final, key2, input, isOptionalIn, isOptionalOut) {
-  const isPresent = key2 in input;
+function handlePropertyResult(result, final, key3, input, isOptionalIn, isOptionalOut) {
+  const isPresent = key3 in input;
   if (result.issues.length) {
     if (isOptionalIn && isOptionalOut && !isPresent) {
       return;
     }
-    final.issues.push(...prefixIssues(key2, result.issues));
+    final.issues.push(...prefixIssues(key3, result.issues));
   }
   if (!isPresent && !isOptionalIn) {
     if (!result.issues.length) {
@@ -2950,17 +2950,17 @@ function handlePropertyResult(result, final, key2, input, isOptionalIn, isOption
         code: "invalid_type",
         expected: "nonoptional",
         input: void 0,
-        path: [key2]
+        path: [key3]
       });
     }
     return;
   }
   if (result.value === void 0) {
     if (isPresent) {
-      final.value[key2] = void 0;
+      final.value[key3] = void 0;
     }
   } else {
-    final.value[key2] = result.value;
+    final.value[key3] = 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 key2 in input) {
-    if (key2 === "__proto__")
+  for (const key3 in input) {
+    if (key3 === "__proto__")
       continue;
-    if (keySet.has(key2))
+    if (keySet.has(key3))
       continue;
     if (t === "never") {
-      unrecognized.push(key2);
+      unrecognized.push(key3);
       continue;
     }
-    const r = _catchall.run({ value: input[key2], issues: [] }, ctx);
+    const r = _catchall.run({ value: input[key3], issues: [] }, ctx);
     if (r instanceof Promise) {
-      proms.push(r.then((r2) => handlePropertyResult(r2, payload, key2, input, isOptionalIn, isOptionalOut)));
+      proms.push(r.then((r2) => handlePropertyResult(r2, payload, key3, input, isOptionalIn, isOptionalOut)));
     } else {
-      handlePropertyResult(r, payload, key2, input, isOptionalIn, isOptionalOut);
+      handlePropertyResult(r, payload, key3, 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 key2 in shape) {
-      const field = shape[key2]._zod;
+    for (const key3 in shape) {
+      const field = shape[key3]._zod;
       if (field.values) {
-        propValues[key2] ?? (propValues[key2] = /* @__PURE__ */ new Set());
+        propValues[key3] ?? (propValues[key3] = /* @__PURE__ */ new Set());
         for (const v of field.values)
-          propValues[key2].add(v);
+          propValues[key3].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 key2 of value.keys) {
-      const el = shape[key2];
+    for (const key3 of value.keys) {
+      const el = shape[key3];
       const isOptionalIn = el._zod.optin === "optional";
       const isOptionalOut = el._zod.optout === "optional";
-      const r = el._zod.run({ value: input[key2], issues: [] }, ctx);
+      const r = el._zod.run({ value: input[key3], issues: [] }, ctx);
       if (r instanceof Promise) {
-        proms.push(r.then((r2) => handlePropertyResult(r2, payload, key2, input, isOptionalIn, isOptionalOut)));
+        proms.push(r.then((r2) => handlePropertyResult(r2, payload, key3, input, isOptionalIn, isOptionalOut)));
       } else {
-        handlePropertyResult(r, payload, key2, input, isOptionalIn, isOptionalOut);
+        handlePropertyResult(r, payload, key3, 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 = (key2) => {
-      const k = esc(key2);
+    const parseStr = (key3) => {
+      const k = esc(key3);
       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 key2 of normalized.keys) {
-      ids[key2] = `key_${counter++}`;
+    for (const key3 of normalized.keys) {
+      ids[key3] = `key_${counter++}`;
     }
     doc.write(`const newResult = {};`);
-    for (const key2 of normalized.keys) {
-      const id = ids[key2];
-      const k = esc(key2);
-      const schema = shape[key2];
+    for (const key3 of normalized.keys) {
+      const id = ids[key3];
+      const k = esc(key3);
+      const schema = shape[key3];
       const isOptionalIn = schema?._zod?.optin === "optional";
       const isOptionalOut = schema?._zod?.optout === "optional";
-      doc.write(`const ${id} = ${parseStr(key2)};`);
+      doc.write(`const ${id} = ${parseStr(key3)};`);
       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((key2) => bKeys.indexOf(key2) !== -1);
+    const sharedKeys = Object.keys(a).filter((key3) => bKeys.indexOf(key3) !== -1);
     const newObj = { ...a, ...b };
-    for (const key2 of sharedKeys) {
-      const sharedValue = mergeValues(a[key2], b[key2]);
+    for (const key3 of sharedKeys) {
+      const sharedValue = mergeValues(a[key3], b[key3]);
       if (!sharedValue.valid) {
         return {
           valid: false,
-          mergeErrorPath: [key2, ...sharedValue.mergeErrorPath]
+          mergeErrorPath: [key3, ...sharedValue.mergeErrorPath]
         };
       }
-      newObj[key2] = sharedValue.data;
+      newObj[key3] = 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, key2) {
+function getTupleOptStart(items, key3) {
   for (let i = items.length - 1; i >= 0; i--) {
-    if (items[i]._zod[key2] !== "optional")
+    if (items[i]._zod[key3] !== "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 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);
+      for (const key3 of values) {
+        if (typeof key3 === "string" || typeof key3 === "number" || typeof key3 === "symbol") {
+          recordKeys.add(typeof key3 === "number" ? key3.toString() : key3);
+          const keyResult = def.keyType._zod.run({ value: key3, 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: key2,
-              path: [key2],
+              input: key3,
+              path: [key3],
               inst
             });
             continue;
           }
           const outKey = keyResult.value;
-          const result = def.valueType._zod.run({ value: input[key2], issues: [] }, ctx);
+          const result = def.valueType._zod.run({ value: input[key3], issues: [] }, ctx);
           if (result instanceof Promise) {
             proms.push(result.then((result2) => {
               if (result2.issues.length) {
-                payload.issues.push(...prefixIssues(key2, result2.issues));
+                payload.issues.push(...prefixIssues(key3, result2.issues));
               }
               payload.value[outKey] = result2.value;
             }));
           } else {
             if (result.issues.length) {
-              payload.issues.push(...prefixIssues(key2, result.issues));
+              payload.issues.push(...prefixIssues(key3, result.issues));
             }
             payload.value[outKey] = result.value;
           }
         }
       }
       let unrecognized;
-      for (const key2 in input) {
-        if (!recordKeys.has(key2)) {
+      for (const key3 in input) {
+        if (!recordKeys.has(key3)) {
           unrecognized = unrecognized ?? [];
-          unrecognized.push(key2);
+          unrecognized.push(key3);
         }
       }
       if (unrecognized && unrecognized.length > 0) {
@@ -3666,18 +3666,18 @@ var $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
       }
     } else {
       payload.value = {};
-      for (const key2 of Reflect.ownKeys(input)) {
-        if (key2 === "__proto__")
+      for (const key3 of Reflect.ownKeys(input)) {
+        if (key3 === "__proto__")
           continue;
-        if (!Object.prototype.propertyIsEnumerable.call(input, key2))
+        if (!Object.prototype.propertyIsEnumerable.call(input, key3))
           continue;
-        let keyResult = def.keyType._zod.run({ value: key2, issues: [] }, ctx);
+        let keyResult = def.keyType._zod.run({ value: key3, issues: [] }, ctx);
         if (keyResult instanceof Promise) {
           throw new Error("Async schemas not supported in object keys currently");
         }
-        const checkNumericKey = typeof key2 === "string" && number.test(key2) && keyResult.issues.length;
+        const checkNumericKey = typeof key3 === "string" && number.test(key3) && keyResult.issues.length;
         if (checkNumericKey) {
-          const retryResult = def.keyType._zod.run({ value: Number(key2), issues: [] }, ctx);
+          const retryResult = def.keyType._zod.run({ value: Number(key3), 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[key2] = input[key2];
+            payload.value[key3] = input[key3];
           } else {
             payload.issues.push({
               code: "invalid_key",
               origin: "record",
               issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config())),
-              input: key2,
-              path: [key2],
+              input: key3,
+              path: [key3],
               inst
             });
           }
           continue;
         }
-        const result = def.valueType._zod.run({ value: input[key2], issues: [] }, ctx);
+        const result = def.valueType._zod.run({ value: input[key3], issues: [] }, ctx);
         if (result instanceof Promise) {
           proms.push(result.then((result2) => {
             if (result2.issues.length) {
-              payload.issues.push(...prefixIssues(key2, result2.issues));
+              payload.issues.push(...prefixIssues(key3, result2.issues));
             }
             payload.value[keyResult.value] = result2.value;
           }));
         } else {
           if (result.issues.length) {
-            payload.issues.push(...prefixIssues(key2, result.issues));
+            payload.issues.push(...prefixIssues(key3, 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 [key2, value] of input) {
-      const keyResult = def.keyType._zod.run({ value: key2, issues: [] }, ctx);
+    for (const [key3, value] of input) {
+      const keyResult = def.keyType._zod.run({ value: key3, 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, key2, input, inst, ctx);
+          handleMapResult(keyResult2, valueResult2, payload, key3, input, inst, ctx);
         }));
       } else {
-        handleMapResult(keyResult, valueResult, payload, key2, input, inst, ctx);
+        handleMapResult(keyResult, valueResult, payload, key3, input, inst, ctx);
       }
     }
     if (proms.length)
@@ -3753,10 +3753,10 @@ var $ZodMap = /* @__PURE__ */ $constructor("$ZodMap", (inst, def) => {
     return payload;
   };
 });
-function handleMapResult(keyResult, valueResult, final, key2, input, inst, ctx) {
+function handleMapResult(keyResult, valueResult, final, key3, input, inst, ctx) {
   if (keyResult.issues.length) {
-    if (propertyKeyTypes.has(typeof key2)) {
-      final.issues.push(...prefixIssues(key2, keyResult.issues));
+    if (propertyKeyTypes.has(typeof key3)) {
+      final.issues.push(...prefixIssues(key3, keyResult.issues));
     } else {
       final.issues.push({
         code: "invalid_key",
@@ -3768,15 +3768,15 @@ function handleMapResult(keyResult, valueResult, final, key2, input, inst, ctx)
     }
   }
   if (valueResult.issues.length) {
-    if (propertyKeyTypes.has(typeof key2)) {
-      final.issues.push(...prefixIssues(key2, valueResult.issues));
+    if (propertyKeyTypes.has(typeof key3)) {
+      final.issues.push(...prefixIssues(key3, valueResult.issues));
     } else {
       final.issues.push({
         origin: "map",
         code: "invalid_element",
         input,
         inst,
-        key: key2,
+        key: key3,
         issues: valueResult.issues.map((iss) => finalizeIssue(iss, ctx, config()))
       });
     }
@@ -11532,15 +11532,15 @@ function extractDefs(ctx, schema) {
       return;
     }
     const seen = entry[1];
-    const { ref, defId } = makeURI(entry);
+    const { ref: ref2, defId } = makeURI(entry);
     seen.def = { ...seen.schema };
     if (defId)
       seen.defId = defId;
     const schema2 = seen.schema;
-    for (const key2 in schema2) {
-      delete schema2[key2];
+    for (const key3 in schema2) {
+      delete schema2[key3];
     }
-    schema2.$ref = ref;
+    schema2.$ref = ref2;
   };
   if (ctx.cycles === "throw") {
     for (const entry of ctx.seen.entries()) {
@@ -11592,11 +11592,11 @@ function finalize(ctx, schema) {
       return;
     const schema2 = seen.def ?? seen.schema;
     const _cached = { ...schema2 };
-    const ref = seen.ref;
+    const ref2 = seen.ref;
     seen.ref = null;
-    if (ref) {
-      flattenRef(ref);
-      const refSeen = ctx.seen.get(ref);
+    if (ref2) {
+      flattenRef(ref2);
+      const refSeen = ctx.seen.get(ref2);
       const refSchema = refSeen.schema;
       if (refSchema.$ref && (ctx.target === "draft-07" || ctx.target === "draft-04" || ctx.target === "openapi-3.0")) {
         schema2.allOf = schema2.allOf ?? [];
@@ -11605,38 +11605,38 @@ function finalize(ctx, schema) {
         Object.assign(schema2, refSchema);
       }
       Object.assign(schema2, _cached);
-      const isParentRef = zodSchema._zod.parent === ref;
+      const isParentRef = zodSchema._zod.parent === ref2;
       if (isParentRef) {
-        for (const key2 in schema2) {
-          if (key2 === "$ref" || key2 === "allOf")
+        for (const key3 in schema2) {
+          if (key3 === "$ref" || key3 === "allOf")
             continue;
-          if (!(key2 in _cached)) {
-            delete schema2[key2];
+          if (!(key3 in _cached)) {
+            delete schema2[key3];
           }
         }
       }
       if (refSchema.$ref && refSeen.def) {
-        for (const key2 in schema2) {
-          if (key2 === "$ref" || key2 === "allOf")
+        for (const key3 in schema2) {
+          if (key3 === "$ref" || key3 === "allOf")
             continue;
-          if (key2 in refSeen.def && JSON.stringify(schema2[key2]) === JSON.stringify(refSeen.def[key2])) {
-            delete schema2[key2];
+          if (key3 in refSeen.def && JSON.stringify(schema2[key3]) === JSON.stringify(refSeen.def[key3])) {
+            delete schema2[key3];
           }
         }
       }
     }
     const parent = zodSchema._zod.parent;
-    if (parent && parent !== ref) {
+    if (parent && parent !== ref2) {
       flattenRef(parent);
       const parentSeen = ctx.seen.get(parent);
       if (parentSeen?.schema.$ref) {
         schema2.$ref = parentSeen.schema.$ref;
         if (parentSeen.def) {
-          for (const key2 in schema2) {
-            if (key2 === "$ref" || key2 === "allOf")
+          for (const key3 in schema2) {
+            if (key3 === "$ref" || key3 === "allOf")
               continue;
-            if (key2 in parentSeen.def && JSON.stringify(schema2[key2]) === JSON.stringify(parentSeen.def[key2])) {
-              delete schema2[key2];
+            if (key3 in parentSeen.def && JSON.stringify(schema2[key3]) === JSON.stringify(parentSeen.def[key3])) {
+              delete schema2[key3];
             }
           }
         }
@@ -11737,8 +11737,8 @@ function isTransforming(_schema, _ctx) {
     return isTransforming(def.in, ctx) || isTransforming(def.out, ctx);
   }
   if (def.type === "object") {
-    for (const key2 in def.shape) {
-      if (isTransforming(def.shape[key2], ctx))
+    for (const key3 in def.shape) {
+      if (isTransforming(def.shape[key3], 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 key2 in shape) {
-    json2.properties[key2] = process2(shape[key2], ctx, {
+  for (const key3 in shape) {
+    json2.properties[key3] = process2(shape[key3], ctx, {
       ...params,
-      path: [...params.path, "properties", key2]
+      path: [...params.path, "properties", key3]
     });
   }
   const allKeys = new Set(Object.keys(shape));
-  const requiredKeys = new Set([...allKeys].filter((key2) => {
-    const v = def.shape[key2]._zod;
+  const requiredKeys = new Set([...allKeys].filter((key3) => {
+    const v = def.shape[key3]._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 [key2, schema] = entry;
+      const [key3, schema] = entry;
       extractDefs(ctx2, schema);
-      schemas[key2] = finalize(ctx2, schema);
+      schemas[key3] = 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 key2 in methods) {
-    const fn = methods[key2];
-    Object.defineProperty(proto, key2, {
+  for (const key3 in methods) {
+    const fn = methods[key3];
+    Object.defineProperty(proto, key3, {
       configurable: true,
       enumerable: false,
       get() {
         const bound = fn.bind(this);
-        Object.defineProperty(this, key2, {
+        Object.defineProperty(this, key3, {
           configurable: true,
           writable: true,
           enumerable: true,
@@ -12725,7 +12725,7 @@ function _installLazyMethods(inst, group, methods) {
         return bound;
       },
       set(v) {
-        Object.defineProperty(this, key2, {
+        Object.defineProperty(this, key3, {
           configurable: true,
           writable: true,
           enumerable: true,
@@ -14103,23 +14103,23 @@ function detectVersion(schema, defaultTarget) {
   }
   return defaultTarget ?? "draft-2020-12";
 }
-function resolveRef(ref, ctx) {
-  if (!ref.startsWith("#")) {
+function resolveRef(ref2, ctx) {
+  if (!ref2.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path8 = ref.slice(1).split("/").filter(Boolean);
+  const path8 = ref2.slice(1).split("/").filter(Boolean);
   if (path8.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
   if (path8[0] === defsKey) {
-    const key2 = path8[1];
-    if (!key2 || !ctx.defs[key2]) {
-      throw new Error(`Reference not found: ${ref}`);
+    const key3 = path8[1];
+    if (!key3 || !ctx.defs[key3]) {
+      throw new Error(`Reference not found: ${ref2}`);
     }
-    return ctx.defs[key2];
+    return ctx.defs[key3];
   }
-  throw new Error(`Reference not found: ${ref}`);
+  throw new Error(`Reference not found: ${ref2}`);
 }
 function convertBaseSchema(schema, ctx) {
   if (schema.not !== void 0) {
@@ -14303,9 +14303,9 @@ function convertBaseSchema(schema, ctx) {
       const shape = {};
       const properties = schema.properties || {};
       const requiredSet = new Set(schema.required || []);
-      for (const [key2, propSchema] of Object.entries(properties)) {
+      for (const [key3, propSchema] of Object.entries(properties)) {
         const propZodSchema = convertSchema(propSchema, ctx);
-        shape[key2] = requiredSet.has(key2) ? propZodSchema : propZodSchema.optional();
+        shape[key3] = requiredSet.has(key3) ? 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 key2 of coreMetadataKeys) {
-    if (key2 in schema) {
-      extraMeta[key2] = schema[key2];
+  for (const key3 of coreMetadataKeys) {
+    if (key3 in schema) {
+      extraMeta[key3] = schema[key3];
     }
   }
   const contentMetadataKeys = ["contentEncoding", "contentMediaType", "contentSchema"];
-  for (const key2 of contentMetadataKeys) {
-    if (key2 in schema) {
-      extraMeta[key2] = schema[key2];
+  for (const key3 of contentMetadataKeys) {
+    if (key3 in schema) {
+      extraMeta[key3] = schema[key3];
     }
   }
-  for (const key2 of Object.keys(schema)) {
-    if (!RECOGNIZED_KEYS.has(key2)) {
-      extraMeta[key2] = schema[key2];
+  for (const key3 of Object.keys(schema)) {
+    if (!RECOGNIZED_KEYS.has(key3)) {
+      extraMeta[key3] = schema[key3];
     }
   }
   if (Object.keys(extraMeta).length > 0) {
@@ -15164,29 +15164,29 @@ function parseMapping(lines, startIdx, indent) {
       i++;
       continue;
     }
-    const key2 = stripKeyQuotes(line.text.slice(0, colon).trim());
-    if (key2 === "") {
+    const key3 = stripKeyQuotes(line.text.slice(0, colon).trim());
+    if (key3 === "") {
       i++;
       continue;
     }
     const rest = line.text.slice(colon + 1).trim();
     if (rest !== "") {
-      out[key2] = parseFlowValue(rest);
+      out[key3] = 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[key2] = null;
+        out[key3] = null;
         i++;
       } else {
         const childBlock = lines.slice(i + 1, j);
         const firstChild = childBlock[0];
         if (firstChild?.text.trimStart().startsWith("- ")) {
-          out[key2] = parseSequence(childBlock, childIndent);
+          out[key3] = parseSequence(childBlock, childIndent);
         } else {
-          out[key2] = parseMapping(childBlock, 0, childIndent).value;
+          out[key3] = parseMapping(childBlock, 0, childIndent).value;
         }
         i = j;
       }
@@ -15298,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 key2 = m[1] ?? "";
-    if (!(key2 in options)) continue;
-    handled.add(key2);
+    const key3 = m[1] ?? "";
+    if (!(key3 in options)) continue;
+    handled.add(key3);
     let end = i + 1;
     while (end < lines.length && /^[ \t]+/.test(lines[end] ?? "")) end++;
-    const value = options[key2];
+    const value = options[key3];
     if (value === null || value === void 0) {
       lines.splice(i, end - i);
       i--;
     } else {
-      lines.splice(i, end - i, `${key2}: ${serializeOptionValue(value)}`);
+      lines.splice(i, end - i, `${key3}: ${serializeOptionValue(value)}`);
     }
   }
   const appended = [];
-  for (const [key2, value] of Object.entries(options)) {
-    if (handled.has(key2)) continue;
+  for (const [key3, value] of Object.entries(options)) {
+    if (handled.has(key3)) continue;
     if (value === null || value === void 0) continue;
-    appended.push(`${key2}: ${serializeOptionValue(value)}`);
+    appended.push(`${key3}: ${serializeOptionValue(value)}`);
   }
   const nextBlock = appended.length > 0 ? lines.join(eol) + eol + appended.join(eol) : lines.join(eol);
   if (nextBlock === block) return content;
@@ -15753,49 +15753,8 @@ 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/quota-fallback-v2.ts
+import { createHash } from "crypto";
 
 // src/core/quota-preflight.ts
 import { Rpc } from "@opencode/plugin/rpc";
@@ -15876,12 +15835,301 @@ function createQuotaQuery(query, deadlineMs = 3e3, capacity = 16) {
   };
 }
 
+// src/quota-fallback-v2.ts
+var QuotaFallbackOptions = external_exports.object({
+  enabled: external_exports.boolean().default(false),
+  allowPaidFallbacks: external_exports.boolean().default(false),
+  maxSwitches: external_exports.number().int().min(1).max(8).default(8)
+}).strict();
+var key = (m) => `${m.providerID}/${m.id}#${m.variant === "default" ? "" : m.variant ?? ""}`;
+var ref = (m) => ({
+  ...quotaCandidate(m),
+  ...m.variant && m.variant !== "default" ? { variant: m.variant } : {}
+});
+var TTL = 5e3;
+var clock = () => performance.now();
+var CAP = 1024;
+var digest = (text) => createHash("sha256").update(text).digest("hex");
+function createQuotaFallback(ctx, routes, admission, current, selected = () => {
+}) {
+  const parsed = QuotaFallbackOptions.safeParse(ctx.options?.quotaFallback ?? {});
+  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 turns = /* @__PURE__ */ new Map();
+  const observations = /* @__PURE__ */ new Map();
+  const requests = /* @__PURE__ */ new WeakMap();
+  const poisoned = /* @__PURE__ */ new Set();
+  const busy = /* @__PURE__ */ new Set();
+  const tickets = /* @__PURE__ */ new Map();
+  const claiming = /* @__PURE__ */ new Map();
+  let disposed = false;
+  let saturated = false;
+  let childSaturated = false;
+  const poison = (id) => {
+    if (poisoned.has(id) || poisoned.size < CAP) poisoned.add(id);
+    else saturated = true;
+  };
+  const prune = () => {
+    const cutoff = clock() - TTL;
+    for (const [id, value] of observations) {
+      if (value.at >= cutoff) continue;
+      if (value.ambiguous || value.status === void 0 || value.status >= 400) poison(id);
+      observations.delete(id);
+    }
+    for (const [id, value] of tickets) if (value.at < cutoff) tickets.delete(id);
+  };
+  const timer = setInterval(prune, TTL);
+  timer.unref();
+  const stop = (id) => {
+    turns.delete(id);
+    observations.delete(id);
+    poisoned.delete(id);
+    claiming.delete(id);
+  };
+  return {
+    stop,
+    admit(id, agent, model) {
+      stop(id);
+      if (turns.size < CAP)
+        turns.set(id, { agent, model, switches: 0, selected: false, generation: 0 });
+    },
+    // Keep only a digest of the automatic admission, never prompt text.
+    ticket(id, parent, agent, model, prompt) {
+      prune();
+      if (tickets.size < CAP)
+        tickets.set(`${parent}/${id}`, {
+          parent,
+          agent,
+          model,
+          callID: id,
+          promptHash: prompt === void 0 ? void 0 : digest(`You are a subagent spawned by another session.
+${prompt}`),
+          at: clock()
+        });
+      else childSaturated = true;
+    },
+    async child(id, agent, model) {
+      if (childSaturated || turns.has(id) || claiming.has(id) || claiming.size >= 64 || disposed || !current())
+        return;
+      prune();
+      const claim = {};
+      claiming.set(id, claim);
+      try {
+        const session = await ctx.session.get({ sessionID: id });
+        if (!session.parentID || session.agent !== agent || !session.model || key(session.model) !== key(model))
+          return;
+        const candidates = [...tickets].filter(([, t]) => t.parent === session.parentID);
+        if (candidates.length !== 1 || await admission.isPinned(id)) return;
+        const messages = await ctx.session.context({ sessionID: session.parentID });
+        const calls = messages.flatMap((m) => "content" in m ? m.content : []);
+        const childMessages = await ctx.session.context({ sessionID: id });
+        const users = childMessages.filter((m) => m.type === "user");
+        const user = users.length === 1 ? users[0] : void 0;
+        if (!user) return;
+        const matched = candidates.filter(
+          ([, t]) => t.agent === agent && t.promptHash && digest(user.text) === t.promptHash && // Positive native association beats a matching automatic prompt fingerprint.
+          !calls.some(
+            (call) => call.name === "subagent" && call.id !== t.callID && call.state?.metadata?.sessionID === id
+          ) && calls.some(
+            (call) => call.id === t.callID && call.name === "subagent" && call.state?.status === "running" && (!call.state.metadata?.sessionID || call.state.metadata.sessionID === id)
+          ) && (!t.model || t.model === `${model.providerID}/${model.id}${model.variant && model.variant !== "default" ? `#${model.variant}` : ""}`)
+        );
+        const match = matched.length === 1 ? matched[0] : void 0;
+        if (!match) return;
+        const latest = await ctx.session.get({ sessionID: id });
+        if (disposed || childSaturated || !current() || claiming.get(id) !== claim || latest.agent !== agent || !latest.model || key(latest.model) !== key(model) || await admission.isPinned(id) || claiming.get(id) !== claim || childSaturated || clock() - match[1].at > TTL)
+          return;
+        tickets.delete(match[0]);
+        if (admission.claim(id, agent, model) && turns.size < CAP) {
+          turns.set(id, { agent, model, switches: 0, selected: false, generation: 0 });
+          selected(id, agent, model, user.id);
+        }
+      } finally {
+        if (claiming.get(id) === claim) claiming.delete(id);
+      }
+    },
+    model(event) {
+      prune();
+      const turn = turns.get(event.sessionID);
+      if (turn) turn.generation++;
+      const previous = observations.get(event.sessionID);
+      if (!previous && observations.size >= CAP) {
+        poison(event.sessionID);
+        return;
+      }
+      if (event.kind !== "primary" || previous?.ambiguous || previous && (previous.status === void 0 || previous.status >= 400)) {
+        poison(event.sessionID);
+      }
+      const observed = {
+        model: key(event.model),
+        agent: event.agent,
+        kind: event.kind,
+        at: clock(),
+        ambiguous: event.kind !== "primary" || poisoned.has(event.sessionID)
+      };
+      try {
+        const url2 = new URL(event.baseURL ?? "");
+        if (!["http:", "https:"].includes(url2.protocol) || url2.username || url2.password || url2.search || url2.hash)
+          observed.ambiguous = true;
+        else {
+          observed.origin = url2.origin;
+          const base = url2.pathname.replace(/\/$/, "");
+          observed.paths = ["/chat/completions", "/responses", "/messages"].map((p) => base + p);
+        }
+      } catch {
+        observed.ambiguous = true;
+      }
+      observations.set(event.sessionID, observed);
+    },
+    request(event) {
+      prune();
+      const observed = observations.get(event.sessionID);
+      if (!observed) return;
+      const url2 = new URL(event.request.url);
+      if (observed.sent || observed.model !== key(event.model) || observed.agent !== event.agent || observed.kind !== event.kind || url2.username || url2.password || url2.search || url2.hash || url2.origin !== observed.origin || !observed.paths?.includes(url2.pathname))
+        observed.ambiguous = true;
+      observed.sent = true;
+      requests.set(event.request, observed);
+      const turn = turns.get(event.sessionID);
+      if (turn?.selected && event.kind === "primary" && key(turn.model) === key(event.model)) {
+        turn.selected = false;
+        admission.reason(event.sessionID, "quota_fallback_attempt_dispatched", event.model);
+      }
+    },
+    response(event) {
+      const observed = observations.get(event.sessionID);
+      if (!observed) return;
+      if (requests.get(event.request) !== observed || observed.model !== key(event.model) || observed.agent !== event.agent || observed.kind !== event.kind)
+        observed.ambiguous = true;
+      else observed.status = event.response.status;
+    },
+    unsupported(id) {
+      const observed = observations.get(id);
+      poison(id);
+      if (observed) observed.ambiguous = true;
+    },
+    async retry(event) {
+      const id = event.sessionID;
+      prune();
+      const observed = observations.get(id);
+      if (observed && (observed.ambiguous || observed.status === void 0)) poison(id);
+      observations.delete(id);
+      const turn = turns.get(id);
+      const generation = turn?.generation;
+      const live = () => !disposed && current() && turns.get(id) === turn && turn?.generation === generation && !!observed && clock() - observed.at <= TTL;
+      if (disposed || saturated || !current() || busy.has(id) || busy.size >= 64 || !turn || !observed || observed.ambiguous || poisoned.has(id) || observed.kind !== "primary" || observed.agent !== event.agent || observed.model !== key(event.model) || turn.agent !== event.agent || key(turn.model) !== key(event.model) || event.error.type !== "provider.quota" || ![402, 429].includes(observed.status ?? 0) || event.error.status !== observed.status)
+        return false;
+      if (!options.allowPaidFallbacks || turn.switches >= options.maxSwitches) return true;
+      const route = routes[turn.agent];
+      if (!route) return true;
+      const chain = [route, ...route.fallbacks ?? []].map(ref);
+      const index = chain.findIndex((m) => key(m) === key(event.model));
+      if (index < 0) return true;
+      busy.add(id);
+      try {
+        const before = await ctx.session.get({ sessionID: id });
+        if (before.agent !== turn.agent || !admission.owns(id, before) || before.model && key(before.model) !== key(event.model) || await admission.isPinned(id) || !live())
+          return true;
+        const results = await query.read(
+          chain.slice(index + 1).map(({ providerID, id: id2 }) => ({ providerID, id: id2 }))
+        );
+        const next = chain.slice(index + 1).find(
+          (m) => (
+            // Do not revisit a model, even if it occurs twice in the configured chain.
+            !chain.slice(0, index + 1).some((old) => key(old) === key(m)) && effectiveQuotaStatus(m, results).status !== "exhausted"
+          )
+        );
+        if (!next) return true;
+        const latest = await ctx.session.get({ sessionID: id });
+        if (!live() || clock() - observed.at > TTL || !admission.owns(id, latest) || await admission.isPinned(id) || latest.agent !== before.agent || (latest.model ? key(latest.model) : "") !== (before.model ? key(before.model) : "") || !live())
+          return true;
+        if (!await admission.select(id, turn.agent, next, live)) return true;
+        turn.model = next;
+        turn.switches++;
+        turn.selected = true;
+        admission.reason(
+          id,
+          live() ? "quota_fallback_selected_retry_requested_not_confirmed" : "quota_fallback_selected_retry_not_requested_control_changed",
+          next
+        );
+        if (live()) {
+          selected(id, turn.agent, next);
+          event.decision = { retry: true, delay: 0 };
+        }
+        return true;
+      } catch {
+        admission.reason(id, "quota_fallback_selection_failed_retry_not_requested");
+        return true;
+      } finally {
+        busy.delete(id);
+      }
+    },
+    dispose() {
+      disposed = true;
+      clearInterval(timer);
+      query.dispose();
+      turns.clear();
+      observations.clear();
+      tickets.clear();
+      poisoned.clear();
+      claiming.clear();
+    }
+  };
+}
+
+// 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/quota-v2.ts
-var key = (model) => model ? `${model.providerID}/${model.id}#${model.variant === "default" ? "" : model.variant ?? ""}` : "";
+var key2 = (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 fallback = QuotaFallbackOptions.safeParse(ctx.options?.quotaFallback ?? {});
+  if ((!parsed.success || !parsed.data.enabled) && (!fallback.success || !fallback.data.enabled))
+    return void 0;
+  const options = parsed.success ? parsed.data : { enabled: false, allowPaidFallbacks: false };
   const query = createQuotaQuery((input, request) => ctx.rpc(UsageQuota).query(input, request));
   const owned = /* @__PURE__ */ new Map();
   const expected = /* @__PURE__ */ new Map();
@@ -15899,7 +16147,7 @@ function createQuotaAdmission(ctx, routes, current) {
   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)}` : ""}`);
+    console.info(`agent-router: [${sessionID}] ${value}${model ? ` ${key2(model)}` : ""}`);
   };
   const isPinned = async (sessionID) => {
     if (pinned.has(sessionID)) return true;
@@ -15915,19 +16163,19 @@ function createQuotaAdmission(ctx, routes, current) {
         (other) => other.providerID === entry.providerID && other.id === entry.id
       ) === index
     );
-    const results = await query.read(candidates);
+    const results = options.enabled ? await query.read(candidates) : [];
     return () => {
       const now = Date.now();
       const startIndex = pending ? Math.max(
         0,
         [route, ...route.fallbacks ?? []].findIndex(
-          (entry) => key({
+          (entry) => key2({
             ...quotaCandidate(entry),
             ...entry.variant ? { variant: entry.variant } : {}
-          }) === key(pending)
+          }) === key2(pending)
         )
       ) : 0;
-      const choice = chooseQuotaRoute(route, results, options.allowPaidFallbacks, now, startIndex);
+      const choice = options.enabled ? chooseQuotaRoute(route, results, options.allowPaidFallbacks, now, startIndex) : pending ? [route, ...route.fallbacks ?? []][startIndex] : route;
       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"
@@ -15936,10 +16184,39 @@ function createQuotaAdmission(ctx, routes, current) {
   };
   return {
     isPinned,
+    reason,
+    owns(sessionID, session) {
+      return !disposed && current() && !controls.has(sessionID) && !pinned.has(sessionID) && !!session.agent && (!session.model || owned.get(sessionID)?.agent === session.agent && owned.get(sessionID)?.model === key2(session.model));
+    },
+    claim(sessionID, agent, model) {
+      if (disposed || !current() || controls.has(sessionID) || pinned.has(sessionID)) return false;
+      if (!owned.has(sessionID) && owned.size >= 1024) return false;
+      owned.set(sessionID, { agent, model: key2(model) });
+      return true;
+    },
+    async select(sessionID, agent, model, live) {
+      if (!live()) return false;
+      expected.set(sessionID, key2(model));
+      try {
+        await ctx.session.switchModel({
+          sessionID,
+          model: {
+            providerID: model.providerID,
+            id: model.id,
+            ...model.variant ? { variant: model.variant } : {}
+          }
+        });
+        if (live()) owned.set(sessionID, { agent, model: key2(model) });
+        return true;
+      } catch (error51) {
+        expected.delete(sessionID);
+        throw error51;
+      }
+    },
     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 automatic = !explicit && (!session.model || owned.get(sessionID)?.model === key2(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,
@@ -15981,7 +16258,7 @@ function createQuotaAdmission(ctx, routes, current) {
             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))
+            if (latest.agent !== session.agent || key2(latest.model) !== key2(session.model))
               throw new Error(
                 "Session selection changed while pinning; current selection remains pinned."
               );
@@ -16000,7 +16277,7 @@ function createQuotaAdmission(ctx, routes, current) {
           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) });
+          owned.set(sessionID, { agent: session.agent, model: key2(session.model) });
           reason(sessionID, "automatic_next_explicit_turn", session.model);
         }
       } finally {
@@ -16010,7 +16287,7 @@ function createQuotaAdmission(ctx, routes, current) {
     },
     /** Called for every selection event, including before the first prompt. */
     event(sessionID, type, model) {
-      if (type === "session.model.selected" && expected.get(sessionID) === key(model)) {
+      if (type === "session.model.selected" && expected.get(sessionID) === key2(model)) {
         expected.delete(sessionID);
         return true;
       }
@@ -16045,13 +16322,13 @@ function createQuotaAdmission(ctx, routes, current) {
         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)))
+        if (session.model && (!previous || previous.agent !== session.agent || previous.model !== key2(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())
+        if (disposed || controls.has(sessionID) || pinned.has(sessionID) || latest.agent !== session.agent || key2(latest.model) !== key2(session.model) || (versions.get(sessionID) ?? 0) !== generation || !current())
           return;
         const decision = choose();
         const { choice } = decision;
@@ -16063,8 +16340,8 @@ function createQuotaAdmission(ctx, routes, current) {
           ...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));
+        if (key2(model) !== key2(session.model) && (session.model || choice.model !== route.model || choice.variant !== route.variant)) {
+          expected.set(sessionID, key2(model));
           try {
             await ctx.session.switchModel({ sessionID, model });
           } catch {
@@ -16074,7 +16351,7 @@ function createQuotaAdmission(ctx, routes, current) {
         }
         if (disposed || controls.has(sessionID) || pinned.has(sessionID) || (versions.get(sessionID) ?? 0) !== generation)
           return;
-        owned.set(sessionID, { agent: session.agent, model: key(model) });
+        owned.set(sessionID, { agent: session.agent, model: key2(model) });
         reason(sessionID, decision.reason, model);
         return model;
       } finally {
@@ -16174,6 +16451,28 @@ async function setupV2(ctx) {
   const kinds = /* @__PURE__ */ new Map();
   const ownSelections = /* @__PURE__ */ new Map();
   const quota = createQuotaAdmission(ctx, routes, () => state() === initial);
+  const quotaFallback = quota && createQuotaFallback(
+    ctx,
+    routes,
+    quota,
+    () => state() === initial,
+    (sessionID, agent, model, messageID) => {
+      const id = messageID ?? turns.get(sessionID)?.id;
+      if (!id) return;
+      const message = {
+        id,
+        agent,
+        model: {
+          providerID: model.providerID,
+          modelID: model.id,
+          variant: variant(model.variant)
+        }
+      };
+      failover.admit(sessionID, message);
+      turns.set(sessionID, message);
+      kinds.set(sessionID, "primary");
+    }
+  );
   if (quota) {
     await ctx.tool.transform((editor) => {
       const input = { type: "object", properties: {}, additionalProperties: false };
@@ -16184,6 +16483,7 @@ async function setupV2(ctx) {
           input,
           async execute(_input, context) {
             await quota.control(context.sessionID, action, async () => {
+              quotaFallback?.stop(context.sessionID);
               turns.delete(context.sessionID);
               kinds.delete(context.sessionID);
               await failover.event({
@@ -16217,6 +16517,15 @@ async function setupV2(ctx) {
         event.type === "session.model.selected" ? event.data.model : void 0
       ))
         continue;
+      if ([
+        "session.model.selected",
+        "session.agent.selected",
+        "session.execution.interrupted",
+        "session.deleted",
+        "session.execution.succeeded",
+        "session.execution.failed"
+      ].includes(event.type))
+        quotaFallback?.stop(sessionID);
       if (!turns.has(sessionID)) continue;
       if (event.type === "session.model.selected") {
         const model = event.data.model;
@@ -16241,12 +16550,37 @@ async function setupV2(ctx) {
   })().catch((error51) => {
     if (!controller.signal.aborted) console.warn("agent-router event subscription failed", error51);
   });
-  await ctx.session.hook("model.request", (event) => {
+  await ctx.session.hook("model.request", async (event) => {
+    quotaFallback?.model(event);
+    if (event.kind === "primary")
+      await quotaFallback?.child(event.sessionID, event.agent, event.model);
     if (turns.has(event.sessionID)) kinds.set(event.sessionID, event.kind);
   });
-  if (quota) await ctx.tool.hook("execute.before", (event) => quota.child(event));
+  if (quota)
+    await ctx.tool.hook("execute.before", async (event) => {
+      const input = event.input;
+      const automatic = event.tool === "subagent" && input && typeof input === "object" && !["model", "sessionID", "session_id", "task_id"].some((key3) => key3 in input) && typeof input.agent === "string";
+      await quota.child(event);
+      if (event.tool === "subagent" && input && typeof input.agent === "string")
+        quotaFallback?.ticket(
+          event.id,
+          event.sessionID,
+          input.agent,
+          typeof input.model === "string" ? input.model : void 0,
+          automatic && typeof input.prompt === "string" ? input.prompt : void 0
+        );
+    });
+  if (quotaFallback) {
+    await ctx.session.hook("http.request", (event) => quotaFallback.request(event));
+    await ctx.session.hook("http.response", (event) => quotaFallback.response(event));
+    await ctx.session.hook(
+      "experimental.ws.handshake",
+      (event) => quotaFallback.unsupported(event.sessionID)
+    );
+  }
   await ctx.session.hook("prompt", async (event) => {
     if (turns.get(event.sessionID)?.id === event.messageID) return;
+    quotaFallback?.stop(event.sessionID);
     if (state() !== initial) {
       failover.disable();
       turns.clear();
@@ -16285,6 +16619,7 @@ async function setupV2(ctx) {
       failover.admit(event.sessionID, message2);
       if (!failover.active(event.sessionID)) return;
       turns.set(event.sessionID, message2);
+      if (!session.parentID) quotaFallback?.admit(event.sessionID, session.agent, selected);
       return;
     }
     if (!session.agent || !session.model || !routes[session.agent]) return;
@@ -16336,6 +16671,7 @@ async function setupV2(ctx) {
     turns.set(event.sessionID, message);
   });
   await ctx.session.hook("retry", async (event) => {
+    if (await quotaFallback?.retry(event)) return;
     const turn = turns.get(event.sessionID);
     if (!turn || kinds.get(event.sessionID) !== "primary" || turn.agent !== event.agent || turn.model.providerID !== event.model.providerID || turn.model.modelID !== event.model.id)
       return;
@@ -16363,6 +16699,7 @@ async function setupV2(ctx) {
   });
   return async () => {
     controller.abort();
+    quotaFallback?.dispose();
     await quota?.dispose();
     failover.disable();
     turns.clear();
@@ -16373,7 +16710,7 @@ async function setupV2(ctx) {
 }
 
 // src/version.ts
-var VERSION = "2.1.1";
+var VERSION = "2.2.0";
 
 // src/plugin.ts
 var tool = Object.assign(