slopcode 0.2.138 → 0.2.141

package/bundle/worker.js

@@ -46,6 +46,39 @@ var __export = (target, all) => {
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __promiseAll = (args2) => Promise.all(args2);
 var __require = import.meta.require;
+var __using = (stack, value, async) => {
+  if (value != null) {
+    if (typeof value !== "object" && typeof value !== "function")
+      throw TypeError('Object expected to be assigned to "using" declaration');
+    let dispose;
+    if (async)
+      dispose = value[Symbol.asyncDispose];
+    if (dispose === undefined)
+      dispose = value[Symbol.dispose];
+    if (typeof dispose !== "function")
+      throw TypeError("Object not disposable");
+    stack.push([async, dispose, value]);
+  } else if (async) {
+    stack.push([async]);
+  }
+  return value;
+};
+var __callDispose = (stack, error, hasError) => {
+  let fail = (e) => error = hasError ? new SuppressedError(e, error, "An error was suppressed during disposal") : (hasError = true, e), next = (it) => {
+    while (it = stack.pop()) {
+      try {
+        var result = it[1] && it[1].call(it[2]);
+        if (it[0])
+          return Promise.resolve(result).then(next, (e) => (fail(e), next()));
+      } catch (e) {
+        fail(e);
+      }
+    }
+    if (hasError)
+      throw error;
+  };
+  return next();
+};
 
 // ../../node_modules/.bun/zod@4.1.8/node_modules/zod/v4/core/core.js
 function $constructor(name2, initializer, params) {
@@ -10538,7 +10571,7 @@ class JSONSchemaGenerator {
               if (val === undefined) {
                 if (this.unrepresentable === "throw") {
                   throw new Error("Literal `undefined` cannot be represented in JSON Schema");
-                }
+                } else {}
               } else if (typeof val === "bigint") {
                 if (this.unrepresentable === "throw") {
                   throw new Error("BigInt literals cannot be represented in JSON Schema");
@@ -27961,7 +27994,7 @@ var init_installation = __esm(async () => {
       await $`${process.execPath} --version`.nothrow().quiet().text();
     }
     Installation.upgrade = upgrade;
-    Installation.VERSION = "0.2.138";
+    Installation.VERSION = "0.2.141";
     Installation.CHANNEL = "latest";
     Installation.USER_AGENT = `${product.id}/${Installation.CHANNEL}/${Installation.VERSION}/${Flag.SLOPCODE_CLIENT}`;
     async function latest(installMethod) {
@@ -81720,7 +81753,7 @@ function toIntArray(seed) {
       buffer4.push(unicode >>> 6 & 63 | 128);
       buffer4.push(unicode >>> 0 & 63 | 128);
       index3++;
-    }
+    } else {}
     if (buffer4.length > 3) {
       result6.push(buffer4.shift() << 0 | buffer4.shift() << 8 | buffer4.shift() << 16 | buffer4.shift() << 24);
     }
@@ -94653,57 +94686,64 @@ var init_bun = __esm(async () => {
       version: zod_default.string()
     }));
     async function install(pkg, version4 = "latest") {
-      using _3 = await Lock.write("bun-install");
-      const mod = path11.join(Global.Path.cache, "node_modules", pkg);
-      const pkgjsonPath = path11.join(Global.Path.cache, "package.json");
-      const parsed = await Filesystem.readJson(pkgjsonPath).catch(async () => {
-        const result6 = { dependencies: {} };
-        await Filesystem.writeJson(pkgjsonPath, result6);
-        return result6;
-      });
-      if (!parsed.dependencies)
-        parsed.dependencies = {};
-      const dependencies = parsed.dependencies;
-      const modExists = await Filesystem.exists(mod);
-      const cachedVersion = dependencies[pkg];
-      if (!modExists || !cachedVersion) {} else if (version4 !== "latest" && cachedVersion === version4) {
-        return mod;
-      } else if (version4 === "latest") {
-        const isOutdated = await PackageRegistry.isOutdated(pkg, cachedVersion, Global.Path.cache);
-        if (!isOutdated)
+      let __stack = [];
+      try {
+        const _3 = __using(__stack, await Lock.write("bun-install"), 0);
+        const mod = path11.join(Global.Path.cache, "node_modules", pkg);
+        const pkgjsonPath = path11.join(Global.Path.cache, "package.json");
+        const parsed = await Filesystem.readJson(pkgjsonPath).catch(async () => {
+          const result6 = { dependencies: {} };
+          await Filesystem.writeJson(pkgjsonPath, result6);
+          return result6;
+        });
+        if (!parsed.dependencies)
+          parsed.dependencies = {};
+        const dependencies = parsed.dependencies;
+        const modExists = await Filesystem.exists(mod);
+        const cachedVersion = dependencies[pkg];
+        if (!modExists || !cachedVersion) {} else if (version4 !== "latest" && cachedVersion === version4) {
           return mod;
-        log4.info("Cached version is outdated, proceeding with install", { pkg, cachedVersion });
-      }
-      const args3 = [
-        "add",
-        "--force",
-        "--exact",
-        ...proxied() || process.env.CI ? ["--no-cache"] : [],
-        "--cwd",
-        Global.Path.cache,
-        pkg + "@" + version4
-      ];
-      log4.info("installing package using Bun's default registry resolution", {
-        pkg,
-        version: version4
-      });
-      await BunProc.run(args3, {
-        cwd: Global.Path.cache
-      }).catch((e3) => {
-        throw new BunProc.InstallFailedError({ pkg, version: version4 }, {
-          cause: e3
+        } else if (version4 === "latest") {
+          const isOutdated = await PackageRegistry.isOutdated(pkg, cachedVersion, Global.Path.cache);
+          if (!isOutdated)
+            return mod;
+          log4.info("Cached version is outdated, proceeding with install", { pkg, cachedVersion });
+        }
+        const args3 = [
+          "add",
+          "--force",
+          "--exact",
+          ...proxied() || process.env.CI ? ["--no-cache"] : [],
+          "--cwd",
+          Global.Path.cache,
+          pkg + "@" + version4
+        ];
+        log4.info("installing package using Bun's default registry resolution", {
+          pkg,
+          version: version4
         });
-      });
-      let resolvedVersion = version4;
-      if (version4 === "latest") {
-        const installedPkg = await Filesystem.readJson(path11.join(mod, "package.json")).catch(() => null);
-        if (installedPkg?.version) {
-          resolvedVersion = installedPkg.version;
+        await BunProc.run(args3, {
+          cwd: Global.Path.cache
+        }).catch((e3) => {
+          throw new BunProc.InstallFailedError({ pkg, version: version4 }, {
+            cause: e3
+          });
+        });
+        let resolvedVersion = version4;
+        if (version4 === "latest") {
+          const installedPkg = await Filesystem.readJson(path11.join(mod, "package.json")).catch(() => null);
+          if (installedPkg?.version) {
+            resolvedVersion = installedPkg.version;
+          }
         }
+        parsed.dependencies[pkg] = resolvedVersion;
+        await Filesystem.writeJson(pkgjsonPath, parsed);
+        return mod;
+      } catch (_catch3) {
+        var _err = _catch3, _hasErr = 1;
+      } finally {
+        __callDispose(__stack, _err, _hasErr);
       }
-      parsed.dependencies[pkg] = resolvedVersion;
-      await Filesystem.writeJson(pkgjsonPath, parsed);
-      return mod;
     }
     BunProc.install = install;
   })(BunProc ||= {});
@@ -103573,9 +103613,16 @@ var init_storage = __esm(async () => {
       const dir2 = await state2().then((x3) => x3.dir);
       const target = path17.join(dir2, ...key) + ".json";
       return withErrorHandling(async () => {
-        using _3 = await Lock.read(target);
-        const result6 = await Filesystem.readJson(target);
-        return result6;
+        let __stack = [];
+        try {
+          const _3 = __using(__stack, await Lock.read(target), 0);
+          const result6 = await Filesystem.readJson(target);
+          return result6;
+        } catch (_catch3) {
+          var _err = _catch3, _hasErr = 1;
+        } finally {
+          __callDispose(__stack, _err, _hasErr);
+        }
       });
     }
     Storage.read = read2;
@@ -103583,11 +103630,18 @@ var init_storage = __esm(async () => {
       const dir2 = await state2().then((x3) => x3.dir);
       const target = path17.join(dir2, ...key) + ".json";
       return withErrorHandling(async () => {
-        using _3 = await Lock.write(target);
-        const content = await Filesystem.readJson(target);
-        fn4(content);
-        await Filesystem.writeJson(target, content);
-        return content;
+        let __stack = [];
+        try {
+          const _3 = __using(__stack, await Lock.write(target), 0);
+          const content = await Filesystem.readJson(target);
+          fn4(content);
+          await Filesystem.writeJson(target, content);
+          return content;
+        } catch (_catch3) {
+          var _err = _catch3, _hasErr = 1;
+        } finally {
+          __callDispose(__stack, _err, _hasErr);
+        }
       });
     }
     Storage.update = update9;
@@ -103595,8 +103649,15 @@ var init_storage = __esm(async () => {
       const dir2 = await state2().then((x3) => x3.dir);
       const target = path17.join(dir2, ...key) + ".json";
       return withErrorHandling(async () => {
-        using _3 = await Lock.write(target);
-        await Filesystem.writeJson(target, content);
+        let __stack = [];
+        try {
+          const _3 = __using(__stack, await Lock.write(target), 0);
+          await Filesystem.writeJson(target, content);
+        } catch (_catch3) {
+          var _err = _catch3, _hasErr = 1;
+        } finally {
+          __callDispose(__stack, _err, _hasErr);
+        }
       });
     }
     Storage.write = write;
@@ -111747,7 +111808,7 @@ var require_tracestate_impl = __commonJS((exports) => {
           const value8 = listMember.slice(i8 + 1, part.length);
           if ((0, tracestate_validators_1.validateKey)(key) && (0, tracestate_validators_1.validateValue)(value8)) {
             agg.set(key, value8);
-          }
+          } else {}
         }
         return agg;
       }, new Map);
@@ -140521,54 +140582,61 @@ var init_file = __esm(async () => {
     }
     File.status = status;
     async function read2(file2) {
-      using _3 = log8.time("read", { file: file2 });
-      const project = Instance.project;
-      const full = path24.join(Instance.directory, file2);
-      if (!Instance.containsPath(full)) {
-        throw new Error(`Access denied: path escapes project directory`);
-      }
-      if (isImageByExtension(file2)) {
-        if (await Filesystem.exists(full)) {
+      let __stack = [];
+      try {
+        const _3 = __using(__stack, log8.time("read", { file: file2 }), 0);
+        const project = Instance.project;
+        const full = path24.join(Instance.directory, file2);
+        if (!Instance.containsPath(full)) {
+          throw new Error(`Access denied: path escapes project directory`);
+        }
+        if (isImageByExtension(file2)) {
+          if (await Filesystem.exists(full)) {
+            const buffer4 = await Filesystem.readBytes(full).catch(() => Buffer.from([]));
+            const content2 = buffer4.toString("base64");
+            const mimeType2 = getImageMimeType(file2);
+            return { type: "text", content: content2, mimeType: mimeType2, encoding: "base64" };
+          }
+          return { type: "text", content: "" };
+        }
+        const text9 = isTextByExtension(file2) || isTextByName(file2);
+        if (isBinaryByExtension(file2) && !text9) {
+          return { type: "binary", content: "" };
+        }
+        if (!await Filesystem.exists(full)) {
+          return { type: "text", content: "" };
+        }
+        const mimeType = Filesystem.mimeType(full);
+        const encode5 = text9 ? false : await shouldEncode(mimeType);
+        if (encode5 && !isImage(mimeType)) {
+          return { type: "binary", content: "", mimeType };
+        }
+        if (encode5) {
           const buffer4 = await Filesystem.readBytes(full).catch(() => Buffer.from([]));
           const content2 = buffer4.toString("base64");
-          const mimeType2 = getImageMimeType(file2);
-          return { type: "text", content: content2, mimeType: mimeType2, encoding: "base64" };
-        }
-        return { type: "text", content: "" };
-      }
-      const text9 = isTextByExtension(file2) || isTextByName(file2);
-      if (isBinaryByExtension(file2) && !text9) {
-        return { type: "binary", content: "" };
-      }
-      if (!await Filesystem.exists(full)) {
-        return { type: "text", content: "" };
-      }
-      const mimeType = Filesystem.mimeType(full);
-      const encode5 = text9 ? false : await shouldEncode(mimeType);
-      if (encode5 && !isImage(mimeType)) {
-        return { type: "binary", content: "", mimeType };
-      }
-      if (encode5) {
-        const buffer4 = await Filesystem.readBytes(full).catch(() => Buffer.from([]));
-        const content2 = buffer4.toString("base64");
-        return { type: "text", content: content2, mimeType, encoding: "base64" };
-      }
-      const content = (await Filesystem.readText(full).catch(() => "")).trim();
-      if (project.vcs === "git") {
-        let diff = await $8`git diff ${file2}`.cwd(Instance.directory).quiet().nothrow().text();
-        if (!diff.trim())
-          diff = await $8`git diff --staged ${file2}`.cwd(Instance.directory).quiet().nothrow().text();
-        if (diff.trim()) {
-          const original = await $8`git show HEAD:${file2}`.cwd(Instance.directory).quiet().nothrow().text();
-          const patch = structuredPatch(file2, file2, original, content, "old", "new", {
-            context: Infinity,
-            ignoreWhitespace: true
-          });
-          const diff2 = formatPatch(patch);
-          return { type: "text", content, patch, diff: diff2 };
+          return { type: "text", content: content2, mimeType, encoding: "base64" };
+        }
+        const content = (await Filesystem.readText(full).catch(() => "")).trim();
+        if (project.vcs === "git") {
+          let diff = await $8`git diff ${file2}`.cwd(Instance.directory).quiet().nothrow().text();
+          if (!diff.trim())
+            diff = await $8`git diff --staged ${file2}`.cwd(Instance.directory).quiet().nothrow().text();
+          if (diff.trim()) {
+            const original = await $8`git show HEAD:${file2}`.cwd(Instance.directory).quiet().nothrow().text();
+            const patch = structuredPatch(file2, file2, original, content, "old", "new", {
+              context: Infinity,
+              ignoreWhitespace: true
+            });
+            const diff2 = formatPatch(patch);
+            return { type: "text", content, patch, diff: diff2 };
+          }
         }
+        return { type: "text", content };
+      } catch (_catch3) {
+        var _err = _catch3, _hasErr = 1;
+      } finally {
+        __callDispose(__stack, _err, _hasErr);
       }
-      return { type: "text", content };
     }
     File.read = read2;
     async function list(dir2) {
@@ -163200,7 +163268,7 @@ ${JSON.stringify(symbolNames, null, 2)}`);
             throw new Error(response.status + " : " + response.url);
           }, "readAsync");
         }
-      }
+      } else {}
       var out = Module["print"] || console.log.bind(console);
       var err = Module["printErr"] || console.error.bind(console);
       Object.assign(Module, moduleOverrides);
@@ -167902,134 +167970,141 @@ var init_task2 = __esm(async () => {
       description,
       parameters,
       async execute(params, ctx2) {
-        const config5 = await Config.get();
-        if (params.background && !Flag.SLOPCODE_EXPERIMENTAL_BACKGROUND_SUBAGENTS) {
-          throw new Error("Background subagents require SLOPCODE_EXPERIMENTAL_BACKGROUND_SUBAGENTS=true");
-        }
-        if (!ctx2.extra?.bypassAgentCheck) {
-          await ctx2.ask({
-            permission: "task",
-            patterns: [params.subagent_type],
-            always: ["*"],
-            metadata: {
-              description: params.description,
-              subagent_type: params.subagent_type
-            }
-          });
-        }
-        const agent = await Agent.get(params.subagent_type);
-        if (!agent)
-          throw new Error(`Unknown agent type: ${params.subagent_type} is not a valid agent type`);
-        const hasTaskPermission = agent.permission.some((rule) => rule.permission === "task");
-        const hasTodoWritePermission = agent.permission.some((rule) => rule.permission === "todowrite");
-        const hasTodoReadPermission = agent.permission.some((rule) => rule.permission === "todoread");
-        const session = await iife2(async () => {
-          if (params.task_id) {
-            const found = await Session.get(params.task_id).catch(() => {});
-            if (found)
-              return found;
-          }
-          return await Session.create({
-            parentID: ctx2.sessionID,
-            title: params.description + ` (@${agent.name} subagent)`,
-            permission: [
-              ...hasTodoWritePermission ? [] : [
-                {
-                  permission: "todowrite",
-                  pattern: "*",
-                  action: "deny"
-                }
-              ],
-              ...hasTodoReadPermission ? [] : [
-                {
-                  permission: "todoread",
-                  pattern: "*",
-                  action: "deny"
-                }
-              ],
-              ...hasTaskPermission ? [] : [
-                {
-                  permission: "task",
+        let __stack = [];
+        try {
+          const config5 = await Config.get();
+          if (params.background && !Flag.SLOPCODE_EXPERIMENTAL_BACKGROUND_SUBAGENTS) {
+            throw new Error("Background subagents require SLOPCODE_EXPERIMENTAL_BACKGROUND_SUBAGENTS=true");
+          }
+          if (!ctx2.extra?.bypassAgentCheck) {
+            await ctx2.ask({
+              permission: "task",
+              patterns: [params.subagent_type],
+              always: ["*"],
+              metadata: {
+                description: params.description,
+                subagent_type: params.subagent_type
+              }
+            });
+          }
+          const agent = await Agent.get(params.subagent_type);
+          if (!agent)
+            throw new Error(`Unknown agent type: ${params.subagent_type} is not a valid agent type`);
+          const hasTaskPermission = agent.permission.some((rule) => rule.permission === "task");
+          const hasTodoWritePermission = agent.permission.some((rule) => rule.permission === "todowrite");
+          const hasTodoReadPermission = agent.permission.some((rule) => rule.permission === "todoread");
+          const session = await iife2(async () => {
+            if (params.task_id) {
+              const found = await Session.get(params.task_id).catch(() => {});
+              if (found)
+                return found;
+            }
+            return await Session.create({
+              parentID: ctx2.sessionID,
+              title: params.description + ` (@${agent.name} subagent)`,
+              permission: [
+                ...hasTodoWritePermission ? [] : [
+                  {
+                    permission: "todowrite",
+                    pattern: "*",
+                    action: "deny"
+                  }
+                ],
+                ...hasTodoReadPermission ? [] : [
+                  {
+                    permission: "todoread",
+                    pattern: "*",
+                    action: "deny"
+                  }
+                ],
+                ...hasTaskPermission ? [] : [
+                  {
+                    permission: "task",
+                    pattern: "*",
+                    action: "deny"
+                  }
+                ],
+                ...config5.experimental?.primary_tools?.map((t3) => ({
                   pattern: "*",
-                  action: "deny"
-                }
-              ],
-              ...config5.experimental?.primary_tools?.map((t3) => ({
-                pattern: "*",
-                action: "allow",
-                permission: t3
-              })) ?? []
-            ]
-          });
-        });
-        const msg = await MessageV2.get({ sessionID: ctx2.sessionID, messageID: ctx2.messageID });
-        if (msg.info.role !== "assistant")
-          throw new Error("Not an assistant message");
-        const model2 = agent.model ?? {
-          modelID: msg.info.modelID,
-          providerID: msg.info.providerID
-        };
-        const metadata2 = {
-          sessionId: session.id,
-          model: model2,
-          ...params.background ? { background: true } : {}
-        };
-        ctx2.metadata({
-          title: params.description,
-          metadata: metadata2
-        });
-        async function runTask() {
-          const promptParts = await SessionPrompt.resolvePromptParts(params.prompt);
-          const result6 = await SessionPrompt.prompt({
-            messageID: Identifier.ascending("message"),
-            sessionID: session.id,
-            model: {
-              modelID: model2.modelID,
-              providerID: model2.providerID
-            },
-            agent: agent.name,
-            tools: {
-              ...hasTodoWritePermission ? {} : { todowrite: false },
-              ...hasTodoReadPermission ? {} : { todoread: false },
-              ...hasTaskPermission ? {} : { task: false },
-              ...Object.fromEntries((config5.experimental?.primary_tools ?? []).map((t3) => [t3, false]))
-            },
-            parts: promptParts
+                  action: "allow",
+                  permission: t3
+                })) ?? []
+              ]
+            });
           });
-          return result6.parts.findLast((x3) => x3.type === "text")?.text ?? "";
-        }
-        if (params.background) {
-          const existing = BackgroundJob.get(session.id);
-          if (existing?.status === "running") {
-            throw new Error(`Task ${session.id} is already running. Use task_status to check progress.`);
-          }
-          const info4 = await BackgroundJob.start({
-            id: session.id,
-            type: "task",
+          const msg = await MessageV2.get({ sessionID: ctx2.sessionID, messageID: ctx2.messageID });
+          if (msg.info.role !== "assistant")
+            throw new Error("Not an assistant message");
+          const model2 = agent.model ?? {
+            modelID: msg.info.modelID,
+            providerID: msg.info.providerID
+          };
+          const metadata2 = {
+            sessionId: session.id,
+            model: model2,
+            ...params.background ? { background: true } : {}
+          };
+          ctx2.metadata({
             title: params.description,
-            metadata: metadata2,
-            run: runTask
+            metadata: metadata2
           });
+          async function runTask() {
+            const promptParts = await SessionPrompt.resolvePromptParts(params.prompt);
+            const result6 = await SessionPrompt.prompt({
+              messageID: Identifier.ascending("message"),
+              sessionID: session.id,
+              model: {
+                modelID: model2.modelID,
+                providerID: model2.providerID
+              },
+              agent: agent.name,
+              tools: {
+                ...hasTodoWritePermission ? {} : { todowrite: false },
+                ...hasTodoReadPermission ? {} : { todoread: false },
+                ...hasTaskPermission ? {} : { task: false },
+                ...Object.fromEntries((config5.experimental?.primary_tools ?? []).map((t3) => [t3, false]))
+              },
+              parts: promptParts
+            });
+            return result6.parts.findLast((x3) => x3.type === "text")?.text ?? "";
+          }
+          if (params.background) {
+            const existing = BackgroundJob.get(session.id);
+            if (existing?.status === "running") {
+              throw new Error(`Task ${session.id} is already running. Use task_status to check progress.`);
+            }
+            const info4 = await BackgroundJob.start({
+              id: session.id,
+              type: "task",
+              title: params.description,
+              metadata: metadata2,
+              run: runTask
+            });
+            return {
+              title: params.description,
+              metadata: {
+                ...metadata2,
+                jobId: info4.id
+              },
+              output: backgroundOutput(session.id)
+            };
+          }
+          function cancel() {
+            SessionPrompt.cancel(session.id);
+          }
+          ctx2.abort.addEventListener("abort", cancel);
+          const _3 = __using(__stack, defer(() => ctx2.abort.removeEventListener("abort", cancel)), 0);
+          const text11 = await runTask();
           return {
             title: params.description,
-            metadata: {
-              ...metadata2,
-              jobId: info4.id
-            },
-            output: backgroundOutput(session.id)
+            metadata: metadata2,
+            output: formatOutput(session.id, text11)
           };
+        } catch (_catch3) {
+          var _err = _catch3, _hasErr = 1;
+        } finally {
+          __callDispose(__stack, _err, _hasErr);
         }
-        function cancel() {
-          SessionPrompt.cancel(session.id);
-        }
-        ctx2.abort.addEventListener("abort", cancel);
-        using _3 = defer(() => ctx2.abort.removeEventListener("abort", cancel));
-        const text11 = await runTask();
-        return {
-          title: params.description,
-          metadata: metadata2,
-          output: formatOutput(session.id, text11)
-        };
       }
     };
   });
@@ -187339,19 +187414,26 @@ var init_registry2 = __esm(async () => {
           return !usePatch;
         return true;
       }).map(async (t3) => {
-        using _3 = log12.time(t3.id);
-        const tool2 = await t3.init({ agent });
-        const output2 = {
-          description: tool2.description,
-          parameters: tool2.parameters
-        };
-        await Plugin.trigger("tool.definition", { toolID: t3.id }, output2);
-        return {
-          id: t3.id,
-          ...tool2,
-          description: output2.description,
-          parameters: output2.parameters
-        };
+        let __stack = [];
+        try {
+          const _3 = __using(__stack, log12.time(t3.id), 0);
+          const tool2 = await t3.init({ agent });
+          const output2 = {
+            description: tool2.description,
+            parameters: tool2.parameters
+          };
+          await Plugin.trigger("tool.definition", { toolID: t3.id }, output2);
+          return {
+            id: t3.id,
+            ...tool2,
+            description: output2.description,
+            parameters: output2.parameters
+          };
+        } catch (_catch3) {
+          var _err = _catch3, _hasErr = 1;
+        } finally {
+          __callDispose(__stack, _err, _hasErr);
+        }
       }));
       return result6;
     }
@@ -188105,404 +188187,411 @@ var init_prompt = __esm(async () => {
         let step = 0;
         const session = await Session.get(sessionID);
         while (true) {
-          SessionStatus.busy(sessionID, "starting");
-          log12.info("loop", { step, sessionID });
-          if (abort2.aborted) {
-            if (held(state4()[sessionID], state4()[sessionID]?.current)) {
-              next4 = "hold";
-              return;
-            }
-            break;
-          }
-          let msgs = filterQueuedMessages(await MessageV2.filterCompacted(MessageV2.stream(sessionID)), state4()[sessionID], mode2);
-          const current2 = mode2 === "serial" ? state4()[sessionID]?.current : undefined;
-          const currentVisible = current2 ? msgs.some((msg) => msg.info.role === "user" && msg.info.id === current2) : false;
-          let currentMsg;
-          let lastUser;
-          let lastAssistant;
-          let lastFinished;
-          let lastComplete;
-          let tasks = [];
-          for (let i8 = msgs.length - 1;i8 >= 0; i8--) {
-            const msg = msgs[i8];
-            if (!lastUser && msg.info.role === "user" && (!current2 || msg.info.id === current2 || !currentVisible)) {
-              lastUser = msg.info;
-              currentMsg = msg;
-            }
-            if (!lastAssistant && msg.info.role === "assistant")
-              lastAssistant = msg.info;
-            if (!lastFinished && msg.info.role === "assistant" && msg.info.finish) {
-              lastFinished = msg.info;
-            }
-            if (!lastComplete && msg.info.role === "assistant" && msg.info.finish && !["tool-calls", "unknown"].includes(msg.info.finish)) {
-              lastComplete = msg.info;
-            }
-            if (lastUser && lastComplete)
+          let __stack = [];
+          try {
+            SessionStatus.busy(sessionID, "starting");
+            log12.info("loop", { step, sessionID });
+            if (abort2.aborted) {
+              if (held(state4()[sessionID], state4()[sessionID]?.current)) {
+                next4 = "hold";
+                return;
+              }
               break;
-            const task2 = msg.parts.filter((part) => part.type === "compaction" || part.type === "subtask");
-            if (task2 && !lastComplete && (!current2 || msg.info.id !== current2)) {
-              tasks.push(...task2);
             }
-          }
-          if (currentMsg && !lastComplete) {
-            const processed = msgs.filter((msg) => msg.info.role === "assistant" && msg.info.parentID === currentMsg.info.id && msg.parts.some((part) => part.type === "tool" && part.tool === TaskTool.id)).length;
-            const remaining2 = currentMsg.parts.filter((part) => part.type === "subtask").slice(processed);
-            tasks.push(...remaining2);
-          }
-          if (!lastUser)
-            throw new Error("No user message found in stream. This should never happen.");
-          if (shouldExitLoop(lastUser, lastAssistant)) {
-            log12.info("exiting loop", { sessionID });
-            break;
-          }
-          step++;
-          const model2 = await Provider2.getModel(lastUser.model.providerID, lastUser.model.modelID).catch((e4) => {
-            if (Provider2.ModelNotFoundError.isInstance(e4)) {
-              const hint = e4.data.suggestions?.length ? ` Did you mean: ${e4.data.suggestions.join(", ")}?` : "";
-              Bus.publish(Session.Event.Error, {
-                sessionID,
-                error: new NamedError.Unknown({
-                  message: `Model not found: ${e4.data.providerID}/${e4.data.modelID}.${hint}`
-                }).toObject(),
-                viewID: Instance.viewID
-              });
+            let msgs = filterQueuedMessages(await MessageV2.filterCompacted(MessageV2.stream(sessionID)), state4()[sessionID], mode2);
+            const current2 = mode2 === "serial" ? state4()[sessionID]?.current : undefined;
+            const currentVisible = current2 ? msgs.some((msg) => msg.info.role === "user" && msg.info.id === current2) : false;
+            let currentMsg;
+            let lastUser;
+            let lastAssistant;
+            let lastFinished;
+            let lastComplete;
+            let tasks = [];
+            for (let i8 = msgs.length - 1;i8 >= 0; i8--) {
+              const msg = msgs[i8];
+              if (!lastUser && msg.info.role === "user" && (!current2 || msg.info.id === current2 || !currentVisible)) {
+                lastUser = msg.info;
+                currentMsg = msg;
+              }
+              if (!lastAssistant && msg.info.role === "assistant")
+                lastAssistant = msg.info;
+              if (!lastFinished && msg.info.role === "assistant" && msg.info.finish) {
+                lastFinished = msg.info;
+              }
+              if (!lastComplete && msg.info.role === "assistant" && msg.info.finish && !["tool-calls", "unknown"].includes(msg.info.finish)) {
+                lastComplete = msg.info;
+              }
+              if (lastUser && lastComplete)
+                break;
+              const task2 = msg.parts.filter((part) => part.type === "compaction" || part.type === "subtask");
+              if (task2 && !lastComplete && (!current2 || msg.info.id !== current2)) {
+                tasks.push(...task2);
+              }
             }
-            throw e4;
-          });
-          const task = tasks.pop();
-          const taskMsg = task && msgs.find((msg) => msg.info.role === "user" && msg.parts.some((part) => part.id === task.id));
-          const taskUser = taskMsg?.info.role === "user" ? taskMsg.info : lastUser;
-          if (task?.type === "subtask") {
-            const taskTool = await TaskTool.init();
-            const taskModel = task.model ? await Provider2.getModel(task.model.providerID, task.model.modelID) : model2;
-            const assistantMessage = await Session.updateMessage({
-              id: Identifier.ascending("message"),
-              role: "assistant",
-              parentID: taskUser.id,
-              sessionID,
-              mode: task.agent,
-              agent: task.agent,
-              variant: taskUser.variant,
-              path: {
-                cwd: Instance.directory,
-                root: Instance.worktree
-              },
-              cost: 0,
-              tokens: {
-                input: 0,
-                output: 0,
-                reasoning: 0,
-                cache: { read: 0, write: 0 }
-              },
-              modelID: taskModel.id,
-              providerID: taskModel.providerID,
-              time: {
-                created: Date.now()
+            if (currentMsg && !lastComplete) {
+              const processed = msgs.filter((msg) => msg.info.role === "assistant" && msg.info.parentID === currentMsg.info.id && msg.parts.some((part) => part.type === "tool" && part.tool === TaskTool.id)).length;
+              const remaining2 = currentMsg.parts.filter((part) => part.type === "subtask").slice(processed);
+              tasks.push(...remaining2);
+            }
+            if (!lastUser)
+              throw new Error("No user message found in stream. This should never happen.");
+            if (shouldExitLoop(lastUser, lastAssistant)) {
+              log12.info("exiting loop", { sessionID });
+              break;
+            }
+            step++;
+            const model2 = await Provider2.getModel(lastUser.model.providerID, lastUser.model.modelID).catch((e4) => {
+              if (Provider2.ModelNotFoundError.isInstance(e4)) {
+                const hint = e4.data.suggestions?.length ? ` Did you mean: ${e4.data.suggestions.join(", ")}?` : "";
+                Bus.publish(Session.Event.Error, {
+                  sessionID,
+                  error: new NamedError.Unknown({
+                    message: `Model not found: ${e4.data.providerID}/${e4.data.modelID}.${hint}`
+                  }).toObject(),
+                  viewID: Instance.viewID
+                });
               }
+              throw e4;
             });
-            let part = await Session.updatePart({
-              id: Identifier.ascending("part"),
-              messageID: assistantMessage.id,
-              sessionID: assistantMessage.sessionID,
-              type: "tool",
-              callID: ulid4(),
-              tool: TaskTool.id,
-              state: {
-                status: "running",
-                input: {
-                  prompt: task.prompt,
-                  description: task.description,
-                  subagent_type: task.agent,
-                  command: task.command
+            const task = tasks.pop();
+            const taskMsg = task && msgs.find((msg) => msg.info.role === "user" && msg.parts.some((part) => part.id === task.id));
+            const taskUser = taskMsg?.info.role === "user" ? taskMsg.info : lastUser;
+            if (task?.type === "subtask") {
+              const taskTool = await TaskTool.init();
+              const taskModel = task.model ? await Provider2.getModel(task.model.providerID, task.model.modelID) : model2;
+              const assistantMessage = await Session.updateMessage({
+                id: Identifier.ascending("message"),
+                role: "assistant",
+                parentID: taskUser.id,
+                sessionID,
+                mode: task.agent,
+                agent: task.agent,
+                variant: taskUser.variant,
+                path: {
+                  cwd: Instance.directory,
+                  root: Instance.worktree
                 },
+                cost: 0,
+                tokens: {
+                  input: 0,
+                  output: 0,
+                  reasoning: 0,
+                  cache: { read: 0, write: 0 }
+                },
+                modelID: taskModel.id,
+                providerID: taskModel.providerID,
                 time: {
-                  start: Date.now()
+                  created: Date.now()
                 }
+              });
+              let part = await Session.updatePart({
+                id: Identifier.ascending("part"),
+                messageID: assistantMessage.id,
+                sessionID: assistantMessage.sessionID,
+                type: "tool",
+                callID: ulid4(),
+                tool: TaskTool.id,
+                state: {
+                  status: "running",
+                  input: {
+                    prompt: task.prompt,
+                    description: task.description,
+                    subagent_type: task.agent,
+                    command: task.command
+                  },
+                  time: {
+                    start: Date.now()
+                  }
+                }
+              });
+              const taskArgs = {
+                prompt: task.prompt,
+                description: task.description,
+                subagent_type: task.agent,
+                command: task.command
+              };
+              await abortable(Plugin.trigger("tool.execute.before", {
+                tool: "task",
+                sessionID,
+                callID: part.id
+              }, { args: taskArgs }), abort2);
+              let executionError;
+              const taskAgent = await Agent.get(task.agent);
+              const taskCtx = {
+                agent: task.agent,
+                messageID: assistantMessage.id,
+                sessionID,
+                abort: abort2,
+                callID: part.callID,
+                extra: { bypassAgentCheck: true },
+                messages: msgs,
+                async metadata(input2) {
+                  await Session.updatePart({
+                    ...part,
+                    type: "tool",
+                    state: {
+                      ...part.state,
+                      ...input2
+                    }
+                  });
+                },
+                async ask(req) {
+                  await PermissionNext.ask({
+                    ...req,
+                    sessionID,
+                    ruleset: PermissionNext.merge(taskAgent.permission, session.permission ?? [])
+                  });
+                }
+              };
+              const result7 = await abortable(taskTool.execute(taskArgs, taskCtx), abort2).catch((error46) => {
+                executionError = error46;
+                log12.error("subtask execution failed", { error: error46, agent: task.agent, description: task.description });
+                return;
+              });
+              const attachments = result7?.attachments?.map((attachment) => ({
+                ...attachment,
+                id: Identifier.ascending("part"),
+                sessionID,
+                messageID: assistantMessage.id
+              }));
+              await abortable(Plugin.trigger("tool.execute.after", {
+                tool: "task",
+                sessionID,
+                callID: part.id,
+                args: taskArgs
+              }, result7), abort2);
+              assistantMessage.finish = "tool-calls";
+              assistantMessage.time.completed = Date.now();
+              await Session.updateMessage(assistantMessage);
+              if (result7 && part.state.status === "running") {
+                await Session.updatePart({
+                  ...part,
+                  state: {
+                    status: "completed",
+                    input: part.state.input,
+                    title: result7.title,
+                    metadata: result7.metadata,
+                    output: result7.output,
+                    attachments,
+                    time: {
+                      ...part.state.time,
+                      end: Date.now()
+                    }
+                  }
+                });
               }
-            });
-            const taskArgs = {
-              prompt: task.prompt,
-              description: task.description,
-              subagent_type: task.agent,
-              command: task.command
-            };
-            await abortable(Plugin.trigger("tool.execute.before", {
-              tool: "task",
-              sessionID,
-              callID: part.id
-            }, { args: taskArgs }), abort2);
-            let executionError;
-            const taskAgent = await Agent.get(task.agent);
-            const taskCtx = {
-              agent: task.agent,
-              messageID: assistantMessage.id,
-              sessionID,
-              abort: abort2,
-              callID: part.callID,
-              extra: { bypassAgentCheck: true },
-              messages: msgs,
-              async metadata(input2) {
+              if (!result7) {
                 await Session.updatePart({
                   ...part,
-                  type: "tool",
                   state: {
-                    ...part.state,
-                    ...input2
+                    status: "error",
+                    error: executionError ? `Tool execution failed: ${executionError.message}` : "Tool execution failed",
+                    time: {
+                      start: part.state.status === "running" ? part.state.time.start : Date.now(),
+                      end: Date.now()
+                    },
+                    metadata: part.metadata,
+                    input: part.state.input
                   }
                 });
-              },
-              async ask(req) {
-                await PermissionNext.ask({
-                  ...req,
+              }
+              if (task.command) {
+                const summaryUserMsg = {
+                  id: Identifier.ascending("message"),
                   sessionID,
-                  ruleset: PermissionNext.merge(taskAgent.permission, session.permission ?? [])
+                  role: "user",
+                  time: {
+                    created: Date.now()
+                  },
+                  agent: taskUser.agent,
+                  model: taskUser.model
+                };
+                await Session.updateMessage(summaryUserMsg);
+                await Session.updatePart({
+                  id: Identifier.ascending("part"),
+                  messageID: summaryUserMsg.id,
+                  sessionID,
+                  type: "text",
+                  text: "Summarize the task tool output above and continue with your task.",
+                  synthetic: true
                 });
               }
-            };
-            const result7 = await abortable(taskTool.execute(taskArgs, taskCtx), abort2).catch((error46) => {
-              executionError = error46;
-              log12.error("subtask execution failed", { error: error46, agent: task.agent, description: task.description });
-              return;
-            });
-            const attachments = result7?.attachments?.map((attachment) => ({
-              ...attachment,
-              id: Identifier.ascending("part"),
-              sessionID,
-              messageID: assistantMessage.id
-            }));
-            await abortable(Plugin.trigger("tool.execute.after", {
-              tool: "task",
-              sessionID,
-              callID: part.id,
-              args: taskArgs
-            }, result7), abort2);
-            assistantMessage.finish = "tool-calls";
-            assistantMessage.time.completed = Date.now();
-            await Session.updateMessage(assistantMessage);
-            if (result7 && part.state.status === "running") {
-              await Session.updatePart({
-                ...part,
-                state: {
-                  status: "completed",
-                  input: part.state.input,
-                  title: result7.title,
-                  metadata: result7.metadata,
-                  output: result7.output,
-                  attachments,
-                  time: {
-                    ...part.state.time,
-                    end: Date.now()
-                  }
-                }
-              });
+              continue;
             }
-            if (!result7) {
-              await Session.updatePart({
-                ...part,
-                state: {
-                  status: "error",
-                  error: executionError ? `Tool execution failed: ${executionError.message}` : "Tool execution failed",
-                  time: {
-                    start: part.state.status === "running" ? part.state.time.start : Date.now(),
-                    end: Date.now()
-                  },
-                  metadata: part.metadata,
-                  input: part.state.input
-                }
+            if (task?.type === "compaction") {
+              SessionStatus.busy(sessionID, "compacting");
+              const result7 = await SessionCompaction.process({
+                messages: msgs,
+                parentID: taskUser.id,
+                abort: abort2,
+                sessionID,
+                auto: task.auto,
+                overflow: task.overflow
               });
+              if (result7 === "stop")
+                break;
+              continue;
             }
-            if (task.command) {
-              const summaryUserMsg = {
-                id: Identifier.ascending("message"),
-                sessionID,
-                role: "user",
-                time: {
-                  created: Date.now()
-                },
-                agent: taskUser.agent,
-                model: taskUser.model
-              };
-              await Session.updateMessage(summaryUserMsg);
-              await Session.updatePart({
-                id: Identifier.ascending("part"),
-                messageID: summaryUserMsg.id,
+            if (lastFinished && lastFinished.summary !== true && await SessionCompaction.isOverflow({ tokens: lastFinished.tokens, model: model2 })) {
+              SessionStatus.busy(sessionID, "compacting");
+              await SessionCompaction.create({
                 sessionID,
-                type: "text",
-                text: "Summarize the task tool output above and continue with your task.",
-                synthetic: true
+                agent: lastUser.agent,
+                model: lastUser.model,
+                auto: true
               });
+              continue;
             }
-            continue;
-          }
-          if (task?.type === "compaction") {
-            SessionStatus.busy(sessionID, "compacting");
-            const result7 = await SessionCompaction.process({
+            const agent = await Agent.get(lastUser.agent);
+            const maxSteps = agent.steps ?? Infinity;
+            const isLastStep = step >= maxSteps;
+            msgs = await insertReminders({
               messages: msgs,
-              parentID: taskUser.id,
-              abort: abort2,
-              sessionID,
-              auto: task.auto,
-              overflow: task.overflow
+              agent,
+              session
             });
-            if (result7 === "stop")
-              break;
-            continue;
-          }
-          if (lastFinished && lastFinished.summary !== true && await SessionCompaction.isOverflow({ tokens: lastFinished.tokens, model: model2 })) {
-            SessionStatus.busy(sessionID, "compacting");
-            await SessionCompaction.create({
+            const processor = SessionProcessor.create({
+              assistantMessage: await Session.updateMessage({
+                id: Identifier.ascending("message"),
+                parentID: lastUser.id,
+                role: "assistant",
+                mode: agent.name,
+                agent: agent.name,
+                variant: lastUser.variant,
+                path: {
+                  cwd: Instance.directory,
+                  root: Instance.worktree
+                },
+                cost: 0,
+                tokens: {
+                  input: 0,
+                  output: 0,
+                  reasoning: 0,
+                  cache: { read: 0, write: 0 }
+                },
+                modelID: model2.id,
+                providerID: model2.providerID,
+                time: {
+                  created: Date.now()
+                },
+                sessionID
+              }),
               sessionID,
-              agent: lastUser.agent,
-              model: lastUser.model,
-              auto: true
-            });
-            continue;
-          }
-          const agent = await Agent.get(lastUser.agent);
-          const maxSteps = agent.steps ?? Infinity;
-          const isLastStep = step >= maxSteps;
-          msgs = await insertReminders({
-            messages: msgs,
-            agent,
-            session
-          });
-          const processor = SessionProcessor.create({
-            assistantMessage: await Session.updateMessage({
-              id: Identifier.ascending("message"),
-              parentID: lastUser.id,
-              role: "assistant",
-              mode: agent.name,
-              agent: agent.name,
-              variant: lastUser.variant,
-              path: {
-                cwd: Instance.directory,
-                root: Instance.worktree
-              },
-              cost: 0,
-              tokens: {
-                input: 0,
-                output: 0,
-                reasoning: 0,
-                cache: { read: 0, write: 0 }
-              },
-              modelID: model2.id,
-              providerID: model2.providerID,
-              time: {
-                created: Date.now()
-              },
-              sessionID
-            }),
-            sessionID,
-            model: model2,
-            abort: abort2
-          });
-          using _3 = defer(() => InstructionPrompt.clear(processor.message.id));
-          const lastUserMsg = current2 ? msgs.find((m5) => m5.info.role === "user" && m5.info.id === current2) : msgs.findLast((m5) => m5.info.role === "user");
-          const bypassAgentCheck = lastUserMsg?.parts.some((p4) => p4.type === "agent") ?? false;
-          const tools = await resolveTools({
-            agent,
-            session,
-            model: model2,
-            tools: lastUser.tools,
-            processor,
-            bypassAgentCheck,
-            messages: msgs
-          });
-          if (lastUser.format?.type === "json_schema") {
-            tools["StructuredOutput"] = createStructuredOutputTool({
-              schema: lastUser.format.schema,
-              onSuccess(output2) {
-                structuredOutput = output2;
-              }
+              model: model2,
+              abort: abort2
             });
-          }
-          if (step === 1) {
-            SessionSummary.summarize({
-              sessionID,
-              messageID: lastUser.id
-            }).catch((error46) => {
-              log12.error("failed to summarize session", { sessionID, error: error46 });
+            const _3 = __using(__stack, defer(() => InstructionPrompt.clear(processor.message.id)), 0);
+            const lastUserMsg = current2 ? msgs.find((m5) => m5.info.role === "user" && m5.info.id === current2) : msgs.findLast((m5) => m5.info.role === "user");
+            const bypassAgentCheck = lastUserMsg?.parts.some((p4) => p4.type === "agent") ?? false;
+            const tools = await resolveTools({
+              agent,
+              session,
+              model: model2,
+              tools: lastUser.tools,
+              processor,
+              bypassAgentCheck,
+              messages: msgs
             });
-          }
-          if (mode2 === "injection" && step > 1 && lastFinished) {
-            for (const msg of msgs) {
-              if (msg.info.role !== "user" || msg.info.id <= lastFinished.id)
-                continue;
-              for (const part of msg.parts) {
-                if (part.type !== "text" || part.ignored || part.synthetic)
-                  continue;
-                if (!part.text.trim())
+            if (lastUser.format?.type === "json_schema") {
+              tools["StructuredOutput"] = createStructuredOutputTool({
+                schema: lastUser.format.schema,
+                onSuccess(output2) {
+                  structuredOutput = output2;
+                }
+              });
+            }
+            if (step === 1) {
+              SessionSummary.summarize({
+                sessionID,
+                messageID: lastUser.id
+              }).catch((error46) => {
+                log12.error("failed to summarize session", { sessionID, error: error46 });
+              });
+            }
+            if (mode2 === "injection" && step > 1 && lastFinished) {
+              for (const msg of msgs) {
+                if (msg.info.role !== "user" || msg.info.id <= lastFinished.id)
                   continue;
-                part.text = [
-                  "<system-reminder>",
-                  "The user sent the following message:",
-                  part.text,
-                  "",
-                  "Please address this message and continue with your tasks.",
-                  "</system-reminder>"
-                ].join(`
+                for (const part of msg.parts) {
+                  if (part.type !== "text" || part.ignored || part.synthetic)
+                    continue;
+                  if (!part.text.trim())
+                    continue;
+                  part.text = [
+                    "<system-reminder>",
+                    "The user sent the following message:",
+                    part.text,
+                    "",
+                    "Please address this message and continue with your tasks.",
+                    "</system-reminder>"
+                  ].join(`
 `);
+                }
               }
             }
-          }
-          await Plugin.trigger("experimental.chat.messages.transform", {}, { messages: msgs });
-          const system = [...await SystemPrompt.environment(model2), ...await InstructionPrompt.system()];
-          const format10 = lastUser.format ?? { type: "text" };
-          if (format10.type === "json_schema") {
-            system.push(STRUCTURED_OUTPUT_SYSTEM_PROMPT);
-          }
-          const result6 = await processor.process({
-            user: lastUser,
-            agent,
-            abort: abort2,
-            sessionID,
-            system,
-            messages: [
-              ...MessageV2.toModelMessages(msgs, model2),
-              ...isLastStep ? [
-                {
-                  role: "assistant",
-                  content: max_steps_default
-                }
-              ] : []
-            ],
-            tools,
-            model: model2,
-            toolChoice: format10.type === "json_schema" ? "required" : undefined
-          });
-          if (structuredOutput !== undefined) {
-            processor.message.structured = structuredOutput;
-            processor.message.finish = processor.message.finish ?? "stop";
-            await Session.updateMessage(processor.message);
-            break;
-          }
-          const modelFinished = processor.message.finish && !["tool-calls", "unknown"].includes(processor.message.finish);
-          if (modelFinished && !processor.message.error) {
+            await Plugin.trigger("experimental.chat.messages.transform", {}, { messages: msgs });
+            const system = [...await SystemPrompt.environment(model2), ...await InstructionPrompt.system()];
+            const format10 = lastUser.format ?? { type: "text" };
             if (format10.type === "json_schema") {
-              processor.message.error = new MessageV2.StructuredOutputError({
-                message: "Model did not produce structured output",
-                retries: 0
-              }).toObject();
-              await Session.updateMessage(processor.message);
-              break;
+              system.push(STRUCTURED_OUTPUT_SYSTEM_PROMPT);
             }
-          }
-          if (held(state4()[sessionID], lastUser?.id)) {
-            next4 = "hold";
-            return;
-          }
-          if (result6 === "stop")
-            break;
-          if (result6 === "compact") {
-            await SessionCompaction.create({
+            const result6 = await processor.process({
+              user: lastUser,
+              agent,
+              abort: abort2,
               sessionID,
-              agent: lastUser.agent,
-              model: lastUser.model,
-              auto: true,
-              overflow: !processor.message.finish
+              system,
+              messages: [
+                ...MessageV2.toModelMessages(msgs, model2),
+                ...isLastStep ? [
+                  {
+                    role: "assistant",
+                    content: max_steps_default
+                  }
+                ] : []
+              ],
+              tools,
+              model: model2,
+              toolChoice: format10.type === "json_schema" ? "required" : undefined
             });
+            if (structuredOutput !== undefined) {
+              processor.message.structured = structuredOutput;
+              processor.message.finish = processor.message.finish ?? "stop";
+              await Session.updateMessage(processor.message);
+              break;
+            }
+            const modelFinished = processor.message.finish && !["tool-calls", "unknown"].includes(processor.message.finish);
+            if (modelFinished && !processor.message.error) {
+              if (format10.type === "json_schema") {
+                processor.message.error = new MessageV2.StructuredOutputError({
+                  message: "Model did not produce structured output",
+                  retries: 0
+                }).toObject();
+                await Session.updateMessage(processor.message);
+                break;
+              }
+            }
+            if (held(state4()[sessionID], lastUser?.id)) {
+              next4 = "hold";
+              return;
+            }
+            if (result6 === "stop")
+              break;
+            if (result6 === "compact") {
+              await SessionCompaction.create({
+                sessionID,
+                agent: lastUser.agent,
+                model: lastUser.model,
+                auto: true,
+                overflow: !processor.message.finish
+              });
+            }
+            continue;
+          } catch (_catch3) {
+            var _err = _catch3, _hasErr = 1;
+          } finally {
+            __callDispose(__stack, _err, _hasErr);
           }
-          continue;
         }
         SessionCompaction.prune({ sessionID });
         const item = await latestAssistant(sessionID);
@@ -188577,155 +188666,162 @@ var init_prompt = __esm(async () => {
       });
     }
     async function resolveTools(input) {
-      using _3 = log12.time("resolveTools");
-      const tools = {};
-      const context5 = (args3, options2) => ({
-        sessionID: input.session.id,
-        abort: options2.abortSignal,
-        messageID: input.processor.message.id,
-        callID: options2.toolCallId,
-        extra: { model: input.model, bypassAgentCheck: input.bypassAgentCheck },
-        agent: input.agent.name,
-        messages: input.messages,
-        metadata: async (val) => {
-          const match17 = input.processor.partFromToolCall(options2.toolCallId);
-          if (match17 && match17.state.status === "running") {
-            await Session.updatePart({
-              ...match17,
-              state: {
-                title: val.title,
-                metadata: val.metadata,
-                status: "running",
-                input: args3,
-                time: {
-                  start: Date.now()
+      let __stack = [];
+      try {
+        const _3 = __using(__stack, log12.time("resolveTools"), 0);
+        const tools = {};
+        const context5 = (args3, options2) => ({
+          sessionID: input.session.id,
+          abort: options2.abortSignal,
+          messageID: input.processor.message.id,
+          callID: options2.toolCallId,
+          extra: { model: input.model, bypassAgentCheck: input.bypassAgentCheck },
+          agent: input.agent.name,
+          messages: input.messages,
+          metadata: async (val) => {
+            const match17 = input.processor.partFromToolCall(options2.toolCallId);
+            if (match17 && match17.state.status === "running") {
+              await Session.updatePart({
+                ...match17,
+                state: {
+                  title: val.title,
+                  metadata: val.metadata,
+                  status: "running",
+                  input: args3,
+                  time: {
+                    start: Date.now()
+                  }
                 }
-              }
+              });
+            }
+          },
+          async ask(req) {
+            await PermissionNext.ask({
+              ...req,
+              sessionID: input.session.id,
+              tool: { messageID: input.processor.message.id, callID: options2.toolCallId },
+              ruleset: PermissionNext.merge(input.agent.permission, input.session.permission ?? [])
             });
           }
-        },
-        async ask(req) {
-          await PermissionNext.ask({
-            ...req,
-            sessionID: input.session.id,
-            tool: { messageID: input.processor.message.id, callID: options2.toolCallId },
-            ruleset: PermissionNext.merge(input.agent.permission, input.session.permission ?? [])
+        });
+        for (const item of await ToolRegistry.tools({ modelID: input.model.api.id, providerID: input.model.providerID }, input.agent)) {
+          const schema4 = ProviderTransform.schema(input.model, zod_default.toJSONSchema(item.parameters));
+          tools[item.id] = tool({
+            id: item.id,
+            description: item.description,
+            inputSchema: jsonSchema(schema4),
+            async execute(args3, options2) {
+              const ctx = context5(args3, options2);
+              await abortable(Plugin.trigger("tool.execute.before", {
+                tool: item.id,
+                sessionID: ctx.sessionID,
+                callID: ctx.callID
+              }, {
+                args: args3
+              }), ctx.abort);
+              const result6 = await abortable(item.execute(args3, ctx), ctx.abort);
+              const output2 = {
+                ...result6,
+                attachments: result6.attachments?.map((attachment) => ({
+                  ...attachment,
+                  id: Identifier.ascending("part"),
+                  sessionID: ctx.sessionID,
+                  messageID: input.processor.message.id
+                }))
+              };
+              await abortable(Plugin.trigger("tool.execute.after", {
+                tool: item.id,
+                sessionID: ctx.sessionID,
+                callID: ctx.callID,
+                args: args3
+              }, output2), ctx.abort);
+              return output2;
+            }
           });
         }
-      });
-      for (const item of await ToolRegistry.tools({ modelID: input.model.api.id, providerID: input.model.providerID }, input.agent)) {
-        const schema4 = ProviderTransform.schema(input.model, zod_default.toJSONSchema(item.parameters));
-        tools[item.id] = tool({
-          id: item.id,
-          description: item.description,
-          inputSchema: jsonSchema(schema4),
-          async execute(args3, options2) {
-            const ctx = context5(args3, options2);
+        for (const [key, item] of Object.entries(await MCP.tools())) {
+          const execute = item.execute;
+          if (!execute)
+            continue;
+          const transformed = ProviderTransform.schema(input.model, asSchema(item.inputSchema).jsonSchema);
+          item.inputSchema = jsonSchema(transformed);
+          item.execute = async (args3, opts) => {
+            const ctx = context5(args3, opts);
             await abortable(Plugin.trigger("tool.execute.before", {
-              tool: item.id,
+              tool: key,
               sessionID: ctx.sessionID,
-              callID: ctx.callID
+              callID: opts.toolCallId
             }, {
               args: args3
             }), ctx.abort);
-            const result6 = await abortable(item.execute(args3, ctx), ctx.abort);
-            const output2 = {
-              ...result6,
-              attachments: result6.attachments?.map((attachment) => ({
-                ...attachment,
-                id: Identifier.ascending("part"),
-                sessionID: ctx.sessionID,
-                messageID: input.processor.message.id
-              }))
-            };
+            await ctx.ask({
+              permission: key,
+              metadata: {},
+              patterns: ["*"],
+              always: ["*"]
+            });
+            const result6 = await abortable(execute(args3, opts), ctx.abort);
             await abortable(Plugin.trigger("tool.execute.after", {
-              tool: item.id,
+              tool: key,
               sessionID: ctx.sessionID,
-              callID: ctx.callID,
+              callID: opts.toolCallId,
               args: args3
-            }, output2), ctx.abort);
-            return output2;
-          }
-        });
-      }
-      for (const [key, item] of Object.entries(await MCP.tools())) {
-        const execute = item.execute;
-        if (!execute)
-          continue;
-        const transformed = ProviderTransform.schema(input.model, asSchema(item.inputSchema).jsonSchema);
-        item.inputSchema = jsonSchema(transformed);
-        item.execute = async (args3, opts) => {
-          const ctx = context5(args3, opts);
-          await abortable(Plugin.trigger("tool.execute.before", {
-            tool: key,
-            sessionID: ctx.sessionID,
-            callID: opts.toolCallId
-          }, {
-            args: args3
-          }), ctx.abort);
-          await ctx.ask({
-            permission: key,
-            metadata: {},
-            patterns: ["*"],
-            always: ["*"]
-          });
-          const result6 = await abortable(execute(args3, opts), ctx.abort);
-          await abortable(Plugin.trigger("tool.execute.after", {
-            tool: key,
-            sessionID: ctx.sessionID,
-            callID: opts.toolCallId,
-            args: args3
-          }, result6), ctx.abort);
-          const textParts = [];
-          const attachments = [];
-          for (const contentItem of result6.content) {
-            if (contentItem.type === "text") {
-              textParts.push(contentItem.text);
-            } else if (contentItem.type === "image") {
-              attachments.push({
-                type: "file",
-                mime: contentItem.mimeType,
-                url: `data:${contentItem.mimeType};base64,${contentItem.data}`
-              });
-            } else if (contentItem.type === "resource") {
-              const { resource } = contentItem;
-              if (resource.text) {
-                textParts.push(resource.text);
-              }
-              if (resource.blob) {
+            }, result6), ctx.abort);
+            const textParts = [];
+            const attachments = [];
+            for (const contentItem of result6.content) {
+              if (contentItem.type === "text") {
+                textParts.push(contentItem.text);
+              } else if (contentItem.type === "image") {
                 attachments.push({
                   type: "file",
-                  mime: resource.mimeType ?? "application/octet-stream",
-                  url: `data:${resource.mimeType ?? "application/octet-stream"};base64,${resource.blob}`,
-                  filename: resource.uri
+                  mime: contentItem.mimeType,
+                  url: `data:${contentItem.mimeType};base64,${contentItem.data}`
                 });
+              } else if (contentItem.type === "resource") {
+                const { resource } = contentItem;
+                if (resource.text) {
+                  textParts.push(resource.text);
+                }
+                if (resource.blob) {
+                  attachments.push({
+                    type: "file",
+                    mime: resource.mimeType ?? "application/octet-stream",
+                    url: `data:${resource.mimeType ?? "application/octet-stream"};base64,${resource.blob}`,
+                    filename: resource.uri
+                  });
+                }
               }
             }
-          }
-          const truncated = await Truncate.output(textParts.join(`
+            const truncated = await Truncate.output(textParts.join(`
 
 `), {}, input.agent);
-          const metadata2 = {
-            ...result6.metadata ?? {},
-            truncated: truncated.truncated,
-            ...truncated.truncated && { outputPath: truncated.outputPath }
-          };
-          return {
-            title: "",
-            metadata: metadata2,
-            output: truncated.content,
-            attachments: attachments.map((attachment) => ({
-              ...attachment,
-              id: Identifier.ascending("part"),
-              sessionID: ctx.sessionID,
-              messageID: input.processor.message.id
-            })),
-            content: result6.content
+            const metadata2 = {
+              ...result6.metadata ?? {},
+              truncated: truncated.truncated,
+              ...truncated.truncated && { outputPath: truncated.outputPath }
+            };
+            return {
+              title: "",
+              metadata: metadata2,
+              output: truncated.content,
+              attachments: attachments.map((attachment) => ({
+                ...attachment,
+                id: Identifier.ascending("part"),
+                sessionID: ctx.sessionID,
+                messageID: input.processor.message.id
+              })),
+              content: result6.content
+            };
           };
-        };
-        tools[key] = item;
+          tools[key] = item;
+        }
+        return tools;
+      } catch (_catch3) {
+        var _err = _catch3, _hasErr = 1;
+      } finally {
+        __callDispose(__stack, _err, _hasErr);
       }
-      return tools;
     }
     SessionPrompt.resolveTools = resolveTools;
     function createStructuredOutputTool(input) {
@@ -188752,321 +188848,328 @@ var init_prompt = __esm(async () => {
     }
     SessionPrompt.createStructuredOutputTool = createStructuredOutputTool;
     async function createUserMessage(input) {
-      const agent = await Agent.get(input.agent ?? await Agent.defaultAgent());
-      const model2 = input.model ?? agent.model ?? await lastModel(input.sessionID);
-      const full = !input.variant && agent.variant ? await Provider2.getModel(model2.providerID, model2.modelID).catch(() => {
-        return;
-      }) : undefined;
-      const variant = input.variant ?? (agent.variant && full?.variants?.[agent.variant] ? agent.variant : undefined);
-      const info4 = {
-        id: input.messageID ?? Identifier.ascending("message"),
-        role: "user",
-        sessionID: input.sessionID,
-        time: {
-          created: Date.now()
-        },
-        tools: input.tools,
-        agent: agent.name,
-        model: model2,
-        system: input.system,
-        format: input.format,
-        variant
-      };
-      using _3 = defer(() => InstructionPrompt.clear(info4.id));
-      const assign2 = (part) => ({
-        ...part,
-        id: part.id ?? Identifier.ascending("part")
-      });
-      const parts3 = await Promise.all(input.parts.map(async (part) => {
-        if (part.type === "file") {
-          if (part.source?.type === "resource") {
-            const { clientName, uri } = part.source;
-            log12.info("mcp resource", { clientName, uri, mime: part.mime });
-            const pieces = [
-              {
-                messageID: info4.id,
-                sessionID: input.sessionID,
-                type: "text",
-                synthetic: true,
-                text: `Reading MCP resource: ${part.filename} (${uri})`
-              }
-            ];
-            try {
-              const resourceContent = await MCP.readResource(clientName, uri);
-              if (!resourceContent) {
-                throw new Error(`Resource not found: ${clientName}/${uri}`);
-              }
-              const contents = Array.isArray(resourceContent.contents) ? resourceContent.contents : [resourceContent.contents];
-              for (const content of contents) {
-                if ("text" in content && content.text) {
-                  pieces.push({
-                    messageID: info4.id,
-                    sessionID: input.sessionID,
-                    type: "text",
-                    synthetic: true,
-                    text: content.text
-                  });
-                } else if ("blob" in content && content.blob) {
-                  const mimeType = "mimeType" in content ? content.mimeType : part.mime;
-                  pieces.push({
-                    messageID: info4.id,
-                    sessionID: input.sessionID,
-                    type: "text",
-                    synthetic: true,
-                    text: `[Binary content: ${mimeType}]`
-                  });
+      let __stack = [];
+      try {
+        const agent = await Agent.get(input.agent ?? await Agent.defaultAgent());
+        const model2 = input.model ?? agent.model ?? await lastModel(input.sessionID);
+        const full = !input.variant && agent.variant ? await Provider2.getModel(model2.providerID, model2.modelID).catch(() => {
+          return;
+        }) : undefined;
+        const variant = input.variant ?? (agent.variant && full?.variants?.[agent.variant] ? agent.variant : undefined);
+        const info4 = {
+          id: input.messageID ?? Identifier.ascending("message"),
+          role: "user",
+          sessionID: input.sessionID,
+          time: {
+            created: Date.now()
+          },
+          tools: input.tools,
+          agent: agent.name,
+          model: model2,
+          system: input.system,
+          format: input.format,
+          variant
+        };
+        const _3 = __using(__stack, defer(() => InstructionPrompt.clear(info4.id)), 0);
+        const assign2 = (part) => ({
+          ...part,
+          id: part.id ?? Identifier.ascending("part")
+        });
+        const parts3 = await Promise.all(input.parts.map(async (part) => {
+          if (part.type === "file") {
+            if (part.source?.type === "resource") {
+              const { clientName, uri } = part.source;
+              log12.info("mcp resource", { clientName, uri, mime: part.mime });
+              const pieces = [
+                {
+                  messageID: info4.id,
+                  sessionID: input.sessionID,
+                  type: "text",
+                  synthetic: true,
+                  text: `Reading MCP resource: ${part.filename} (${uri})`
                 }
-              }
-              pieces.push({
-                ...part,
-                messageID: info4.id,
-                sessionID: input.sessionID
-              });
-            } catch (error46) {
-              log12.error("failed to read MCP resource", { error: error46, clientName, uri });
-              const message = error46 instanceof Error ? error46.message : String(error46);
-              pieces.push({
-                messageID: info4.id,
-                sessionID: input.sessionID,
-                type: "text",
-                synthetic: true,
-                text: `Failed to read MCP resource ${part.filename}: ${message}`
-              });
-            }
-            return pieces;
-          }
-          const url4 = new URL(part.url);
-          switch (url4.protocol) {
-            case "data:":
-              if (part.mime === "text/plain") {
-                return [
-                  {
-                    messageID: info4.id,
-                    sessionID: input.sessionID,
-                    type: "text",
-                    synthetic: true,
-                    text: `Called the Read tool with the following input: ${JSON.stringify({ filePath: part.filename })}`
-                  },
-                  {
-                    messageID: info4.id,
-                    sessionID: input.sessionID,
-                    type: "text",
-                    synthetic: true,
-                    text: Buffer.from(part.url, "base64url").toString()
-                  },
-                  {
-                    ...part,
-                    messageID: info4.id,
-                    sessionID: input.sessionID
+              ];
+              try {
+                const resourceContent = await MCP.readResource(clientName, uri);
+                if (!resourceContent) {
+                  throw new Error(`Resource not found: ${clientName}/${uri}`);
+                }
+                const contents = Array.isArray(resourceContent.contents) ? resourceContent.contents : [resourceContent.contents];
+                for (const content of contents) {
+                  if ("text" in content && content.text) {
+                    pieces.push({
+                      messageID: info4.id,
+                      sessionID: input.sessionID,
+                      type: "text",
+                      synthetic: true,
+                      text: content.text
+                    });
+                  } else if ("blob" in content && content.blob) {
+                    const mimeType = "mimeType" in content ? content.mimeType : part.mime;
+                    pieces.push({
+                      messageID: info4.id,
+                      sessionID: input.sessionID,
+                      type: "text",
+                      synthetic: true,
+                      text: `[Binary content: ${mimeType}]`
+                    });
                   }
-                ];
-              }
-              break;
-            case "file:":
-              log12.info("file", { mime: part.mime });
-              const filepath = fileURLToPath7(part.url);
-              const s6 = Filesystem.stat(filepath);
-              if (s6?.isDirectory()) {
-                part.mime = "application/x-directory";
+                }
+                pieces.push({
+                  ...part,
+                  messageID: info4.id,
+                  sessionID: input.sessionID
+                });
+              } catch (error46) {
+                log12.error("failed to read MCP resource", { error: error46, clientName, uri });
+                const message = error46 instanceof Error ? error46.message : String(error46);
+                pieces.push({
+                  messageID: info4.id,
+                  sessionID: input.sessionID,
+                  type: "text",
+                  synthetic: true,
+                  text: `Failed to read MCP resource ${part.filename}: ${message}`
+                });
               }
-              if (part.mime === "text/plain") {
-                let offset = undefined;
-                let limit = undefined;
-                const range6 = {
-                  start: url4.searchParams.get("start"),
-                  end: url4.searchParams.get("end")
-                };
-                if (range6.start != null) {
-                  const filePathURI = part.url.split("?")[0];
-                  let start4 = parseInt(range6.start);
-                  let end4 = range6.end ? parseInt(range6.end) : undefined;
-                  if (start4 === end4) {
-                    const symbols = await LSP.documentSymbol(filePathURI).catch(() => []);
-                    for (const symbol16 of symbols) {
-                      let range7;
-                      if ("range" in symbol16) {
-                        range7 = symbol16.range;
-                      } else if ("location" in symbol16) {
-                        range7 = symbol16.location.range;
-                      }
-                      if (range7?.start?.line && range7?.start?.line === start4) {
-                        start4 = range7.start.line;
-                        end4 = range7?.end?.line ?? start4;
-                        break;
+              return pieces;
+            }
+            const url4 = new URL(part.url);
+            switch (url4.protocol) {
+              case "data:":
+                if (part.mime === "text/plain") {
+                  return [
+                    {
+                      messageID: info4.id,
+                      sessionID: input.sessionID,
+                      type: "text",
+                      synthetic: true,
+                      text: `Called the Read tool with the following input: ${JSON.stringify({ filePath: part.filename })}`
+                    },
+                    {
+                      messageID: info4.id,
+                      sessionID: input.sessionID,
+                      type: "text",
+                      synthetic: true,
+                      text: Buffer.from(part.url, "base64url").toString()
+                    },
+                    {
+                      ...part,
+                      messageID: info4.id,
+                      sessionID: input.sessionID
+                    }
+                  ];
+                }
+                break;
+              case "file:":
+                log12.info("file", { mime: part.mime });
+                const filepath = fileURLToPath7(part.url);
+                const s6 = Filesystem.stat(filepath);
+                if (s6?.isDirectory()) {
+                  part.mime = "application/x-directory";
+                }
+                if (part.mime === "text/plain") {
+                  let offset = undefined;
+                  let limit = undefined;
+                  const range6 = {
+                    start: url4.searchParams.get("start"),
+                    end: url4.searchParams.get("end")
+                  };
+                  if (range6.start != null) {
+                    const filePathURI = part.url.split("?")[0];
+                    let start4 = parseInt(range6.start);
+                    let end4 = range6.end ? parseInt(range6.end) : undefined;
+                    if (start4 === end4) {
+                      const symbols = await LSP.documentSymbol(filePathURI).catch(() => []);
+                      for (const symbol16 of symbols) {
+                        let range7;
+                        if ("range" in symbol16) {
+                          range7 = symbol16.range;
+                        } else if ("location" in symbol16) {
+                          range7 = symbol16.location.range;
+                        }
+                        if (range7?.start?.line && range7?.start?.line === start4) {
+                          start4 = range7.start.line;
+                          end4 = range7?.end?.line ?? start4;
+                          break;
+                        }
                       }
                     }
+                    offset = Math.max(start4, 1);
+                    if (end4) {
+                      limit = end4 - (offset - 1);
+                    }
                   }
-                  offset = Math.max(start4, 1);
-                  if (end4) {
-                    limit = end4 - (offset - 1);
-                  }
+                  const args3 = { filePath: filepath, offset, limit };
+                  const pieces = [
+                    {
+                      messageID: info4.id,
+                      sessionID: input.sessionID,
+                      type: "text",
+                      synthetic: true,
+                      text: `Called the Read tool with the following input: ${JSON.stringify(args3)}`
+                    }
+                  ];
+                  await ReadTool.init().then(async (t3) => {
+                    const model3 = await Provider2.getModel(info4.model.providerID, info4.model.modelID);
+                    const readCtx = {
+                      sessionID: input.sessionID,
+                      abort: new AbortController().signal,
+                      agent: input.agent,
+                      messageID: info4.id,
+                      extra: { bypassCwdCheck: true, model: model3 },
+                      messages: [],
+                      metadata: async () => {},
+                      ask: async () => {}
+                    };
+                    const result6 = await t3.execute(args3, readCtx);
+                    pieces.push({
+                      messageID: info4.id,
+                      sessionID: input.sessionID,
+                      type: "text",
+                      synthetic: true,
+                      text: result6.output
+                    });
+                    if (result6.attachments?.length) {
+                      pieces.push(...result6.attachments.map((attachment) => ({
+                        ...attachment,
+                        synthetic: true,
+                        filename: attachment.filename ?? part.filename,
+                        messageID: info4.id,
+                        sessionID: input.sessionID
+                      })));
+                    } else {
+                      pieces.push({
+                        ...part,
+                        messageID: info4.id,
+                        sessionID: input.sessionID
+                      });
+                    }
+                  }).catch((error46) => {
+                    log12.error("failed to read file", { error: error46 });
+                    const message = error46 instanceof Error ? error46.message : error46.toString();
+                    Bus.publish(Session.Event.Error, {
+                      sessionID: input.sessionID,
+                      error: new NamedError.Unknown({
+                        message
+                      }).toObject(),
+                      viewID: Instance.viewID
+                    });
+                    pieces.push({
+                      messageID: info4.id,
+                      sessionID: input.sessionID,
+                      type: "text",
+                      synthetic: true,
+                      text: `Read tool failed to read ${filepath} with the following error: ${message}`
+                    });
+                  });
+                  return pieces;
                 }
-                const args3 = { filePath: filepath, offset, limit };
-                const pieces = [
-                  {
-                    messageID: info4.id,
-                    sessionID: input.sessionID,
-                    type: "text",
-                    synthetic: true,
-                    text: `Called the Read tool with the following input: ${JSON.stringify(args3)}`
-                  }
-                ];
-                await ReadTool.init().then(async (t3) => {
-                  const model3 = await Provider2.getModel(info4.model.providerID, info4.model.modelID);
-                  const readCtx = {
+                if (part.mime === "application/x-directory") {
+                  const args3 = { filePath: filepath };
+                  const listCtx = {
                     sessionID: input.sessionID,
                     abort: new AbortController().signal,
                     agent: input.agent,
                     messageID: info4.id,
-                    extra: { bypassCwdCheck: true, model: model3 },
+                    extra: { bypassCwdCheck: true },
                     messages: [],
                     metadata: async () => {},
                     ask: async () => {}
                   };
-                  const result6 = await t3.execute(args3, readCtx);
-                  pieces.push({
-                    messageID: info4.id,
-                    sessionID: input.sessionID,
-                    type: "text",
-                    synthetic: true,
-                    text: result6.output
-                  });
-                  if (result6.attachments?.length) {
-                    pieces.push(...result6.attachments.map((attachment) => ({
-                      ...attachment,
+                  const result6 = await ReadTool.init().then((t3) => t3.execute(args3, listCtx));
+                  return [
+                    {
+                      messageID: info4.id,
+                      sessionID: input.sessionID,
+                      type: "text",
                       synthetic: true,
-                      filename: attachment.filename ?? part.filename,
+                      text: `Called the Read tool with the following input: ${JSON.stringify(args3)}`
+                    },
+                    {
                       messageID: info4.id,
-                      sessionID: input.sessionID
-                    })));
-                  } else {
-                    pieces.push({
+                      sessionID: input.sessionID,
+                      type: "text",
+                      synthetic: true,
+                      text: result6.output
+                    },
+                    {
                       ...part,
                       messageID: info4.id,
                       sessionID: input.sessionID
-                    });
-                  }
-                }).catch((error46) => {
-                  log12.error("failed to read file", { error: error46 });
-                  const message = error46 instanceof Error ? error46.message : error46.toString();
-                  Bus.publish(Session.Event.Error, {
-                    sessionID: input.sessionID,
-                    error: new NamedError.Unknown({
-                      message
-                    }).toObject(),
-                    viewID: Instance.viewID
-                  });
-                  pieces.push({
-                    messageID: info4.id,
-                    sessionID: input.sessionID,
-                    type: "text",
-                    synthetic: true,
-                    text: `Read tool failed to read ${filepath} with the following error: ${message}`
-                  });
-                });
-                return pieces;
-              }
-              if (part.mime === "application/x-directory") {
-                const args3 = { filePath: filepath };
-                const listCtx = {
-                  sessionID: input.sessionID,
-                  abort: new AbortController().signal,
-                  agent: input.agent,
-                  messageID: info4.id,
-                  extra: { bypassCwdCheck: true },
-                  messages: [],
-                  metadata: async () => {},
-                  ask: async () => {}
-                };
-                const result6 = await ReadTool.init().then((t3) => t3.execute(args3, listCtx));
+                    }
+                  ];
+                }
+                FileTime.read(input.sessionID, filepath);
                 return [
                   {
                     messageID: info4.id,
                     sessionID: input.sessionID,
                     type: "text",
-                    synthetic: true,
-                    text: `Called the Read tool with the following input: ${JSON.stringify(args3)}`
+                    text: `Called the Read tool with the following input: {"filePath":"${filepath}"}`,
+                    synthetic: true
                   },
                   {
+                    id: part.id,
                     messageID: info4.id,
                     sessionID: input.sessionID,
-                    type: "text",
-                    synthetic: true,
-                    text: result6.output
-                  },
-                  {
-                    ...part,
-                    messageID: info4.id,
-                    sessionID: input.sessionID
+                    type: "file",
+                    url: `data:${part.mime};base64,` + (await Filesystem.readBytes(filepath)).toString("base64"),
+                    mime: part.mime,
+                    filename: part.filename,
+                    source: part.source
                   }
                 ];
+            }
+          }
+          if (part.type === "agent") {
+            const perm = PermissionNext.evaluate("task", part.name, agent.permission);
+            const hint = perm.action === "deny" ? " . Invoked by user; guaranteed to exist." : "";
+            return [
+              {
+                ...part,
+                messageID: info4.id,
+                sessionID: input.sessionID
+              },
+              {
+                messageID: info4.id,
+                sessionID: input.sessionID,
+                type: "text",
+                synthetic: true,
+                text: " Use the above message and context to generate a prompt and call the task tool with subagent: " + part.name + hint
               }
-              FileTime.read(input.sessionID, filepath);
-              return [
-                {
-                  messageID: info4.id,
-                  sessionID: input.sessionID,
-                  type: "text",
-                  text: `Called the Read tool with the following input: {"filePath":"${filepath}"}`,
-                  synthetic: true
-                },
-                {
-                  id: part.id,
-                  messageID: info4.id,
-                  sessionID: input.sessionID,
-                  type: "file",
-                  url: `data:${part.mime};base64,` + (await Filesystem.readBytes(filepath)).toString("base64"),
-                  mime: part.mime,
-                  filename: part.filename,
-                  source: part.source
-                }
-              ];
+            ];
           }
-        }
-        if (part.type === "agent") {
-          const perm = PermissionNext.evaluate("task", part.name, agent.permission);
-          const hint = perm.action === "deny" ? " . Invoked by user; guaranteed to exist." : "";
           return [
             {
               ...part,
               messageID: info4.id,
               sessionID: input.sessionID
-            },
-            {
-              messageID: info4.id,
-              sessionID: input.sessionID,
-              type: "text",
-              synthetic: true,
-              text: " Use the above message and context to generate a prompt and call the task tool with subagent: " + part.name + hint
             }
           ];
+        })).then((x3) => x3.flat().map(assign2));
+        await Plugin.trigger("chat.message", {
+          sessionID: input.sessionID,
+          agent: input.agent,
+          model: input.model,
+          messageID: input.messageID,
+          variant: input.variant
+        }, {
+          message: info4,
+          parts: parts3
+        });
+        await Session.updateMessage(info4);
+        for (const part of parts3) {
+          await Session.updatePart(part);
         }
-        return [
-          {
-            ...part,
-            messageID: info4.id,
-            sessionID: input.sessionID
-          }
-        ];
-      })).then((x3) => x3.flat().map(assign2));
-      await Plugin.trigger("chat.message", {
-        sessionID: input.sessionID,
-        agent: input.agent,
-        model: input.model,
-        messageID: input.messageID,
-        variant: input.variant
-      }, {
-        message: info4,
-        parts: parts3
-      });
-      await Session.updateMessage(info4);
-      for (const part of parts3) {
-        await Session.updatePart(part);
+        return {
+          info: info4,
+          parts: parts3
+        };
+      } catch (_catch3) {
+        var _err = _catch3, _hasErr = 1;
+      } finally {
+        __callDispose(__stack, _err, _hasErr);
       }
-      return {
-        info: info4,
-        parts: parts3
-      };
     }
     async function insertReminders(input) {
       const userMessage = input.messages.findLast((msg) => msg.info.role === "user");
@@ -189223,279 +189326,286 @@ NOTE: At any point in time through this workflow you should feel free to ask the
       command: zod_default.string()
     });
     async function shell(input) {
-      const abort2 = start3(input.sessionID);
-      if (!abort2) {
-        throw new Session.BusyError(input.sessionID);
-      }
-      using _3 = defer(() => {
-        const entry = state4()[input.sessionID];
-        const hasQueuedWork = !!entry && (entry.callbacks.length > 0 || entry.queued.length > 0);
-        if (!hasQueuedWork) {
-          cancel(input.sessionID);
-        } else {
-          SessionPrompt.loop({ sessionID: input.sessionID, resume_existing: true }).catch((error47) => {
-            log12.error("session loop failed to resume after shell command", { sessionID: input.sessionID, error: error47 });
-            cancel(input.sessionID, error47);
-          });
+      let __stack = [];
+      try {
+        const abort2 = start3(input.sessionID);
+        if (!abort2) {
+          throw new Session.BusyError(input.sessionID);
+        }
+        const _3 = __using(__stack, defer(() => {
+          const entry = state4()[input.sessionID];
+          const hasQueuedWork = !!entry && (entry.callbacks.length > 0 || entry.queued.length > 0);
+          if (!hasQueuedWork) {
+            cancel(input.sessionID);
+          } else {
+            SessionPrompt.loop({ sessionID: input.sessionID, resume_existing: true }).catch((error47) => {
+              log12.error("session loop failed to resume after shell command", { sessionID: input.sessionID, error: error47 });
+              cancel(input.sessionID, error47);
+            });
+          }
+        }), 0);
+        const session = await Session.get(input.sessionID);
+        if (session.revert) {
+          await SessionRevert.cleanup(session);
         }
-      });
-      const session = await Session.get(input.sessionID);
-      if (session.revert) {
-        await SessionRevert.cleanup(session);
-      }
-      const agent = await Agent.get(input.agent);
-      const model2 = input.model ?? agent.model ?? await lastModel(input.sessionID);
-      const userMsg = {
-        id: Identifier.ascending("message"),
-        sessionID: input.sessionID,
-        time: {
-          created: Date.now()
-        },
-        role: "user",
-        agent: input.agent,
-        model: {
+        const agent = await Agent.get(input.agent);
+        const model2 = input.model ?? agent.model ?? await lastModel(input.sessionID);
+        const userMsg = {
+          id: Identifier.ascending("message"),
+          sessionID: input.sessionID,
+          time: {
+            created: Date.now()
+          },
+          role: "user",
+          agent: input.agent,
+          model: {
+            providerID: model2.providerID,
+            modelID: model2.modelID
+          }
+        };
+        await Session.updateMessage(userMsg);
+        const userPart = {
+          type: "text",
+          id: Identifier.ascending("part"),
+          messageID: userMsg.id,
+          sessionID: input.sessionID,
+          text: "The following tool was executed by the user",
+          synthetic: true
+        };
+        await Session.updatePart(userPart);
+        queueTitle({
+          sessionID: input.sessionID,
           providerID: model2.providerID,
-          modelID: model2.modelID
-        }
-      };
-      await Session.updateMessage(userMsg);
-      const userPart = {
-        type: "text",
-        id: Identifier.ascending("part"),
-        messageID: userMsg.id,
-        sessionID: input.sessionID,
-        text: "The following tool was executed by the user",
-        synthetic: true
-      };
-      await Session.updatePart(userPart);
-      queueTitle({
-        sessionID: input.sessionID,
-        providerID: model2.providerID,
-        modelID: model2.modelID,
-        text: input.command
-      });
-      const msg = {
-        id: Identifier.ascending("message"),
-        sessionID: input.sessionID,
-        parentID: userMsg.id,
-        mode: input.agent,
-        agent: input.agent,
-        cost: 0,
-        path: {
-          cwd: Instance.directory,
-          root: Instance.worktree
-        },
-        time: {
-          created: Date.now()
-        },
-        role: "assistant",
-        tokens: {
-          input: 0,
-          output: 0,
-          reasoning: 0,
-          cache: { read: 0, write: 0 }
-        },
-        modelID: model2.modelID,
-        providerID: model2.providerID
-      };
-      await Session.updateMessage(msg);
-      const part = {
-        type: "tool",
-        id: Identifier.ascending("part"),
-        messageID: msg.id,
-        sessionID: input.sessionID,
-        tool: "bash",
-        callID: ulid4(),
-        state: {
-          status: "running",
+          modelID: model2.modelID,
+          text: input.command
+        });
+        const msg = {
+          id: Identifier.ascending("message"),
+          sessionID: input.sessionID,
+          parentID: userMsg.id,
+          mode: input.agent,
+          agent: input.agent,
+          cost: 0,
+          path: {
+            cwd: Instance.directory,
+            root: Instance.worktree
+          },
           time: {
-            start: Date.now()
+            created: Date.now()
           },
-          input: {
-            command: input.command
+          role: "assistant",
+          tokens: {
+            input: 0,
+            output: 0,
+            reasoning: 0,
+            cache: { read: 0, write: 0 }
+          },
+          modelID: model2.modelID,
+          providerID: model2.providerID
+        };
+        await Session.updateMessage(msg);
+        const part = {
+          type: "tool",
+          id: Identifier.ascending("part"),
+          messageID: msg.id,
+          sessionID: input.sessionID,
+          tool: "bash",
+          callID: ulid4(),
+          state: {
+            status: "running",
+            time: {
+              start: Date.now()
+            },
+            input: {
+              command: input.command
+            }
           }
-        }
-      };
-      await Session.updatePart(part);
-      const cfg = await Config.get();
-      const shell2 = Shell.preferred(cfg.shell?.program);
-      const shellName = Shell.name(shell2);
-      const invocations = {
-        nu: {
-          args: ["-c", input.command]
-        },
-        fish: {
-          args: ["-c", input.command]
-        },
-        zsh: {
-          args: [
-            "-c",
-            "-l",
-            `
+        };
+        await Session.updatePart(part);
+        const cfg = await Config.get();
+        const shell2 = Shell.preferred(cfg.shell?.program);
+        const shellName = Shell.name(shell2);
+        const invocations = {
+          nu: {
+            args: ["-c", input.command]
+          },
+          fish: {
+            args: ["-c", input.command]
+          },
+          zsh: {
+            args: [
+              "-c",
+              "-l",
+              `
             [[ -f ~/.zshenv ]] && source ~/.zshenv >/dev/null 2>&1 || true
             [[ -f "\${ZDOTDIR:-$HOME}/.zshrc" ]] && source "\${ZDOTDIR:-$HOME}/.zshrc" >/dev/null 2>&1 || true
             eval ${JSON.stringify(input.command)}
           `
-          ]
-        },
-        bash: {
-          args: [
-            "-c",
-            "-l",
-            `
+            ]
+          },
+          bash: {
+            args: [
+              "-c",
+              "-l",
+              `
             shopt -s expand_aliases
             [[ -f ~/.bashrc ]] && source ~/.bashrc >/dev/null 2>&1 || true
             eval ${JSON.stringify(input.command)}
           `
-          ]
-        },
-        cmd: {
-          args: ["/c", input.command]
-        },
-        powershell: {
-          args: ["-NoProfile", "-Command", input.command]
-        },
-        pwsh: {
-          args: ["-NoProfile", "-Command", input.command]
-        },
-        "": {
-          args: ["-c", `${input.command}`]
-        }
-      };
-      const matchingInvocation = invocations[shellName] ?? invocations[""];
-      const args3 = matchingInvocation?.args;
-      const cwd = Instance.directory;
-      const shellEnv = await Plugin.trigger("shell.env", { cwd, sessionID: input.sessionID, callID: part.callID }, { env: {} });
-      const proc = spawn6(shell2, args3, {
-        cwd,
-        detached: process.platform !== "win32",
-        stdio: ["ignore", "pipe", "pipe"],
-        env: {
-          ...Env.all({ sessionID: input.sessionID }),
-          ...shellEnv.env,
-          TERM: "dumb"
-        }
-      });
-      const timeout4 = cfg.shell?.timeout_ms ?? SHELL_TIMEOUT;
-      const decoder2 = new TextDecoder;
-      let output2 = "";
-      let clipped = 0;
-      const format10 = (notes2 = []) => {
-        const meta = [
-          ...clipped > 0 ? [`Output truncated after ${SHELL_OUTPUT_LIMIT} characters; ${clipped} additional characters omitted.`] : [],
-          ...notes2
-        ];
-        const suffix = meta.length ? `
+            ]
+          },
+          cmd: {
+            args: ["/c", input.command]
+          },
+          powershell: {
+            args: ["-NoProfile", "-Command", input.command]
+          },
+          pwsh: {
+            args: ["-NoProfile", "-Command", input.command]
+          },
+          "": {
+            args: ["-c", `${input.command}`]
+          }
+        };
+        const matchingInvocation = invocations[shellName] ?? invocations[""];
+        const args3 = matchingInvocation?.args;
+        const cwd = Instance.directory;
+        const shellEnv = await Plugin.trigger("shell.env", { cwd, sessionID: input.sessionID, callID: part.callID }, { env: {} });
+        const proc = spawn6(shell2, args3, {
+          cwd,
+          detached: process.platform !== "win32",
+          stdio: ["ignore", "pipe", "pipe"],
+          env: {
+            ...Env.all({ sessionID: input.sessionID }),
+            ...shellEnv.env,
+            TERM: "dumb"
+          }
+        });
+        const timeout4 = cfg.shell?.timeout_ms ?? SHELL_TIMEOUT;
+        const decoder2 = new TextDecoder;
+        let output2 = "";
+        let clipped = 0;
+        const format10 = (notes2 = []) => {
+          const meta = [
+            ...clipped > 0 ? [`Output truncated after ${SHELL_OUTPUT_LIMIT} characters; ${clipped} additional characters omitted.`] : [],
+            ...notes2
+          ];
+          const suffix = meta.length ? `
 
 <shell_metadata>
 ${meta.join(`
 `)}
 </shell_metadata>` : "";
-        const text12 = output2 + suffix;
-        if (text12.length <= SHELL_METADATA_LIMIT)
-          return text12;
-        return text12.slice(0, SHELL_METADATA_LIMIT) + `
+          const text12 = output2 + suffix;
+          if (text12.length <= SHELL_METADATA_LIMIT)
+            return text12;
+          return text12.slice(0, SHELL_METADATA_LIMIT) + `
 
 ...`;
-      };
-      const append7 = (chunk) => {
-        const text12 = typeof chunk === "string" ? chunk : decoder2.decode(chunk);
-        if (clipped > 0) {
-          clipped += text12.length;
-        } else {
-          const remaining2 = SHELL_OUTPUT_LIMIT - output2.length;
-          if (text12.length <= remaining2) {
-            output2 += text12;
+        };
+        const append7 = (chunk) => {
+          const text12 = typeof chunk === "string" ? chunk : decoder2.decode(chunk);
+          if (clipped > 0) {
+            clipped += text12.length;
           } else {
-            output2 += text12.slice(0, remaining2);
-            clipped += text12.length - remaining2;
+            const remaining2 = SHELL_OUTPUT_LIMIT - output2.length;
+            if (text12.length <= remaining2) {
+              output2 += text12;
+            } else {
+              output2 += text12.slice(0, remaining2);
+              clipped += text12.length - remaining2;
+            }
           }
-        }
-        if (part.state.status !== "running")
-          return;
-        part.state.metadata = {
-          output: format10(),
-          description: ""
+          if (part.state.status !== "running")
+            return;
+          part.state.metadata = {
+            output: format10(),
+            description: ""
+          };
+          Session.updatePart(part);
         };
-        Session.updatePart(part);
-      };
-      proc.stdout?.on("data", append7);
-      proc.stderr?.on("data", append7);
-      let timedOut = false;
-      let aborted3 = false;
-      let exited = false;
-      const kill = () => Shell.killTree(proc, { exited: () => exited });
-      if (abort2.aborted) {
-        aborted3 = true;
-        await kill();
-      }
-      const abortHandler = () => {
-        aborted3 = true;
-        kill();
-      };
-      const timeoutTimer = setTimeout(() => {
-        timedOut = true;
-        kill();
-      }, timeout4 + 100);
-      abort2.addEventListener("abort", abortHandler, { once: true });
-      const error46 = await new Promise((resolve10) => {
-        const cleanup = () => {
-          clearTimeout(timeoutTimer);
-          abort2.removeEventListener("abort", abortHandler);
-          proc.stdout?.off("data", append7);
-          proc.stderr?.off("data", append7);
+        proc.stdout?.on("data", append7);
+        proc.stderr?.on("data", append7);
+        let timedOut = false;
+        let aborted3 = false;
+        let exited = false;
+        const kill = () => Shell.killTree(proc, { exited: () => exited });
+        if (abort2.aborted) {
+          aborted3 = true;
+          await kill();
+        }
+        const abortHandler = () => {
+          aborted3 = true;
+          kill();
         };
-        proc.once("close", () => {
-          exited = true;
-          cleanup();
-          resolve10(undefined);
-        });
-        proc.once("error", (error47) => {
-          exited = true;
-          cleanup();
-          resolve10(error47);
+        const timeoutTimer = setTimeout(() => {
+          timedOut = true;
+          kill();
+        }, timeout4 + 100);
+        abort2.addEventListener("abort", abortHandler, { once: true });
+        const error46 = await new Promise((resolve10) => {
+          const cleanup = () => {
+            clearTimeout(timeoutTimer);
+            abort2.removeEventListener("abort", abortHandler);
+            proc.stdout?.off("data", append7);
+            proc.stderr?.off("data", append7);
+          };
+          proc.once("close", () => {
+            exited = true;
+            cleanup();
+            resolve10(undefined);
+          });
+          proc.once("error", (error47) => {
+            exited = true;
+            cleanup();
+            resolve10(error47);
+          });
         });
-      });
-      msg.time.completed = Date.now();
-      await Session.updateMessage(msg);
-      if (error46) {
+        msg.time.completed = Date.now();
+        await Session.updateMessage(msg);
+        if (error46) {
+          if (part.state.status === "running") {
+            part.state = {
+              status: "error",
+              input: part.state.input,
+              error: error46.toString(),
+              time: {
+                ...part.state.time,
+                end: Date.now()
+              }
+            };
+            await Session.updatePart(part);
+          }
+          throw error46;
+        }
+        const notes = [
+          ...timedOut ? [`shell command terminated after exceeding timeout ${timeout4} ms`] : [],
+          ...aborted3 ? ["User aborted the command"] : []
+        ];
+        const text11 = format10(notes);
         if (part.state.status === "running") {
           part.state = {
-            status: "error",
-            input: part.state.input,
-            error: error46.toString(),
+            status: "completed",
             time: {
               ...part.state.time,
               end: Date.now()
-            }
+            },
+            input: part.state.input,
+            title: "",
+            metadata: {
+              output: text11,
+              description: ""
+            },
+            output: text11
           };
           await Session.updatePart(part);
         }
-        throw error46;
-      }
-      const notes = [
-        ...timedOut ? [`shell command terminated after exceeding timeout ${timeout4} ms`] : [],
-        ...aborted3 ? ["User aborted the command"] : []
-      ];
-      const text11 = format10(notes);
-      if (part.state.status === "running") {
-        part.state = {
-          status: "completed",
-          time: {
-            ...part.state.time,
-            end: Date.now()
-          },
-          input: part.state.input,
-          title: "",
-          metadata: {
-            output: text11,
-            description: ""
-          },
-          output: text11
-        };
-        await Session.updatePart(part);
+        return { info: msg, parts: [part] };
+      } catch (_catch3) {
+        var _err = _catch3, _hasErr = 1;
+      } finally {
+        __callDispose(__stack, _err, _hasErr);
       }
-      return { info: msg, parts: [part] };
     }
     SessionPrompt.shell = shell;
     SessionPrompt.CommandInput = zod_default.object({
@@ -256877,11 +256987,11 @@ var init_types4 = () => {};
 var exports_dist_es = {};
 __export(exports_dist_es, {
   providerConfigFromInit: () => providerConfigFromInit,
-  httpRequest: () => httpRequest,
-  getInstanceMetadataEndpoint: () => getInstanceMetadataEndpoint,
+  httpRequest: () => httpRequest2,
+  getInstanceMetadataEndpoint: () => getInstanceMetadataEndpoint2,
   fromInstanceMetadata: () => fromInstanceMetadata,
   fromContainerMetadata: () => fromContainerMetadata,
-  Endpoint: () => Endpoint,
+  Endpoint: () => Endpoint2,
   ENV_CMDS_RELATIVE_URI: () => ENV_CMDS_RELATIVE_URI,
   ENV_CMDS_FULL_URI: () => ENV_CMDS_FULL_URI,
   ENV_CMDS_AUTH_TOKEN: () => ENV_CMDS_AUTH_TOKEN,
@@ -256889,9 +256999,6 @@ __export(exports_dist_es, {
   DEFAULT_MAX_RETRIES: () => DEFAULT_MAX_RETRIES
 });
 var init_dist_es4 = __esm(() => {
-  init_httpRequest();
-  init_getInstanceMetadataEndpoint();
-  init_Endpoint();
   init_fromContainerMetadata();
   init_fromInstanceMetadata();
   init_types4();
@@ -257302,7 +257409,7 @@ var require_dist_cjs14 = __commonJS((exports) => {
     return timing.setTimeout(registerTimeout.bind(null, timeoutInMs === 0 ? 0 : DEFER_EVENT_LISTENER_TIME), DEFER_EVENT_LISTENER_TIME);
   };
   var MIN_WAIT_TIME = 6000;
-  async function writeRequestBody(httpRequest2, request5, maxContinueTimeoutMs = MIN_WAIT_TIME, externalAgent = false) {
+  async function writeRequestBody(httpRequest3, request5, maxContinueTimeoutMs = MIN_WAIT_TIME, externalAgent = false) {
     const headers = request5.headers ?? {};
     const expect = headers.Expect || headers.expect;
     let timeoutId = -1;
@@ -257313,15 +257420,15 @@ var require_dist_cjs14 = __commonJS((exports) => {
           timeoutId = Number(timing.setTimeout(() => resolve12(true), Math.max(MIN_WAIT_TIME, maxContinueTimeoutMs)));
         }),
         new Promise((resolve12) => {
-          httpRequest2.on("continue", () => {
+          httpRequest3.on("continue", () => {
             timing.clearTimeout(timeoutId);
             resolve12(true);
           });
-          httpRequest2.on("response", () => {
+          httpRequest3.on("response", () => {
             timing.clearTimeout(timeoutId);
             resolve12(false);
           });
-          httpRequest2.on("error", () => {
+          httpRequest3.on("error", () => {
             timing.clearTimeout(timeoutId);
             resolve12(false);
           });
@@ -257329,12 +257436,12 @@ var require_dist_cjs14 = __commonJS((exports) => {
       ]);
     }
     if (sendBody) {
-      writeBody(httpRequest2, request5.body);
+      writeBody(httpRequest3, request5.body);
     }
   }
-  function writeBody(httpRequest2, body2) {
+  function writeBody(httpRequest3, body2) {
     if (body2 instanceof stream3.Readable) {
-      body2.pipe(httpRequest2);
+      body2.pipe(httpRequest3);
       return;
     }
     if (body2) {
@@ -257342,21 +257449,21 @@ var require_dist_cjs14 = __commonJS((exports) => {
       const isString4 = typeof body2 === "string";
       if (isBuffer || isString4) {
         if (isBuffer && body2.byteLength === 0) {
-          httpRequest2.end();
+          httpRequest3.end();
         } else {
-          httpRequest2.end(body2);
+          httpRequest3.end(body2);
         }
         return;
       }
       const uint8 = body2;
       if (typeof uint8 === "object" && uint8.buffer && typeof uint8.byteOffset === "number" && typeof uint8.byteLength === "number") {
-        httpRequest2.end(Buffer.from(uint8.buffer, uint8.byteOffset, uint8.byteLength));
+        httpRequest3.end(Buffer.from(uint8.buffer, uint8.byteOffset, uint8.byteLength));
         return;
       }
-      httpRequest2.end(Buffer.from(body2));
+      httpRequest3.end(Buffer.from(body2));
       return;
     }
-    httpRequest2.end();
+    httpRequest3.end();
   }
   var DEFAULT_REQUEST_TIMEOUT = 0;
 
@@ -262956,7 +263063,7 @@ var require_dist_cjs26 = __commonJS((exports) => {
   }
 
   class HttpApiKeyAuthSigner {
-    async sign(httpRequest2, identity3, signingProperties) {
+    async sign(httpRequest3, identity3, signingProperties) {
       if (!signingProperties) {
         throw new Error("request could not be signed with `apiKey` since the `name` and `in` signer properties are missing");
       }
@@ -262969,7 +263076,7 @@ var require_dist_cjs26 = __commonJS((exports) => {
       if (!identity3.apiKey) {
         throw new Error("request could not be signed with `apiKey` since the `apiKey` is not defined");
       }
-      const clonedRequest = protocolHttp.HttpRequest.clone(httpRequest2);
+      const clonedRequest = protocolHttp.HttpRequest.clone(httpRequest3);
       if (signingProperties.in === types6.HttpApiKeyAuthLocation.QUERY) {
         clonedRequest.query[signingProperties.name] = identity3.apiKey;
       } else if (signingProperties.in === types6.HttpApiKeyAuthLocation.HEADER) {
@@ -262982,8 +263089,8 @@ var require_dist_cjs26 = __commonJS((exports) => {
   }
 
   class HttpBearerAuthSigner {
-    async sign(httpRequest2, identity3, signingProperties) {
-      const clonedRequest = protocolHttp.HttpRequest.clone(httpRequest2);
+    async sign(httpRequest3, identity3, signingProperties) {
+      const clonedRequest = protocolHttp.HttpRequest.clone(httpRequest3);
       if (!identity3.token) {
         throw new Error("request could not be signed with `token` since the `token` is not defined");
       }
@@ -262993,8 +263100,8 @@ var require_dist_cjs26 = __commonJS((exports) => {
   }
 
   class NoAuthSigner {
-    async sign(httpRequest2, identity3, signingProperties) {
-      return httpRequest2;
+    async sign(httpRequest3, identity3, signingProperties) {
+      return httpRequest3;
     }
   }
   var createIsIdentityExpiredFunction = (expirationMs) => function isIdentityExpired2(identity3) {
@@ -266755,8 +266862,8 @@ More information can be found at: https://a.co/c895JFp`);
   };
 
   class AwsSdkSigV4Signer {
-    async sign(httpRequest2, identity3, signingProperties) {
-      if (!protocolHttp.HttpRequest.isInstance(httpRequest2)) {
+    async sign(httpRequest3, identity3, signingProperties) {
+      if (!protocolHttp.HttpRequest.isInstance(httpRequest3)) {
         throw new Error("The request is not an instance of `HttpRequest` and cannot be signed");
       }
       const validatedProps = await validateSigningProperties(signingProperties);
@@ -266770,7 +266877,7 @@ More information can be found at: https://a.co/c895JFp`);
           signingName = second?.signingName ?? signingName;
         }
       }
-      const signedRequest = await signer.sign(httpRequest2, {
+      const signedRequest = await signer.sign(httpRequest3, {
         signingDate: getSkewCorrectedDate(config5.systemClockOffset),
         signingRegion,
         signingService: signingName
@@ -266803,14 +266910,14 @@ More information can be found at: https://a.co/c895JFp`);
   var AWSSDKSigV4Signer = AwsSdkSigV4Signer;
 
   class AwsSdkSigV4ASigner extends AwsSdkSigV4Signer {
-    async sign(httpRequest2, identity3, signingProperties) {
-      if (!protocolHttp.HttpRequest.isInstance(httpRequest2)) {
+    async sign(httpRequest3, identity3, signingProperties) {
+      if (!protocolHttp.HttpRequest.isInstance(httpRequest3)) {
         throw new Error("The request is not an instance of `HttpRequest` and cannot be signed");
       }
       const { config: config5, signer, signingRegion, signingRegionSet, signingName } = await validateSigningProperties(signingProperties);
       const configResolvedSigningRegionSet = await config5.sigv4aSigningRegionSet?.();
       const multiRegionOverride = (configResolvedSigningRegionSet ?? signingRegionSet ?? [signingRegion]).join(",");
-      const signedRequest = await signer.sign(httpRequest2, {
+      const signedRequest = await signer.sign(httpRequest3, {
         signingDate: getSkewCorrectedDate(config5.systemClockOffset),
         signingRegion: multiRegionOverride,
         signingService: signingName
@@ -270566,9 +270673,9 @@ var require_dist_cjs44 = __commonJS((exports) => {
     }
     if (!process.env[ENV_IMDS_DISABLED]) {
       try {
-        const { getInstanceMetadataEndpoint: getInstanceMetadataEndpoint2, httpRequest: httpRequest2 } = await Promise.resolve().then(() => (init_dist_es4(), exports_dist_es));
-        const endpoint = await getInstanceMetadataEndpoint2();
-        return (await httpRequest2({ ...endpoint, path: IMDS_REGION_PATH })).toString();
+        const { getInstanceMetadataEndpoint: getInstanceMetadataEndpoint3, httpRequest: httpRequest3 } = await Promise.resolve().then(() => (init_dist_es4(), exports_dist_es));
+        const endpoint = await getInstanceMetadataEndpoint3();
+        return (await httpRequest3({ ...endpoint, path: IMDS_REGION_PATH })).toString();
       } catch (e4) {}
     }
   };
@@ -277644,256 +277751,263 @@ var init_provider = __esm(async () => {
     }
     Provider.fromModelsDevProvider = fromModelsDevProvider;
     const state4 = Instance.state(async () => {
-      using _3 = log12.time("state");
-      const config5 = await Config.get();
-      const modelsDev = await ModelsDev.get();
-      const database = i4(modelsDev, fromModelsDevProvider);
-      const disabled = new Set(config5.disabled_providers ?? []);
-      const enabled = config5.enabled_providers ? new Set(config5.enabled_providers) : null;
-      function isProviderAllowed(providerID) {
-        if (enabled && !enabled.has(providerID))
-          return false;
-        if (disabled.has(providerID))
-          return false;
-        return true;
-      }
-      const providers2 = {};
-      const languages = new Map;
-      const modelLoaders = {};
-      const sdk = new Map;
-      log12.info("init");
-      const configProviders = Object.entries(config5.provider ?? {});
-      if (database["github-copilot"]) {
-        const githubCopilot = database["github-copilot"];
-        database["github-copilot-enterprise"] = {
-          ...githubCopilot,
-          id: "github-copilot-enterprise",
-          name: "GitHub Copilot Enterprise",
-          models: i4(githubCopilot.models, (model2) => ({
-            ...model2,
-            providerID: "github-copilot-enterprise"
-          }))
-        };
-      }
-      function mergeProvider(providerID, provider) {
-        const existing = providers2[providerID];
-        if (existing) {
-          providers2[providerID] = D2(existing, provider);
-          return;
+      let __stack = [];
+      try {
+        const _3 = __using(__stack, log12.time("state"), 0);
+        const config5 = await Config.get();
+        const modelsDev = await ModelsDev.get();
+        const database = i4(modelsDev, fromModelsDevProvider);
+        const disabled = new Set(config5.disabled_providers ?? []);
+        const enabled = config5.enabled_providers ? new Set(config5.enabled_providers) : null;
+        function isProviderAllowed(providerID) {
+          if (enabled && !enabled.has(providerID))
+            return false;
+          if (disabled.has(providerID))
+            return false;
+          return true;
         }
-        const match17 = database[providerID];
-        if (!match17)
-          return;
-        providers2[providerID] = D2(match17, provider);
-      }
-      for (const [providerID, provider] of configProviders) {
-        const existing = database[providerID];
-        const parsed = {
-          id: providerID,
-          name: provider.name ?? existing?.name ?? providerID,
-          env: provider.env ?? existing?.env ?? [],
-          options: D2(existing?.options ?? {}, provider.options ?? {}),
-          source: "config",
-          models: existing?.models ?? {}
-        };
-        for (const [modelID, model2] of Object.entries(provider.models ?? {})) {
-          const existingModel = parsed.models[model2.id ?? modelID];
-          const name19 = iife2(() => {
-            if (model2.name)
-              return model2.name;
-            if (model2.id && model2.id !== modelID)
-              return modelID;
-            return existingModel?.name ?? modelID;
-          });
-          const parsedModel = {
-            id: modelID,
-            api: {
-              id: model2.id ?? existingModel?.api.id ?? modelID,
-              npm: model2.provider?.npm ?? provider.npm ?? existingModel?.api.npm ?? modelsDev[providerID]?.npm ?? "@ai-sdk/openai-compatible",
-              url: model2.provider?.api ?? provider?.api ?? existingModel?.api.url ?? modelsDev[providerID]?.api
-            },
-            status: model2.status ?? existingModel?.status ?? "active",
-            name: name19,
-            providerID,
-            capabilities: {
-              temperature: model2.temperature ?? existingModel?.capabilities.temperature ?? false,
-              reasoning: model2.reasoning ?? existingModel?.capabilities.reasoning ?? false,
-              attachment: model2.attachment ?? existingModel?.capabilities.attachment ?? false,
-              toolcall: model2.tool_call ?? existingModel?.capabilities.toolcall ?? true,
-              input: {
-                text: model2.modalities?.input?.includes("text") ?? existingModel?.capabilities.input.text ?? true,
-                audio: model2.modalities?.input?.includes("audio") ?? existingModel?.capabilities.input.audio ?? false,
-                image: model2.modalities?.input?.includes("image") ?? existingModel?.capabilities.input.image ?? false,
-                video: model2.modalities?.input?.includes("video") ?? existingModel?.capabilities.input.video ?? false,
-                pdf: model2.modalities?.input?.includes("pdf") ?? existingModel?.capabilities.input.pdf ?? false
+        const providers2 = {};
+        const languages = new Map;
+        const modelLoaders = {};
+        const sdk = new Map;
+        log12.info("init");
+        const configProviders = Object.entries(config5.provider ?? {});
+        if (database["github-copilot"]) {
+          const githubCopilot = database["github-copilot"];
+          database["github-copilot-enterprise"] = {
+            ...githubCopilot,
+            id: "github-copilot-enterprise",
+            name: "GitHub Copilot Enterprise",
+            models: i4(githubCopilot.models, (model2) => ({
+              ...model2,
+              providerID: "github-copilot-enterprise"
+            }))
+          };
+        }
+        function mergeProvider(providerID, provider) {
+          const existing = providers2[providerID];
+          if (existing) {
+            providers2[providerID] = D2(existing, provider);
+            return;
+          }
+          const match17 = database[providerID];
+          if (!match17)
+            return;
+          providers2[providerID] = D2(match17, provider);
+        }
+        for (const [providerID, provider] of configProviders) {
+          const existing = database[providerID];
+          const parsed = {
+            id: providerID,
+            name: provider.name ?? existing?.name ?? providerID,
+            env: provider.env ?? existing?.env ?? [],
+            options: D2(existing?.options ?? {}, provider.options ?? {}),
+            source: "config",
+            models: existing?.models ?? {}
+          };
+          for (const [modelID, model2] of Object.entries(provider.models ?? {})) {
+            const existingModel = parsed.models[model2.id ?? modelID];
+            const name19 = iife2(() => {
+              if (model2.name)
+                return model2.name;
+              if (model2.id && model2.id !== modelID)
+                return modelID;
+              return existingModel?.name ?? modelID;
+            });
+            const parsedModel = {
+              id: modelID,
+              api: {
+                id: model2.id ?? existingModel?.api.id ?? modelID,
+                npm: model2.provider?.npm ?? provider.npm ?? existingModel?.api.npm ?? modelsDev[providerID]?.npm ?? "@ai-sdk/openai-compatible",
+                url: model2.provider?.api ?? provider?.api ?? existingModel?.api.url ?? modelsDev[providerID]?.api
+              },
+              status: model2.status ?? existingModel?.status ?? "active",
+              name: name19,
+              providerID,
+              capabilities: {
+                temperature: model2.temperature ?? existingModel?.capabilities.temperature ?? false,
+                reasoning: model2.reasoning ?? existingModel?.capabilities.reasoning ?? false,
+                attachment: model2.attachment ?? existingModel?.capabilities.attachment ?? false,
+                toolcall: model2.tool_call ?? existingModel?.capabilities.toolcall ?? true,
+                input: {
+                  text: model2.modalities?.input?.includes("text") ?? existingModel?.capabilities.input.text ?? true,
+                  audio: model2.modalities?.input?.includes("audio") ?? existingModel?.capabilities.input.audio ?? false,
+                  image: model2.modalities?.input?.includes("image") ?? existingModel?.capabilities.input.image ?? false,
+                  video: model2.modalities?.input?.includes("video") ?? existingModel?.capabilities.input.video ?? false,
+                  pdf: model2.modalities?.input?.includes("pdf") ?? existingModel?.capabilities.input.pdf ?? false
+                },
+                output: {
+                  text: model2.modalities?.output?.includes("text") ?? existingModel?.capabilities.output.text ?? true,
+                  audio: model2.modalities?.output?.includes("audio") ?? existingModel?.capabilities.output.audio ?? false,
+                  image: model2.modalities?.output?.includes("image") ?? existingModel?.capabilities.output.image ?? false,
+                  video: model2.modalities?.output?.includes("video") ?? existingModel?.capabilities.output.video ?? false,
+                  pdf: model2.modalities?.output?.includes("pdf") ?? existingModel?.capabilities.output.pdf ?? false
+                },
+                interleaved: model2.interleaved ?? false
               },
-              output: {
-                text: model2.modalities?.output?.includes("text") ?? existingModel?.capabilities.output.text ?? true,
-                audio: model2.modalities?.output?.includes("audio") ?? existingModel?.capabilities.output.audio ?? false,
-                image: model2.modalities?.output?.includes("image") ?? existingModel?.capabilities.output.image ?? false,
-                video: model2.modalities?.output?.includes("video") ?? existingModel?.capabilities.output.video ?? false,
-                pdf: model2.modalities?.output?.includes("pdf") ?? existingModel?.capabilities.output.pdf ?? false
+              cost: {
+                input: model2?.cost?.input ?? existingModel?.cost?.input ?? 0,
+                output: model2?.cost?.output ?? existingModel?.cost?.output ?? 0,
+                cache: {
+                  read: model2?.cost?.cache_read ?? existingModel?.cost?.cache.read ?? 0,
+                  write: model2?.cost?.cache_write ?? existingModel?.cost?.cache.write ?? 0
+                }
               },
-              interleaved: model2.interleaved ?? false
-            },
-            cost: {
-              input: model2?.cost?.input ?? existingModel?.cost?.input ?? 0,
-              output: model2?.cost?.output ?? existingModel?.cost?.output ?? 0,
-              cache: {
-                read: model2?.cost?.cache_read ?? existingModel?.cost?.cache.read ?? 0,
-                write: model2?.cost?.cache_write ?? existingModel?.cost?.cache.write ?? 0
-              }
-            },
-            options: D2(existingModel?.options ?? {}, model2.options ?? {}),
-            limit: {
-              context: model2.limit?.context ?? existingModel?.limit?.context ?? 0,
-              output: model2.limit?.output ?? existingModel?.limit?.output ?? 0
-            },
-            headers: D2(existingModel?.headers ?? {}, model2.headers ?? {}),
-            family: model2.family ?? existingModel?.family ?? "",
-            release_date: model2.release_date ?? existingModel?.release_date ?? "",
-            variants: {}
-          };
-          const merged = D2(ProviderTransform.variants(parsedModel), model2.variants ?? {});
-          parsedModel.variants = i4(d3(merged, (v4) => !v4.disabled), (v4) => y4(v4, ["disabled"]));
-          parsed.models[modelID] = parsedModel;
+              options: D2(existingModel?.options ?? {}, model2.options ?? {}),
+              limit: {
+                context: model2.limit?.context ?? existingModel?.limit?.context ?? 0,
+                output: model2.limit?.output ?? existingModel?.limit?.output ?? 0
+              },
+              headers: D2(existingModel?.headers ?? {}, model2.headers ?? {}),
+              family: model2.family ?? existingModel?.family ?? "",
+              release_date: model2.release_date ?? existingModel?.release_date ?? "",
+              variants: {}
+            };
+            const merged = D2(ProviderTransform.variants(parsedModel), model2.variants ?? {});
+            parsedModel.variants = i4(d3(merged, (v4) => !v4.disabled), (v4) => y4(v4, ["disabled"]));
+            parsed.models[modelID] = parsedModel;
+          }
+          database[providerID] = parsed;
         }
-        database[providerID] = parsed;
-      }
-      const env3 = Env.all();
-      for (const [providerID, provider] of Object.entries(database)) {
-        if (disabled.has(providerID))
-          continue;
-        const apiKey = provider.env.map((item) => env3[item]).find(Boolean);
-        if (!apiKey)
-          continue;
-        mergeProvider(providerID, {
-          source: "env",
-          key: provider.env.length === 1 ? apiKey : undefined
-        });
-      }
-      for (const [providerID, provider] of Object.entries(await Auth.all())) {
-        if (disabled.has(providerID))
-          continue;
-        if (provider.type === "api") {
+        const env3 = Env.all();
+        for (const [providerID, provider] of Object.entries(database)) {
+          if (disabled.has(providerID))
+            continue;
+          const apiKey = provider.env.map((item) => env3[item]).find(Boolean);
+          if (!apiKey)
+            continue;
           mergeProvider(providerID, {
-            source: "api",
-            key: provider.key
+            source: "env",
+            key: provider.env.length === 1 ? apiKey : undefined
           });
         }
-      }
-      for (const plugin of await Plugin.list()) {
-        if (!plugin.auth)
-          continue;
-        const providerID = plugin.auth.provider;
-        if (disabled.has(providerID))
-          continue;
-        let hasAuth = false;
-        const auth3 = await Auth.get(providerID);
-        if (auth3)
-          hasAuth = true;
-        if (providerID === "github-copilot" && !hasAuth) {
-          const enterpriseAuth = await Auth.get("github-copilot-enterprise");
-          if (enterpriseAuth)
-            hasAuth = true;
-        }
-        if (!hasAuth)
-          continue;
-        if (!plugin.auth.loader)
-          continue;
-        if (auth3) {
-          const options2 = await plugin.auth.loader(() => Auth.get(providerID), database[plugin.auth.provider]);
-          const opts = options2 ?? {};
-          const patch = providers2[providerID] ? { options: opts } : { source: "custom", options: opts };
-          mergeProvider(providerID, patch);
+        for (const [providerID, provider] of Object.entries(await Auth.all())) {
+          if (disabled.has(providerID))
+            continue;
+          if (provider.type === "api") {
+            mergeProvider(providerID, {
+              source: "api",
+              key: provider.key
+            });
+          }
         }
-        if (providerID === "github-copilot") {
-          const enterpriseProviderID = "github-copilot-enterprise";
-          if (!disabled.has(enterpriseProviderID)) {
-            const enterpriseAuth = await Auth.get(enterpriseProviderID);
-            if (enterpriseAuth) {
-              const enterpriseOptions = await plugin.auth.loader(() => Auth.get(enterpriseProviderID), database[enterpriseProviderID]);
-              const opts = enterpriseOptions ?? {};
-              const patch = providers2[enterpriseProviderID] ? { options: opts } : { source: "custom", options: opts };
-              mergeProvider(enterpriseProviderID, patch);
+        for (const plugin of await Plugin.list()) {
+          if (!plugin.auth)
+            continue;
+          const providerID = plugin.auth.provider;
+          if (disabled.has(providerID))
+            continue;
+          let hasAuth = false;
+          const auth3 = await Auth.get(providerID);
+          if (auth3)
+            hasAuth = true;
+          if (providerID === "github-copilot" && !hasAuth) {
+            const enterpriseAuth = await Auth.get("github-copilot-enterprise");
+            if (enterpriseAuth)
+              hasAuth = true;
+          }
+          if (!hasAuth)
+            continue;
+          if (!plugin.auth.loader)
+            continue;
+          if (auth3) {
+            const options2 = await plugin.auth.loader(() => Auth.get(providerID), database[plugin.auth.provider]);
+            const opts = options2 ?? {};
+            const patch = providers2[providerID] ? { options: opts } : { source: "custom", options: opts };
+            mergeProvider(providerID, patch);
+          }
+          if (providerID === "github-copilot") {
+            const enterpriseProviderID = "github-copilot-enterprise";
+            if (!disabled.has(enterpriseProviderID)) {
+              const enterpriseAuth = await Auth.get(enterpriseProviderID);
+              if (enterpriseAuth) {
+                const enterpriseOptions = await plugin.auth.loader(() => Auth.get(enterpriseProviderID), database[enterpriseProviderID]);
+                const opts = enterpriseOptions ?? {};
+                const patch = providers2[enterpriseProviderID] ? { options: opts } : { source: "custom", options: opts };
+                mergeProvider(enterpriseProviderID, patch);
+              }
             }
           }
         }
-      }
-      for (const [providerID, fn5] of Object.entries(CUSTOM_LOADERS)) {
-        if (disabled.has(providerID))
-          continue;
-        const data2 = database[providerID];
-        if (!data2) {
-          log12.debug("skipping custom loader for missing provider", { providerID });
-          continue;
-        }
-        const result6 = await fn5(data2);
-        if (result6 && (result6.autoload || providers2[providerID])) {
-          if (result6.getModel)
-            modelLoaders[providerID] = result6.getModel;
-          const opts = result6.options ?? {};
-          const patch = providers2[providerID] ? { options: opts } : { source: "custom", options: opts };
-          mergeProvider(providerID, patch);
-        }
-      }
-      for (const [providerID, provider] of configProviders) {
-        const partial2 = { source: "config" };
-        if (provider.env)
-          partial2.env = provider.env;
-        if (provider.name)
-          partial2.name = provider.name;
-        if (provider.options)
-          partial2.options = provider.options;
-        mergeProvider(providerID, partial2);
-      }
-      for (const plugin of await Plugin.list()) {
-        if (!plugin.provider?.models)
-          continue;
-        const providerID = plugin.provider.id;
-        const provider = providers2[providerID];
-        if (!provider || !isProviderAllowed(providerID))
-          continue;
-        const models = await plugin.provider.models(provider, { auth: await Auth.get(providerID) });
-        if (models) {
-          provider.models = D2(provider.models, models);
-        }
-      }
-      for (const [providerID, provider] of Object.entries(providers2)) {
-        if (!isProviderAllowed(providerID)) {
-          delete providers2[providerID];
-          continue;
+        for (const [providerID, fn5] of Object.entries(CUSTOM_LOADERS)) {
+          if (disabled.has(providerID))
+            continue;
+          const data2 = database[providerID];
+          if (!data2) {
+            log12.debug("skipping custom loader for missing provider", { providerID });
+            continue;
+          }
+          const result6 = await fn5(data2);
+          if (result6 && (result6.autoload || providers2[providerID])) {
+            if (result6.getModel)
+              modelLoaders[providerID] = result6.getModel;
+            const opts = result6.options ?? {};
+            const patch = providers2[providerID] ? { options: opts } : { source: "custom", options: opts };
+            mergeProvider(providerID, patch);
+          }
+        }
+        for (const [providerID, provider] of configProviders) {
+          const partial2 = { source: "config" };
+          if (provider.env)
+            partial2.env = provider.env;
+          if (provider.name)
+            partial2.name = provider.name;
+          if (provider.options)
+            partial2.options = provider.options;
+          mergeProvider(providerID, partial2);
+        }
+        for (const plugin of await Plugin.list()) {
+          if (!plugin.provider?.models)
+            continue;
+          const providerID = plugin.provider.id;
+          const provider = providers2[providerID];
+          if (!provider || !isProviderAllowed(providerID))
+            continue;
+          const models = await plugin.provider.models(provider, { auth: await Auth.get(providerID) });
+          if (models) {
+            provider.models = D2(provider.models, models);
+          }
         }
-        const configProvider = config5.provider?.[providerID];
-        for (const [modelID, model2] of Object.entries(provider.models)) {
-          model2.api.id = model2.api.id ?? model2.id ?? modelID;
-          if (modelID === "gpt-5-chat-latest" || providerID === "openrouter" && modelID === "openai/gpt-5-chat")
-            delete provider.models[modelID];
-          if (model2.status === "alpha" && !Flag.SLOPCODE_ENABLE_EXPERIMENTAL_MODELS)
-            delete provider.models[modelID];
-          if (model2.status === "deprecated")
-            delete provider.models[modelID];
-          if (configProvider?.blacklist && configProvider.blacklist.includes(modelID) || configProvider?.whitelist && !configProvider.whitelist.includes(modelID))
-            delete provider.models[modelID];
-          model2.variants = i4(ProviderTransform.variants(model2), (v4) => v4);
-          const configVariants = configProvider?.models?.[modelID]?.variants;
-          if (configVariants && model2.variants) {
-            const merged = D2(model2.variants, configVariants);
-            model2.variants = i4(d3(merged, (v4) => !v4.disabled), (v4) => y4(v4, ["disabled"]));
-          }
-        }
-        if (Object.keys(provider.models).length === 0) {
-          delete providers2[providerID];
-          continue;
+        for (const [providerID, provider] of Object.entries(providers2)) {
+          if (!isProviderAllowed(providerID)) {
+            delete providers2[providerID];
+            continue;
+          }
+          const configProvider = config5.provider?.[providerID];
+          for (const [modelID, model2] of Object.entries(provider.models)) {
+            model2.api.id = model2.api.id ?? model2.id ?? modelID;
+            if (modelID === "gpt-5-chat-latest" || providerID === "openrouter" && modelID === "openai/gpt-5-chat")
+              delete provider.models[modelID];
+            if (model2.status === "alpha" && !Flag.SLOPCODE_ENABLE_EXPERIMENTAL_MODELS)
+              delete provider.models[modelID];
+            if (model2.status === "deprecated")
+              delete provider.models[modelID];
+            if (configProvider?.blacklist && configProvider.blacklist.includes(modelID) || configProvider?.whitelist && !configProvider.whitelist.includes(modelID))
+              delete provider.models[modelID];
+            model2.variants = i4(ProviderTransform.variants(model2), (v4) => v4);
+            const configVariants = configProvider?.models?.[modelID]?.variants;
+            if (configVariants && model2.variants) {
+              const merged = D2(model2.variants, configVariants);
+              model2.variants = i4(d3(merged, (v4) => !v4.disabled), (v4) => y4(v4, ["disabled"]));
+            }
+          }
+          if (Object.keys(provider.models).length === 0) {
+            delete providers2[providerID];
+            continue;
+          }
+          log12.info("found", { providerID });
         }
-        log12.info("found", { providerID });
+        return {
+          models: languages,
+          providers: providers2,
+          sdk,
+          modelLoaders
+        };
+      } catch (_catch3) {
+        var _err = _catch3, _hasErr = 1;
+      } finally {
+        __callDispose(__stack, _err, _hasErr);
       }
-      return {
-        models: languages,
-        providers: providers2,
-        sdk,
-        modelLoaders
-      };
     });
     async function list() {
       return state4().then((state5) => state5.providers);
@@ -277901,113 +278015,120 @@ var init_provider = __esm(async () => {
     Provider.list = list;
     async function getSDK(model2) {
       try {
-        using _3 = log12.time("getSDK", {
-          providerID: model2.providerID
-        });
-        const s7 = await state4();
-        const provider = s7.providers[model2.providerID];
-        const options2 = { ...provider.options };
-        if (model2.providerID === "google-vertex" && !model2.api.npm.includes("@ai-sdk/openai-compatible")) {
-          delete options2.fetch;
-        }
-        if (model2.api.npm.includes("@ai-sdk/openai-compatible") && options2["includeUsage"] !== false) {
-          options2["includeUsage"] = true;
-        }
-        const baseURL2 = loadBaseURL(model2, options2);
-        if (baseURL2 !== undefined)
-          options2["baseURL"] = baseURL2;
-        if (options2["apiKey"] === undefined && provider.key)
-          options2["apiKey"] = provider.key;
-        if (model2.headers)
-          options2["headers"] = {
-            ...options2["headers"],
-            ...model2.headers
-          };
-        const key = Bun.hash.xxHash32(JSON.stringify({ providerID: model2.providerID, npm: model2.api.npm, options: options2 }));
-        const existing = s7.sdk.get(key);
-        if (existing)
-          return existing;
-        const customFetch = options2["fetch"];
-        options2["fetch"] = async (input, init3) => {
-          const fetchFn = customFetch ?? fetch;
-          const opts = init3 ?? {};
-          if (options2["timeout"] !== undefined && options2["timeout"] !== null) {
-            const signals = [];
-            if (opts.signal)
-              signals.push(opts.signal);
-            if (options2["timeout"] !== false)
-              signals.push(AbortSignal.timeout(options2["timeout"]));
-            const combined = signals.length > 1 ? AbortSignal.any(signals) : signals[0];
-            opts.signal = combined;
-          }
-          if (opts.method === "POST" && typeof opts.body === "string") {
-            const url4 = new URL(input instanceof Request ? input.url : input.toString());
-            if (model2.api.npm === "@ai-sdk/openai") {
-              const body2 = JSON.parse(opts.body);
-              const isAzure = model2.providerID.includes("azure");
-              const keepIds = isAzure && body2.store === true;
-              if (!keepIds && Array.isArray(body2.input)) {
-                for (const item of body2.input) {
-                  if ("id" in item) {
-                    delete item.id;
+        let __stack = [];
+        try {
+          const _3 = __using(__stack, log12.time("getSDK", {
+            providerID: model2.providerID
+          }), 0);
+          const s7 = await state4();
+          const provider = s7.providers[model2.providerID];
+          const options2 = { ...provider.options };
+          if (model2.providerID === "google-vertex" && !model2.api.npm.includes("@ai-sdk/openai-compatible")) {
+            delete options2.fetch;
+          }
+          if (model2.api.npm.includes("@ai-sdk/openai-compatible") && options2["includeUsage"] !== false) {
+            options2["includeUsage"] = true;
+          }
+          const baseURL2 = loadBaseURL(model2, options2);
+          if (baseURL2 !== undefined)
+            options2["baseURL"] = baseURL2;
+          if (options2["apiKey"] === undefined && provider.key)
+            options2["apiKey"] = provider.key;
+          if (model2.headers)
+            options2["headers"] = {
+              ...options2["headers"],
+              ...model2.headers
+            };
+          const key = Bun.hash.xxHash32(JSON.stringify({ providerID: model2.providerID, npm: model2.api.npm, options: options2 }));
+          const existing = s7.sdk.get(key);
+          if (existing)
+            return existing;
+          const customFetch = options2["fetch"];
+          options2["fetch"] = async (input, init3) => {
+            const fetchFn = customFetch ?? fetch;
+            const opts = init3 ?? {};
+            if (options2["timeout"] !== undefined && options2["timeout"] !== null) {
+              const signals = [];
+              if (opts.signal)
+                signals.push(opts.signal);
+              if (options2["timeout"] !== false)
+                signals.push(AbortSignal.timeout(options2["timeout"]));
+              const combined = signals.length > 1 ? AbortSignal.any(signals) : signals[0];
+              opts.signal = combined;
+            }
+            if (opts.method === "POST" && typeof opts.body === "string") {
+              const url4 = new URL(input instanceof Request ? input.url : input.toString());
+              if (model2.api.npm === "@ai-sdk/openai") {
+                const body2 = JSON.parse(opts.body);
+                const isAzure = model2.providerID.includes("azure");
+                const keepIds = isAzure && body2.store === true;
+                if (!keepIds && Array.isArray(body2.input)) {
+                  for (const item of body2.input) {
+                    if ("id" in item) {
+                      delete item.id;
+                    }
                   }
+                  opts.body = JSON.stringify(body2);
                 }
-                opts.body = JSON.stringify(body2);
               }
-            }
-            if (LlamaCppSessionCache.isEnabled(provider.options) && (url4.pathname.endsWith("/chat/completions") || url4.pathname.endsWith("/completions"))) {
-              const sessionID = new Headers(opts.headers).get("x-slopcode-session");
-              if (sessionID) {
-                const body2 = JSON.parse(opts.body);
-                const injected = await LlamaCppSessionCache.prepareRequest({
-                  sessionID,
-                  providerID: model2.providerID,
-                  modelID: model2.id,
-                  providerOptions: provider.options,
-                  baseURL: String(baseURL2 ?? model2.api.url),
-                  fetch: fetchFn,
-                  signal: opts.signal ?? undefined
-                });
-                if (injected) {
-                  opts.body = JSON.stringify({ ...body2, ...injected });
+              if (LlamaCppSessionCache.isEnabled(provider.options) && (url4.pathname.endsWith("/chat/completions") || url4.pathname.endsWith("/completions"))) {
+                const sessionID = new Headers(opts.headers).get("x-slopcode-session");
+                if (sessionID) {
+                  const body2 = JSON.parse(opts.body);
+                  const injected = await LlamaCppSessionCache.prepareRequest({
+                    sessionID,
+                    providerID: model2.providerID,
+                    modelID: model2.id,
+                    providerOptions: provider.options,
+                    baseURL: String(baseURL2 ?? model2.api.url),
+                    fetch: fetchFn,
+                    signal: opts.signal ?? undefined
+                  });
+                  if (injected) {
+                    opts.body = JSON.stringify({ ...body2, ...injected });
+                  }
                 }
               }
             }
+            const response = await fetchFn(input, {
+              ...opts,
+              timeout: false
+            });
+            if (response.ok) {
+              ProviderLimit.capture(response.headers);
+            }
+            return response;
+          };
+          const bundledFn = BUNDLED_PROVIDERS[model2.api.npm];
+          if (bundledFn) {
+            log12.info("using bundled provider", { providerID: model2.providerID, pkg: model2.api.npm });
+            const loaded2 = bundledFn({
+              name: model2.providerID,
+              ...options2
+            });
+            s7.sdk.set(key, loaded2);
+            return loaded2;
           }
-          const response = await fetchFn(input, {
-            ...opts,
-            timeout: false
-          });
-          if (response.ok) {
-            ProviderLimit.capture(response.headers);
+          let installedPath;
+          if (!model2.api.npm.startsWith("file://")) {
+            installedPath = await BunProc.install(model2.api.npm, "latest");
+          } else {
+            log12.info("loading local provider", { pkg: model2.api.npm });
+            installedPath = model2.api.npm;
           }
-          return response;
-        };
-        const bundledFn = BUNDLED_PROVIDERS[model2.api.npm];
-        if (bundledFn) {
-          log12.info("using bundled provider", { providerID: model2.providerID, pkg: model2.api.npm });
-          const loaded2 = bundledFn({
+          const mod2 = await import(installedPath);
+          const fn5 = mod2[Object.keys(mod2).find((key2) => key2.startsWith("create"))];
+          const loaded = fn5({
             name: model2.providerID,
             ...options2
           });
-          s7.sdk.set(key, loaded2);
-          return loaded2;
-        }
-        let installedPath;
-        if (!model2.api.npm.startsWith("file://")) {
-          installedPath = await BunProc.install(model2.api.npm, "latest");
-        } else {
-          log12.info("loading local provider", { pkg: model2.api.npm });
-          installedPath = model2.api.npm;
+          s7.sdk.set(key, loaded);
+          return loaded;
+        } catch (_catch3) {
+          var _err = _catch3, _hasErr = 1;
+        } finally {
+          __callDispose(__stack, _err, _hasErr);
         }
-        const mod2 = await import(installedPath);
-        const fn5 = mod2[Object.keys(mod2).find((key2) => key2.startsWith("create"))];
-        const loaded = fn5({
-          name: model2.providerID,
-          ...options2
-        });
-        s7.sdk.set(key, loaded);
-        return loaded;
       } catch (e5) {
         throw new Provider.InitError({ providerID: model2.providerID }, { cause: e5 });
       }
@@ -278292,7 +278413,8 @@ function createSurfaceManifest(input = {}) {
     version: TUI_SURFACE_VERSION,
     renderer: {
       linux: "opentui/solid",
-      android: "ratatui/crossterm"
+      android: "ratatui/crossterm",
+      frame: "shared/terminal-frame"
     },
     capabilities: {
       "android.runtime": input.android ?? false,
@@ -278429,7 +278551,166 @@ function createSurfaceSnapshot(input) {
     }
   };
 }
-var TUI_SURFACE_VERSION = 1, TuiSurfaceCommand, TuiSurfaceManifest, TuiSurfaceAction, TuiSurfaceSnapshot, command = (input) => input, surfaceCommands;
+function cellWidth(char2) {
+  const code = char2.codePointAt(0) ?? 0;
+  if (code === 0)
+    return 0;
+  if (code < 32 || code >= 127 && code < 160)
+    return 0;
+  return code >= 4352 ? 2 : 1;
+}
+function visibleWidth(text11) {
+  let width = 0;
+  for (const char2 of text11)
+    width += cellWidth(char2);
+  return width;
+}
+function fit(text11, width) {
+  if (width <= 0)
+    return "";
+  let out2 = "";
+  let size24 = 0;
+  for (const char2 of text11.replace(/\s+/g, " ")) {
+    const next4 = cellWidth(char2);
+    if (size24 + next4 > width)
+      break;
+    out2 += char2;
+    size24 += next4;
+  }
+  return out2 + " ".repeat(Math.max(0, width - size24));
+}
+function wrap2(text11, width) {
+  if (width <= 0)
+    return [""];
+  const words = text11.split(/\s+/).filter(Boolean);
+  if (words.length === 0)
+    return [""];
+  const lines = [];
+  let line2 = "";
+  for (const word of words) {
+    const candidate = line2 ? `${line2} ${word}` : word;
+    if (visibleWidth(candidate) <= width) {
+      line2 = candidate;
+      continue;
+    }
+    if (line2)
+      lines.push(line2);
+    if (visibleWidth(word) <= width) {
+      line2 = word;
+      continue;
+    }
+    let chunk = "";
+    let size24 = 0;
+    for (const char2 of word) {
+      const next4 = cellWidth(char2);
+      if (size24 + next4 > width) {
+        lines.push(chunk);
+        chunk = "";
+        size24 = 0;
+      }
+      chunk += char2;
+      size24 += next4;
+    }
+    line2 = chunk;
+  }
+  if (line2)
+    lines.push(line2);
+  return lines;
+}
+function clampDimension(value8, fallback, min13, max13) {
+  if (!Number.isFinite(value8))
+    return fallback;
+  return Math.max(min13, Math.min(max13, Math.floor(value8)));
+}
+function tabLine(snapshot4) {
+  const tabs = snapshot4.tabs.length ? snapshot4.tabs.map((item) => `${item.active ? "[*]" : "[ ]"} ${item.title} ${item.status}`).join("  ") : "[ ] new session idle";
+  return tabs;
+}
+function transcriptLines(snapshot4, width) {
+  const lines = [];
+  if (snapshot4.transcript.length === 0) {
+    lines.push("Start a conversation or type /help for commands.");
+    return lines;
+  }
+  for (const message of snapshot4.transcript) {
+    const label = message.role === "user" ? "You" : "Assistant";
+    if (message.text)
+      lines.push(...wrap2(`${label}: ${message.text}`, width));
+    for (const tool3 of message.tools) {
+      lines.push(...wrap2(`tool ${tool3.tool} ${tool3.status}`, width));
+      for (const row of tool3.preview)
+        lines.push(...wrap2(`output ${row}`, width));
+      for (const row of tool3.diff)
+        lines.push(...wrap2(`diff ${row}`, width));
+      if (tool3.expandable)
+        lines.push("more output available");
+    }
+    if (message.text || message.tools.length > 0)
+      lines.push("");
+  }
+  while (lines.at(-1) === "")
+    lines.pop();
+  return lines.length ? lines : ["No transcript yet."];
+}
+function sidebarLines(snapshot4, width) {
+  const title = snapshot4.sidebar.mode === "files" ? "Files" : "Modified Files";
+  const rows = snapshot4.sidebar.rows.length ? snapshot4.sidebar.rows : ["No changed files"];
+  return [title, ...rows.flatMap((row) => wrap2(row, width))];
+}
+function createSurfaceFrame(input) {
+  const width = clampDimension(input.width, 80, 20, 240);
+  const height = clampDimension(input.height, 24, 8, 100);
+  const snapshot4 = input.snapshot;
+  const header = `SlopCode | ${snapshot4.header.title} | ${snapshot4.status}`;
+  const footer = [
+    snapshot4.footer.directory,
+    snapshot4.footer.workspaceID ? `workspace ${snapshot4.footer.workspaceID}` : undefined,
+    `lsp ${snapshot4.footer.lsp}`,
+    `mcp ${snapshot4.footer.mcp}${snapshot4.footer.mcpFailed ? "!" : ""}`,
+    snapshot4.footer.permissions ? `perm ${snapshot4.footer.permissions}` : undefined
+  ].filter(Boolean).join(" | ");
+  const prompt = "> ";
+  const bodyHeight = Math.max(1, height - 4);
+  const useSidebar = width >= 90;
+  const body2 = [];
+  if (useSidebar) {
+    const sidebarWidth = Math.min(32, Math.max(24, Math.floor(width * 0.3)));
+    const mainWidth = width - sidebarWidth - 3;
+    const main = transcriptLines(snapshot4, mainWidth);
+    const side = sidebarLines(snapshot4, sidebarWidth);
+    for (let index3 = 0;index3 < bodyHeight; index3++) {
+      body2.push(`${fit(main[index3] ?? "", mainWidth)} | ${fit(side[index3] ?? "", sidebarWidth)}`);
+    }
+  } else {
+    const main = [...transcriptLines(snapshot4, width), "", ...sidebarLines(snapshot4, width)];
+    for (let index3 = 0;index3 < bodyHeight; index3++)
+      body2.push(fit(main[index3] ?? "", width));
+  }
+  const lines = [
+    fit(header, width),
+    fit(tabLine(snapshot4), width),
+    ...body2,
+    fit(prompt, width),
+    fit(footer, width)
+  ].slice(0, height);
+  while (lines.length < height)
+    lines.push(" ".repeat(width));
+  return {
+    version: TUI_SURFACE_VERSION,
+    renderer: "shared/terminal-frame",
+    width,
+    height,
+    sessionID: snapshot4.sessionID,
+    title: snapshot4.title,
+    status: snapshot4.status,
+    lines,
+    rows: lines.map((line2, y6) => ({
+      y: y6,
+      spans: [{ x: 0, text: line2 }]
+    }))
+  };
+}
+var TUI_SURFACE_VERSION = 2, TuiSurfaceCommand, TuiSurfaceManifest, TuiSurfaceAction, TuiSurfaceSnapshot, TuiSurfaceFrameStyle, TuiSurfaceFrameSpan, TuiSurfaceFrame, command = (input) => input, surfaceCommands;
 var init_surface = __esm(async () => {
   init_zod();
   init_keybind();
@@ -278451,7 +278732,8 @@ var init_surface = __esm(async () => {
     version: zod_default.literal(TUI_SURFACE_VERSION),
     renderer: zod_default.object({
       linux: zod_default.literal("opentui/solid"),
-      android: zod_default.literal("ratatui/crossterm")
+      android: zod_default.literal("ratatui/crossterm"),
+      frame: zod_default.literal("shared/terminal-frame")
     }),
     capabilities: zod_default.record(zod_default.string(), zod_default.boolean()),
     commands: TuiSurfaceCommand.array(),
@@ -278559,6 +278841,33 @@ var init_surface = __esm(async () => {
       rows: zod_default.string().array()
     })
   });
+  TuiSurfaceFrameStyle = zod_default.object({
+    fg: zod_default.string().optional(),
+    bg: zod_default.string().optional(),
+    bold: zod_default.boolean().optional(),
+    dim: zod_default.boolean().optional(),
+    underline: zod_default.boolean().optional(),
+    reverse: zod_default.boolean().optional()
+  });
+  TuiSurfaceFrameSpan = zod_default.object({
+    x: zod_default.number(),
+    text: zod_default.string(),
+    style: TuiSurfaceFrameStyle.optional()
+  });
+  TuiSurfaceFrame = zod_default.object({
+    version: zod_default.literal(TUI_SURFACE_VERSION),
+    renderer: zod_default.literal("shared/terminal-frame"),
+    width: zod_default.number(),
+    height: zod_default.number(),
+    sessionID: zod_default.string().optional(),
+    title: zod_default.string(),
+    status: zod_default.string(),
+    lines: zod_default.string().array(),
+    rows: zod_default.object({
+      y: zod_default.number(),
+      spans: TuiSurfaceFrameSpan.array()
+    }).array()
+  });
   surfaceCommands = [
     command({
       id: "help.show",
@@ -279336,6 +279645,32 @@ var init_tui2 = __esm(async () => {
     sessionID: zod_default.string().optional()
   })), async (c4) => {
     return c4.json(await snapshot4(c4.req.valid("query").sessionID));
+  }).get("/frame", describeRoute({
+    summary: "Get shared TUI terminal frame",
+    description: "Return a deterministic terminal-cell frame that native renderers can paint exactly across Linux and Android.",
+    operationId: "tui.frame",
+    responses: {
+      200: {
+        description: "Shared TUI terminal frame",
+        content: {
+          "application/json": {
+            schema: resolver(TuiSurfaceFrame)
+          }
+        }
+      },
+      ...errors6(400, 404)
+    }
+  }), validator2("query", zod_default.object({
+    sessionID: zod_default.string().optional(),
+    width: zod_default.coerce.number().optional(),
+    height: zod_default.coerce.number().optional()
+  })), async (c4) => {
+    const query2 = c4.req.valid("query");
+    return c4.json(createSurfaceFrame({
+      snapshot: await snapshot4(query2.sessionID),
+      width: query2.width ?? 80,
+      height: query2.height ?? 24
+    }));
   }).post("/action", describeRoute({
     summary: "Dispatch shared TUI action",
     description: "Dispatch a typed action from a native TUI renderer through the shared TUI surface contract.",
@@ -281229,7 +281564,7 @@ var CAPTURING_REGEX_SOURCE, RegexSource = class {
               let localIncludedRule = repository[reference.ruleName];
               if (localIncludedRule) {
                 ruleId = _RuleFactory.getCompiledRuleId(localIncludedRule, helper, repository);
-              }
+              } else {}
               break;
             case 3:
             case 4:
@@ -281241,11 +281576,11 @@ var CAPTURING_REGEX_SOURCE, RegexSource = class {
                   let externalIncludedRule = externalGrammar.repository[externalGrammarInclude];
                   if (externalIncludedRule) {
                     ruleId = _RuleFactory.getCompiledRuleId(externalIncludedRule, helper, externalGrammar.repository);
-                  }
+                  } else {}
                 } else {
                   ruleId = _RuleFactory.getCompiledRuleId(externalGrammar.repository.$self, helper, externalGrammar.repository);
                 }
-              }
+              } else {}
               break;
           }
         } else {
@@ -300492,12 +300827,19 @@ var init_config3 = __esm(async () => {
       }
     }
   }), async (c4) => {
-    using _3 = log18.time("providers");
-    const providers2 = await Provider2.list().then((x4) => i4(x4, (item) => item));
-    return c4.json({
-      providers: Object.values(providers2),
-      default: i4(providers2, (item) => Provider2.sort(Object.values(item.models))[0].id)
-    });
+    let __stack = [];
+    try {
+      const _3 = __using(__stack, log18.time("providers"), 0);
+      const providers2 = await Provider2.list().then((x4) => i4(x4, (item) => item));
+      return c4.json({
+        providers: Object.values(providers2),
+        default: i4(providers2, (item) => Provider2.sort(Object.values(item.models))[0].id)
+      });
+    } catch (_catch3) {
+      var _err = _catch3, _hasErr = 1;
+    } finally {
+      __callDispose(__stack, _err, _hasErr);
+    }
   }));
 });
 
@@ -308501,6 +308843,23 @@ var init_sdk_gen2 = __esm(() => {
         ...params
       });
     }
+    frame(parameters5, options2) {
+      const params = buildClientParams2([parameters5], [
+        {
+          args: [
+            { in: "query", key: "directory" },
+            { in: "query", key: "sessionID" },
+            { in: "query", key: "width" },
+            { in: "query", key: "height" }
+          ]
+        }
+      ]);
+      return (options2?.client ?? this.client).get({
+        url: "/tui/frame",
+        ...options2,
+        ...params
+      });
+    }
     action(parameters5, options2) {
       const params = buildClientParams2([parameters5], [
         {