experimental-ash 0.3.0-alpha.37 → 0.3.0-alpha.38

package/dist/docs/public/sandbox.md

@@ -21,7 +21,7 @@ If you never author a sandbox override, the framework default is what you get.
 
 ## Overriding The Sandbox
 
-To customize the sandbox — to add backend options, bootstrap commands, or per-session setup —
+To customize the sandbox — to add bootstrap commands or per-session setup —
 author a sandbox definition module:
 
 ```ts
@@ -29,7 +29,8 @@ author a sandbox definition module:
 import { defineSandbox } from "experimental-ash/sandbox";
 
 export default defineSandbox({
-  async bootstrap({ sandbox }) {
+  async bootstrap({ use }) {
+    const sandbox = await use();
     await sandbox.runCommand("apt-get install -y jq");
   },
 });
@@ -49,8 +50,10 @@ When both are present, the folder layout wins and the top-level shorthand is ign
 
 The public lifecycle surface is intentionally small:
 
-- `bootstrap` — template-scoped setup (runs once when the template is built)
-- `onSession` — durable-session-scoped setup (runs once per session)
+- `bootstrap({ use })` — template-scoped setup (runs once when the template is built). Call `use()`
+  to get a `SandboxSession` for filesystem setup. Only filesystem state survives snapshotting.
+- `onSession({ use })` — durable-session-scoped setup (runs once per session). Call `use(opts?)` to
+  get the backend-specific sandbox (e.g. `VercelSandbox`) with session-level configuration applied.
 - `sandbox.resolvePath(path)` — translate a logical `/workspace/...` path into the live filesystem
 - `sandbox.runCommand(command)` — run a shell command inside the sandbox
 
@@ -182,6 +185,9 @@ Inside a subagent's authored code, `getSandbox()` binds to the subagent's own sa
 - installing dependencies
 - seeding files or directories every later session should start with
 
+Call `use()` to get a `SandboxSession`. Only filesystem state survives — configuration changes
+like network policy or resource allocation do not persist into the snapshot.
+
 Framework-managed seed files (compiled skills, authored `workspace/` entries) are written into the
 template before the authored `bootstrap` runs, so your bootstrap can read them.
 
@@ -189,10 +195,14 @@ template before the authored `bootstrap` runs, so your bootstrap can read them.
 
 `onSession` is durable-session-scoped. Use it for one-time setup for the current Ash session:
 
+- configuring network policy, resources, or timeout
 - creating a session-specific working copy
 - configuring per-user credentials for CLI tools
 - writing one-time markers
-- lightweight setup that should not be baked into the template
+
+Call `use(opts?)` to get the backend-specific sandbox. When using `vercelBackend()`, this returns
+a `VercelSandbox` with `update()` for session-level configuration. Options passed to `use()` are
+applied immediately; you can call `sandbox.update()` again later if needed.
 
 Unlike `bootstrap`, `onSession` runs inside the active Ash runtime context, so user-scoped setup can
 call `getSession()` and derive the current principal without baking credentials into the reusable
@@ -200,10 +210,12 @@ template:
 
 ```ts
 import { getSession } from "experimental-ash/context";
-import { defineSandbox } from "experimental-ash/sandbox";
+import { defineSandbox, vercelBackend } from "experimental-ash/sandbox";
 
 export default defineSandbox({
-  async onSession({ sandbox }) {
+  backend: vercelBackend(),
+  async onSession({ use }) {
+    const sandbox = await use({ networkPolicy: "deny-all" });
     const user = getSession().auth.current;
     if (user === null) return;
 
@@ -219,7 +231,8 @@ export default defineSandbox({
 
 Ash ships two built-in backends, exposed as factory functions from `experimental-ash/sandbox`:
 
-- `vercelBackend(options?)` — runs the sandbox on Vercel Sandbox via `@vercel/sandbox`.
+- `vercelBackend()` — runs the sandbox on Vercel Sandbox via `@vercel/sandbox`. Returns a
+  `VercelSandbox` from `onSession`'s `use()` with full SDK capabilities.
 - `localBackend()` — runs the sandbox locally via `just-bash`. Default for `pnpm ash dev`.
 
 Attach a backend via `defineSandbox({ backend })`:
@@ -229,10 +242,14 @@ Attach a backend via `defineSandbox({ backend })`:
 import { defineSandbox, vercelBackend } from "experimental-ash/sandbox";
 
 export default defineSandbox({
-  backend: vercelBackend({ runtime: "node24" }),
-  async bootstrap({ sandbox }) {
+  backend: vercelBackend(),
+  async bootstrap({ use }) {
+    const sandbox = await use();
     await sandbox.runCommand("git clone https://example.com/repo.git repo");
   },
+  async onSession({ use }) {
+    await use({ networkPolicy: "deny-all" });
+  },
 });
 ```
 
@@ -251,69 +268,90 @@ export default defineSandbox({
 });
 ```
 
-### Vercel Backend Options
+### Vercel Backend: Session Configuration
 
-`vercelBackend(options)` accepts the same parameters as `@vercel/sandbox`'s `Sandbox.create`, minus
-the four fields Ash owns internally (`name`, `persistent`, `source`, `signal`). The option type is
-**inferred** from the SDK so new SDK fields flow through automatically without any ash-side change.
-Hover the `options` argument in your editor to see the live set of fields.
+`vercelBackend()` takes no options. All configuration is done through lifecycle hooks:
+
+- **Immutable creation config** (runtime, ports, env) — passed via `bootstrap`'s `use()`:
 
 ```ts
-vercelBackend({
-  networkPolicy: "deny-all",
-  runtime: "node24",
-  resources: { vcpus: 4 },
-  ports: [3000],
-  env: { NODE_ENV: "production" },
-});
+async bootstrap({ use }) {
+  const sandbox = await use({ runtime: "node24", ports: [3000] });
+  await sandbox.runCommand("npm install");
+}
 ```
 
-Ash also attaches Vercel Sandbox tags for runtime attribution:
+- **Session-level config** (networkPolicy, resources, timeout, tags) — passed via `onSession`'s
+  `use()` or `sandbox.update()`:
 
-- `agent` — the active agent or subagent name
-- `channel` — the active channel adapter kind
-- `sessionId` — the Ash session id
+```ts
+async onSession({ use }) {
+  const sandbox = await use({
+    networkPolicy: "deny-all",
+    resources: { vcpus: 4 },
+    timeout: 60 * 60 * 1_000,
+  });
+  // Can also update later:
+  await sandbox.update({ tags: { user: "casey" } });
+}
+```
+
+This split ensures that `bootstrap` only does filesystem setup (which survives snapshotting), while
+`onSession` configures the live session (network policy, resources, etc. do not survive snapshots).
+
+### Network Policies
 
-Custom `tags` passed to `vercelBackend(options)` are merged with those Ash-owned tags. Vercel
-Sandbox supports at most five tags, so custom tags have two free slots unless they intentionally
-share an Ash-owned key.
+Network policies are set per-session via `onSession`. Three forms are supported:
+
+```ts
+await use({ networkPolicy: "allow-all" }); // default
+await use({ networkPolicy: "deny-all" }); // block all egress, including DNS
+
+await use({
+  networkPolicy: {
+    allow: ["ai-gateway.vercel.sh", "*.github.com"],
+    subnets: { deny: ["10.0.0.0/8"] },
+  },
+});
+```
+
+Since network policy is applied in `onSession` (after the template snapshot), it does not constrain
+`bootstrap`. You can freely `git clone` and `npm install` in bootstrap, then lock down the network
+in `onSession`.
 
 ### Timeout
 
 The `@vercel/sandbox` SDK shuts down idle VMs after a configurable timeout (default 5 minutes). Ash
 raises this default to **30 minutes** so the sandbox survives across workflow step boundaries. You can
-override it via `vercelBackend()`:
+override it in `onSession`:
 
 ```ts
-vercelBackend({ timeout: 60 * 60 * 1_000 }); // 1 hour
+async onSession({ use }) {
+  await use({ timeout: 60 * 60 * 1_000 }); // 1 hour
+}
 ```
 
 The maximum timeout depends on your Vercel plan: **5 hours** for Pro/Enterprise, **45 minutes** for
 Hobby. If a sandbox expires between steps, the next step will fail with a `410 Gone` error.
 
-### Network Policies
+### Tags
 
-The Vercel backend exposes the underlying SDK's `networkPolicy` field unchanged. Three forms are
-supported:
+Ash attaches Vercel Sandbox tags for runtime attribution:
 
-```ts
-vercelBackend({ networkPolicy: "allow-all" }); // default
-vercelBackend({ networkPolicy: "deny-all" }); // block all egress, including DNS
+- `agent` — the active agent or subagent name
+- `channel` — the active channel adapter kind
+- `sessionId` — the Ash session id
 
-vercelBackend({
-  networkPolicy: {
-    allow: ["ai-gateway.vercel.sh", "*.github.com"],
-    subnets: { deny: ["10.0.0.0/8"] },
-  },
-});
+Custom tags can be set via `onSession`:
+
+```ts
+async onSession({ use }) {
+  await use({ tags: { team: "infra" } });
+}
 ```
 
-Important caveat: any options you pass to `vercelBackend()` are applied to **both** the build-time
-template snapshot (when `bootstrap()` runs) and per-session sandbox creation. A restrictive
-`networkPolicy` will therefore also constrain `bootstrap()`. Make sure your bootstrap works within
-whatever constraints you set — for example, a `deny-all` policy will block `git clone` and
-`npm install`. If you need a less restrictive bootstrap, allowlist only the hosts your bootstrap
-needs (e.g. `["registry.npmjs.org"]`) instead of using `deny-all`.
+Vercel Sandbox supports at most five tags. Ash-owned tags take three slots, leaving two for custom
+tags.
 
 ### Custom Backends
 

package/dist/src/chunks/{chunk-2R4UWV4G.js → chunk-5BOA7PVK.js}

@@ -11,7 +11,7 @@ import {
   loadCompiledManifest,
   resolveWorkflowBuildDirectory,
   stringifyEsmImportSpecifier
-} from "./chunk-XQMYWUU7.js";
+} from "./chunk-IKHNAPQA.js";
 import {
   resolvePackageSourceFilePath
 } from "./chunk-E7IAIRUB.js";
@@ -589,4 +589,4 @@ export {
   createAuthoredSourceRuntimeCompiledArtifactsSource,
   prepareApplicationHost
 };
-//# sourceMappingURL=chunk-2R4UWV4G.js.map
+//# sourceMappingURL=chunk-5BOA7PVK.js.map

package/dist/src/chunks/{chunk-XQMYWUU7.js → chunk-IKHNAPQA.js}

@@ -4453,7 +4453,7 @@ function createLocalSandboxBackend() {
         });
         const templateSession = buildSandboxSession(createLocalSessionPrimitives(templateSandbox));
         if (createInput.bootstrap !== void 0) {
-          await createInput.bootstrap(templateSession);
+          await createInput.bootstrap({ use: async () => templateSession });
         }
         const templateSeedFiles = await loadSeedFiles();
         for (const file of templateSeedFiles) {
@@ -4592,8 +4592,10 @@ async function createBashSandbox(input) {
   };
 }
 function createHandle(sandbox) {
+  const session = buildSandboxSession(createLocalSessionPrimitives(sandbox));
   return {
-    session: buildSandboxSession(createLocalSessionPrimitives(sandbox)),
+    session,
+    useSessionFn: async () => session,
     async captureState() {
       const metadata = await sandbox.captureSnapshot() ?? {};
       return {
@@ -4716,8 +4718,7 @@ function localBackend() {
 function createVercelSandboxBackend(input = {}) {
   const loadSandboxModule = input.loadSandboxModule ?? (async () => await import("@vercel/sandbox"));
   const createOptions = {
-    timeout: DEFAULT_SANDBOX_TIMEOUT_MS,
-    ...input.createOptions
+    timeout: DEFAULT_SANDBOX_TIMEOUT_MS
   };
   return {
     name: "vercel",
@@ -4798,7 +4799,7 @@ async function ensureTemplate(input) {
     createVercelSessionPrimitives(sandbox, input.templateKey)
   );
   if (input.bootstrap !== void 0) {
-    await input.bootstrap(templateSession);
+    await input.bootstrap({ use: async () => templateSession });
   }
   const resolvedSeedFiles = input.seedFiles === void 0 ? [] : typeof input.seedFiles === "function" ? await input.seedFiles() : input.seedFiles;
   for (const file of resolvedSeedFiles) {
@@ -4833,6 +4834,19 @@ async function ensureSession(input) {
 function createHandle2(sandbox, sessionKey) {
   return {
     session: buildSandboxSession(createVercelSessionPrimitives(sandbox, sessionKey)),
+    useSessionFn: async (options) => {
+      if (options !== void 0) {
+        const updateParams = {};
+        if (options.networkPolicy !== void 0) updateParams.networkPolicy = options.networkPolicy;
+        if (options.resources !== void 0) updateParams.resources = options.resources;
+        if (options.timeout !== void 0) updateParams.timeout = options.timeout;
+        if (options.tags !== void 0) updateParams.tags = options.tags;
+        if (Object.keys(updateParams).length > 0) {
+          await sandbox.update(updateParams);
+        }
+      }
+      return buildVercelSandbox(sandbox, sessionKey);
+    },
     async captureState() {
       return {
         backendName: "vercel",
@@ -4844,6 +4858,39 @@ function createHandle2(sandbox, sessionKey) {
     }
   };
 }
+function buildVercelSandbox(sandbox, id) {
+  const session = buildSandboxSession(createVercelSessionPrimitives(sandbox, id));
+  return {
+    ...session,
+    get name() {
+      return sandbox.name;
+    },
+    get persistent() {
+      return sandbox.persistent;
+    },
+    get status() {
+      return sandbox.status;
+    },
+    get networkPolicy() {
+      return sandbox.networkPolicy;
+    },
+    get tags() {
+      return sandbox.tags;
+    },
+    async update(params) {
+      await sandbox.update(params);
+    },
+    async stop(opts) {
+      await sandbox.stop(opts);
+    },
+    async snapshot(opts) {
+      return await sandbox.snapshot(opts);
+    },
+    domain(port) {
+      return sandbox.domain(port);
+    }
+  };
+}
 function createVercelSessionPrimitives(sandbox, id) {
   return {
     id,
@@ -4979,8 +5026,8 @@ var DEFAULT_SANDBOX_TIMEOUT_MS = 30 * 60 * 1e3;
 var VERCEL_SANDBOX_TAG_LIMIT = 5;
 
 // src/public/sandbox/backends/vercel.ts
-function vercelBackend(options = {}) {
-  return createVercelSandboxBackend({ createOptions: options });
+function vercelBackend() {
+  return createVercelSandboxBackend();
 }
 
 // src/public/sandbox/backends/default.ts
@@ -6723,19 +6770,30 @@ async function normalizeAuthoredModelReference(input) {
       `Expected the authored agent config export "${source.exportName ?? "default"}" from "${source.logicalPath}" to provide a valid AI SDK language model.`
     );
   }
-  return await withCompiledRuntimeModelLimits(
-    {
-      id: formatLanguageModelGatewayId(languageModel),
-      source: {
-        exportName: source.exportName,
-        sourceKind: "module",
-        logicalPath: source.logicalPath,
-        sourceId: source.sourceId
-      },
-      providerOptions: input.providerOptions === void 0 ? void 0 : parseJsonObject(input.providerOptions)
+  const sourceBackedModel = {
+    id: formatLanguageModelGatewayId(languageModel),
+    source: {
+      exportName: source.exportName,
+      sourceKind: "module",
+      logicalPath: source.logicalPath,
+      sourceId: source.sourceId
     },
-    input
-  );
+    providerOptions: input.providerOptions === void 0 ? void 0 : parseJsonObject(input.providerOptions)
+  };
+  if (input.contextWindowTokens === void 0) {
+    const providerResult = await input.modelCatalog.getByProviderModelId(
+      languageModel.provider,
+      languageModel.modelId
+    );
+    if (providerResult) {
+      return {
+        ...sourceBackedModel,
+        id: providerResult.slug,
+        contextWindowTokens: providerResult.limits.contextWindowTokens
+      };
+    }
+  }
+  return await withCompiledRuntimeModelLimits(sourceBackedModel, input);
 }
 async function withCompiledRuntimeModelLimits(model, input) {
   if (input.contextWindowTokens !== void 0) {
@@ -8647,20 +8705,24 @@ import { join as join17, relative as relative4, resolve as resolve8 } from "node
 import { mkdir as mkdir2, readFile as readFile3, writeFile as writeFile2 } from "node:fs/promises";
 import { join as join14 } from "node:path";
 import { z as z7 } from "zod";
-var AI_GATEWAY_MODELS_URL = "https://ai-gateway.vercel.sh/v1/models";
-var COMPILED_RUNTIME_MODEL_CATALOG_CACHE_KIND = "ash-runtime-model-catalog-cache";
-var COMPILED_RUNTIME_MODEL_CATALOG_CACHE_VERSION = 1;
+var AI_GATEWAY_MODELS_CATALOG_URL = "https://ai-gateway.vercel.sh/v1/models/catalog";
+var COMPILED_RUNTIME_MODEL_CATALOG_CACHE_KIND = "ash-model-catalog-cache";
+var COMPILED_RUNTIME_MODEL_CATALOG_CACHE_VERSION = 2;
 var COMPILED_RUNTIME_MODEL_CATALOG_CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
 var THINKING_SUFFIX = "-thinking";
-var aiGatewayModelCatalogResponseSchema = z7.object({
-  data: z7.array(
-    z7.object({
-      context_window: z7.number().int().nonnegative().optional(),
-      id: z7.string().min(1),
-      max_tokens: z7.number().int().nonnegative().optional()
-    }).passthrough()
-  ),
-  object: z7.literal("list")
+var catalogModelProviderSchema = z7.object({
+  provider: z7.string().min(1),
+  providerModelId: z7.string().min(1),
+  contextWindowTokens: z7.number().int().nonnegative().optional(),
+  maxOutputTokens: z7.number().int().nonnegative().optional()
+}).passthrough();
+var catalogModelSchema = z7.object({
+  slug: z7.string().min(1),
+  providers: z7.array(catalogModelProviderSchema).min(1)
+}).passthrough();
+var modelCatalogResponseSchema = z7.object({
+  models: z7.array(catalogModelSchema),
+  providerAliases: z7.record(z7.string(), z7.string())
 }).passthrough();
 var compiledRuntimeModelLimitsSchema = z7.object({
   contextWindowTokens: z7.number().int().positive(),
@@ -8669,8 +8731,8 @@ var compiledRuntimeModelLimitsSchema = z7.object({
 var compiledRuntimeModelCatalogCacheSchema = z7.object({
   fetchedAt: z7.string(),
   kind: z7.literal(COMPILED_RUNTIME_MODEL_CATALOG_CACHE_KIND),
-  models: z7.record(z7.string(), compiledRuntimeModelLimitsSchema),
-  source: z7.literal("gateway"),
+  models: z7.array(catalogModelSchema),
+  providerAliases: z7.record(z7.string(), z7.string()),
   version: z7.literal(COMPILED_RUNTIME_MODEL_CATALOG_CACHE_VERSION)
 }).strict();
 var builtInCompiledRuntimeModelLimitsById = /* @__PURE__ */ new Map([
@@ -8704,7 +8766,7 @@ function createCompiledRuntimeModelCatalogLoader(appRoot) {
   let fetchedCatalogError = null;
   let fetchedCatalogPromise = null;
   const getCachedCatalog = async () => {
-    cachedCatalogPromise ??= readCompiledRuntimeModelCatalogCache(appRoot);
+    cachedCatalogPromise ??= readModelCatalogCache(appRoot);
     return await cachedCatalogPromise;
   };
   const getFetchedCatalog = async () => {
@@ -8714,7 +8776,7 @@ function createCompiledRuntimeModelCatalogLoader(appRoot) {
     if (fetchedCatalogPromise !== null) {
       return await fetchedCatalogPromise;
     }
-    fetchedCatalogPromise = fetchAndPersistCompiledRuntimeModelCatalog(appRoot).then((catalog) => {
+    fetchedCatalogPromise = fetchAndPersistModelCatalog(appRoot).then((catalog) => {
       cachedCatalogPromise = Promise.resolve(catalog);
       return catalog;
     });
@@ -8725,77 +8787,87 @@ function createCompiledRuntimeModelCatalogLoader(appRoot) {
       throw error;
     }
   };
+  const resolveModelsFromCacheOrFetch = async () => {
+    const cachedCatalog = await getCachedCatalog();
+    if (cachedCatalog !== null && isCacheFresh(cachedCatalog)) {
+      return cachedCatalog;
+    }
+    try {
+      return await getFetchedCatalog();
+    } catch {
+      if (cachedCatalog !== null) {
+        return cachedCatalog;
+      }
+      return null;
+    }
+  };
   return {
     async getModelLimits(modelId) {
-      const normalizedModelId = normalizeModelIdForCatalogLookup(modelId);
-      const cachedCatalog = await getCachedCatalog();
-      const cachedLimits = getCompiledRuntimeModelLimitsFromCache(cachedCatalog, modelId);
-      if (cachedLimits !== null && isCompiledRuntimeModelCatalogCacheFresh(cachedCatalog)) {
-        return cachedLimits;
-      }
-      try {
-        const fetchedCatalog = await getFetchedCatalog();
-        const fetchedLimits = getCompiledRuntimeModelLimitsFromCache(fetchedCatalog, modelId);
-        if (fetchedLimits !== null) {
-          return fetchedLimits;
-        }
-      } catch (error) {
-        if (cachedLimits !== null) {
-          return cachedLimits;
-        }
-        const builtInLimits = builtInCompiledRuntimeModelLimitsById.get(normalizedModelId);
-        if (builtInLimits !== void 0) {
-          return builtInLimits;
+      const normalizedId = normalizeModelId(modelId);
+      const resolved = await resolveModelsFromCacheOrFetch();
+      if (resolved !== null) {
+        const model = findBySlug(resolved.models, normalizedId);
+        if (model) {
+          for (const p of model.providers) {
+            const limits = limitsFromProvider(p);
+            if (limits !== null) {
+              return limits;
+            }
+          }
         }
-        throw error;
       }
-      if (cachedLimits !== null) {
-        return cachedLimits;
+      return builtInCompiledRuntimeModelLimitsById.get(normalizedId) ?? null;
+    },
+    async getByProviderModelId(provider, providerModelId) {
+      const resolved = await resolveModelsFromCacheOrFetch();
+      if (resolved === null) {
+        return null;
       }
-      return builtInCompiledRuntimeModelLimitsById.get(normalizedModelId) ?? null;
+      const baseProvider = provider.split(".")[0];
+      const resolvedProvider = resolved.providerAliases[baseProvider] ?? baseProvider;
+      const normalizedModelId = normalizeModelId(providerModelId);
+      for (const model of resolved.models) {
+        for (const p of model.providers) {
+          if (p.provider === resolvedProvider && normalizeModelId(p.providerModelId) === normalizedModelId) {
+            const limits = limitsFromProvider(p);
+            if (limits !== null) {
+              return { slug: model.slug, limits };
+            }
+          }
+        }
+      }
+      return null;
     }
   };
 }
-async function fetchAndPersistCompiledRuntimeModelCatalog(appRoot) {
-  const response = await fetch(AI_GATEWAY_MODELS_URL);
+async function fetchAndPersistModelCatalog(appRoot) {
+  const response = await fetch(AI_GATEWAY_MODELS_CATALOG_URL);
   if (!response.ok) {
     throw new Error(
       `AI Gateway model catalog request failed with HTTP ${response.status} ${response.statusText}.`
     );
   }
-  const parsed = aiGatewayModelCatalogResponseSchema.safeParse(await response.json());
+  const parsed = modelCatalogResponseSchema.safeParse(await response.json());
   if (!parsed.success) {
     throw new Error("AI Gateway model catalog response did not match the expected schema.");
   }
-  const models = {};
-  for (const model of parsed.data.data) {
-    if (model.context_window === void 0 || model.context_window <= 0) {
-      continue;
-    }
-    const limits = {
-      contextWindowTokens: model.context_window
-    };
-    if (model.max_tokens !== void 0 && model.max_tokens > 0) {
-      limits.maxOutputTokens = model.max_tokens;
-    }
-    models[model.id] = limits;
-  }
   const cacheArtifact = {
     fetchedAt: (/* @__PURE__ */ new Date()).toISOString(),
     kind: COMPILED_RUNTIME_MODEL_CATALOG_CACHE_KIND,
-    models,
-    source: "gateway",
+    models: parsed.data.models,
+    providerAliases: parsed.data.providerAliases,
     version: COMPILED_RUNTIME_MODEL_CATALOG_CACHE_VERSION
   };
-  const cachePath = resolveCompiledRuntimeModelCatalogCachePath(appRoot);
-  await mkdir2(join14(appRoot, ".ash", "cache"), {
-    recursive: true
-  });
-  await writeFile2(cachePath, `${JSON.stringify(cacheArtifact, null, 2)}
+  try {
+    const cachePath = resolveCompiledRuntimeModelCatalogCachePath(appRoot);
+    await mkdir2(join14(appRoot, ".ash", "cache"), { recursive: true });
+    await writeFile2(cachePath, `${JSON.stringify(cacheArtifact, null, 2)}
 `, "utf8");
+  } catch {
+  }
   return cacheArtifact;
 }
-async function readCompiledRuntimeModelCatalogCache(appRoot) {
+async function readModelCatalogCache(appRoot) {
   try {
     const cacheText = await readFile3(resolveCompiledRuntimeModelCatalogCachePath(appRoot), "utf8");
     const parsed = compiledRuntimeModelCatalogCacheSchema.safeParse(JSON.parse(cacheText));
@@ -8807,24 +8879,26 @@ async function readCompiledRuntimeModelCatalogCache(appRoot) {
     return null;
   }
 }
-function getCompiledRuntimeModelLimitsFromCache(cache, modelId) {
-  if (cache === null) {
+function findBySlug(models, slug) {
+  return models.find((m) => m.slug === slug);
+}
+function limitsFromProvider(provider) {
+  if (provider.contextWindowTokens === void 0 || provider.contextWindowTokens <= 0) {
     return null;
   }
-  const cachedModelId = normalizeModelIdForCatalogLookup(modelId);
-  return cache.models[cachedModelId] ?? null;
+  return {
+    contextWindowTokens: provider.contextWindowTokens,
+    ...provider.maxOutputTokens !== void 0 && provider.maxOutputTokens > 0 && { maxOutputTokens: provider.maxOutputTokens }
+  };
 }
-function isCompiledRuntimeModelCatalogCacheFresh(cache) {
-  if (cache === null) {
-    return false;
-  }
+function isCacheFresh(cache) {
   const fetchedAt = Date.parse(cache.fetchedAt);
   if (!Number.isFinite(fetchedAt)) {
     return false;
   }
   return Date.now() - fetchedAt <= COMPILED_RUNTIME_MODEL_CATALOG_CACHE_TTL_MS;
 }
-function normalizeModelIdForCatalogLookup(modelId) {
+function normalizeModelId(modelId) {
   return modelId.endsWith(THINKING_SUFFIX) ? modelId.slice(0, -THINKING_SUFFIX.length) : modelId;
 }
 
@@ -9723,4 +9797,4 @@ export {
   resolveWorkflowBuildDirectory,
   getApplicationInfo
 };
-//# sourceMappingURL=chunk-XQMYWUU7.js.map
+//# sourceMappingURL=chunk-IKHNAPQA.js.map