fix(build): harden provider catalog packaging

Author: deepagent-ai

.github/workflows/desktop-build.yml

@@ -121,6 +121,7 @@ jobs:
         working-directory: packages/desktop
         env:
           DEEPAGENT_CODE_CHANNEL: ${{ github.event_name == 'push' && 'prod' || (github.event.inputs.channel || 'prod') }}
+          MODELS_DEV_API_JSON: ${{ github.workspace }}/packages/deepagent-code/test/tool/fixtures/models-api.json
           NODE_OPTIONS: --max-old-space-size=4096
         run: bun run build
 

.github/workflows/publish.yml

@@ -94,6 +94,7 @@ jobs:
         env:
           DEEPAGENT_CODE_VERSION: ${{ needs.version.outputs.version }}
           DEEPAGENT_CODE_RELEASE: ${{ needs.version.outputs.release }}
+          MODELS_DEV_API_JSON: ${{ github.workspace }}/packages/deepagent-code/test/tool/fixtures/models-api.json
           GH_REPO: ${{ needs.version.outputs.repo }}
           GH_TOKEN: ${{ steps.committer.outputs.token }}
 
@@ -326,6 +327,7 @@ jobs:
         working-directory: packages/desktop
         env:
           DEEPAGENT_CODE_CHANNEL: ${{ (github.ref_name == 'beta' && 'beta') || 'prod' }}
+          MODELS_DEV_API_JSON: ${{ github.workspace }}/packages/deepagent-code/test/tool/fixtures/models-api.json
           SENTRY_AUTH_TOKEN: ${{ secrets.SENTRY_AUTH_TOKEN }}
           SENTRY_ORG: ${{ vars.SENTRY_ORG }}
           SENTRY_PROJECT: ${{ vars.WEB_SENTRY_PROJECT }}

packages/deepagent-code/script/build-node.ts

@@ -28,6 +28,16 @@ const result = await Bun.build({
   },
 })
 if (!result.success) throw new AggregateError(result.logs, "Failed to build the Node server")
+await Bun.file("./dist/node/models-dev.build.json").write(
+  JSON.stringify(
+    {
+      source: generated.modelsSource,
+      sha256: generated.modelsSha256,
+    },
+    null,
+    2,
+  ),
+)
 
 // Bun preserves CommonJS __dirname/__filename values for bundled dependencies. Those values point
 // at the build machine and are unusable after installation, so make the bundle reproducible and

packages/deepagent-code/script/build.ts

@@ -253,6 +253,10 @@ for (const item of targets) {
           ...(sourceCommit ? { sourceCommit } : {}),
           ...(sourceDirty !== undefined ? { sourceDirty } : {}),
           binarySha256,
+          modelsDev: {
+            source: generated.modelsSource,
+            sha256: generated.modelsSha256,
+          },
         },
       },
       null,

packages/deepagent-code/script/generate.ts

@@ -5,4 +5,11 @@ process.chdir(path.resolve(import.meta.dir, ".."))
 
 const models = await loadModelsData()
 export const modelsData = models.data
-console.log(`Loaded models.dev snapshot from ${models.source}`)
+export const modelsSource = (() => {
+  if (/^https?:\/\//.test(models.source)) return models.source
+  const relative = path.relative(path.resolve(import.meta.dir, ".."), path.resolve(models.source))
+  if (!relative.startsWith("..") && !path.isAbsolute(relative)) return relative.replaceAll("\\", "/")
+  return `external:${path.basename(models.source)}`
+})()
+export const modelsSha256 = models.sha256
+console.log(`Loaded models.dev snapshot from ${models.source} (sha256:${models.sha256})`)

packages/deepagent-code/script/models-data.ts

@@ -1,7 +1,5 @@
 import { mkdir, rename, rm } from "node:fs/promises"
-import os from "node:os"
 import path from "node:path"
-import { resolveDataPath } from "@deepagent-code/core/global-path"
 
 const repositorySnapshotFile = path.resolve(import.meta.dir, "../test/tool/fixtures/models-api.json")
 
@@ -18,7 +16,7 @@ export async function loadModelsData(
   if (configuredFile) {
     const configured = await readCatalog(configuredFile)
     if (!configured) throw new Error(`Configured models.dev snapshot is invalid: ${configuredFile}`)
-    return { data: JSON.stringify(configured), source: configuredFile }
+    return result(configured, configuredFile)
   }
 
   const modelsURL = (environment.DEEPAGENT_CODE_MODELS_URL?.trim() || "https://models.dev").replace(/\/$/, "")
@@ -27,26 +25,34 @@ export async function loadModelsData(
   })
     .then(async (response) => (response.ok ? catalog(await response.json()) : undefined))
     .catch(() => undefined)
-  const cacheFile = options.cacheFile ?? path.join(resolveDataPath(), "cache", "models.json")
   if (remote) {
-    await persistCatalog(cacheFile, remote).catch((error) =>
-      console.warn(
-        `Unable to update models.dev build cache: ${error instanceof Error ? error.message : String(error)}`,
-      ),
-    )
-    return { data: JSON.stringify(remote), source: `${modelsURL}/api.json` }
+    if (options.cacheFile) {
+      await persistCatalog(options.cacheFile, remote).catch((error) =>
+        console.warn(
+          `Unable to update models.dev build cache: ${error instanceof Error ? error.message : String(error)}`,
+        ),
+      )
+    }
+    return result(remote, `${modelsURL}/api.json`)
   }
 
-  const fallbacks = options.fallbackFiles ?? [
-    cacheFile,
-    path.join(os.homedir(), ".cache", "opencode", "models.json"),
-    repositorySnapshotFile,
-  ]
+  // Build inputs must not depend on the builder's DeepAgent/OpenCode runtime caches. A caller may
+  // pass explicit fallback files for tests or controlled builds; the default is the committed copy.
+  const fallbacks = options.fallbackFiles ?? [repositorySnapshotFile]
   const cached = (await Promise.all(fallbacks.map(async (file) => ({ file, data: await readCatalog(file) })))).find(
     (item): item is { file: string; data: Record<string, unknown> } => item.data !== undefined,
   )
   if (!cached) throw new Error(`Unable to load a valid models.dev catalog from ${modelsURL} or local snapshots`)
-  return { data: JSON.stringify(cached.data), source: cached.file }
+  return result(cached.data, cached.file)
+}
+
+function result(data: Record<string, unknown>, source: string) {
+  const serialized = JSON.stringify(data)
+  return {
+    data: serialized,
+    source,
+    sha256: new Bun.CryptoHasher("sha256").update(serialized).digest("hex"),
+  }
 }
 
 function catalog(value: unknown): Record<string, unknown> | undefined {

packages/deepagent-code/test/script/models-data.test.ts

@@ -35,6 +35,7 @@ describe("models.dev build data", () => {
 
     expect(result.source).toBe(file)
     expect(JSON.parse(result.data)).toEqual(catalog)
+    expect(result.sha256).toBe(new Bun.CryptoHasher("sha256").update(JSON.stringify(catalog)).digest("hex"))
   })
 
   test("fetches a fresh catalog and persists the last good copy", async () => {
@@ -79,4 +80,27 @@ describe("models.dev build data", () => {
       "Configured models.dev snapshot is invalid",
     )
   })
+
+  test("does not read or rewrite a builder-local cache when the network is unavailable", async () => {
+    await using directory = await fixture()
+    const cacheFile = path.join(directory.root, "models.json")
+    const builderOnly = {
+      "builder-only": {
+        id: "builder-only",
+        name: "Builder only",
+        models: { leaked: { id: "leaked" } },
+      },
+    }
+    await Bun.write(cacheFile, JSON.stringify(builderOnly))
+
+    const result = await loadModelsData({
+      environment: { DEEPAGENT_CODE_MODELS_URL: "http://127.0.0.1:1" },
+      cacheFile,
+      requestTimeoutMs: 200,
+    })
+
+    expect(result.source).toBe(path.resolve(import.meta.dir, "../tool/fixtures/models-api.json"))
+    expect(JSON.parse(result.data)["builder-only"]).toBeUndefined()
+    expect(await Bun.file(cacheFile).json()).toEqual(builderOnly)
+  })
 })

packages/deepagent-code/test/server/httpapi-provider.test.ts

@@ -263,6 +263,37 @@ function setEnvScoped(key: string, value: string) {
 }
 
 describe("provider HttpApi", () => {
+  it.instance(
+    "only autoloads the public hosted provider for a blank installation",
+    Effect.gen(function* () {
+      const directory = (yield* TestInstance).directory
+      yield* setEnvScoped("DEEPAGENT_CODE_AUTH_CONTENT", "{}")
+
+      const response = yield* request("/provider", {
+        headers: { "x-deepagent-code-directory": directory },
+      })
+      expect(response.status).toBe(200)
+
+      const body = yield* response.json
+      expect(providerList(body, "all").length).toBeGreaterThan(0)
+      expect(isRecord(body) && body.connected).toEqual(["deepagent-code"])
+      expect(isRecord(body) && isRecord(body.default) && Object.keys(body.default).length).toBeGreaterThan(0)
+
+      const hosted = providerByID(body, "all", "deepagent-code")
+      expect(hosted).toBeDefined()
+      expect(isRecord(hosted) && isRecord(hosted.models) && Object.keys(hosted.models).length).toBeGreaterThan(0)
+      expect(
+        isRecord(hosted) &&
+          isRecord(hosted.models) &&
+          Object.values(hosted.models).every(
+            (model) => isRecord(model) && isRecord(model.cost) && model.cost.input === 0,
+          ),
+      ).toBe(true)
+    }),
+    projectOptions,
+    30000,
+  )
+
   it.instance.skip(
     "returns public v2 provider not found errors",
     Effect.gen(function* () {

packages/desktop/electron.vite.config.ts

@@ -56,7 +56,10 @@ export default defineConfig(({ command }) => ({
         async writeBundle() {
           await mkdir("./out/main/chunks", { recursive: true })
           for (const file of await readdir(DEEPAGENT_CODE_SERVER_DIST)) {
-            if (!file.endsWith(".wasm") && (command !== "build" || (file !== "node.js" && file !== "node.js.map")))
+            if (
+              !file.endsWith(".wasm") &&
+              (command !== "build" || !["node.js", "node.js.map", "models-dev.build.json"].includes(file))
+            )
               continue
             await copyFile(`${DEEPAGENT_CODE_SERVER_DIST}/${file}`, `./out/main/chunks/${file}`)
           }

packages/desktop/scripts/audit-package.test.ts

@@ -18,6 +18,11 @@ async function fixture() {
 describe("auditPackageInputs", () => {
   test("accepts generated application assets", async () => {
     await using root = await fixture()
+    await mkdir(path.join(root.root, "out", "main", "chunks"), { recursive: true })
+    await writeFile(
+      path.join(root.root, "out", "main", "chunks", "models-dev.build.json"),
+      JSON.stringify({ source: "test/tool/fixtures/models-api.json", sha256: "a".repeat(64) }),
+    )
     await expect(auditPackageInputs(root.root)).resolves.toBeUndefined()
   })
 
@@ -44,4 +49,27 @@ describe("auditPackageInputs", () => {
     await symlink(path.join(root.root, "out", "main", "index.js"), path.join(root.root, "resources", "linked.js"))
     await expect(auditPackageInputs(root.root)).rejects.toThrow("symbolic link")
   })
+
+  for (const runtimeFile of [
+    "config.json",
+    "config.jsonc",
+    "deepagent-code.json",
+    "deepagent-code.jsonc",
+    "provider-template.jsonc",
+    "mcp-auth.json",
+    "mcp-secrets.json",
+    "models.json",
+    "model.json",
+    "plugin-meta.json",
+    "sessions.json",
+    "artifact-key.json",
+    "token-keyring.json",
+    "password",
+  ]) {
+    test(`rejects runtime configuration or state file ${runtimeFile}`, async () => {
+      await using root = await fixture()
+      await writeFile(path.join(root.root, "resources", runtimeFile), "{}")
+      await expect(auditPackageInputs(root.root)).rejects.toThrow("runtime user-data file")
+    })
+  }
 })