@cursor/july 0.1.99 → 0.1.101

package/src/internal/advertise-tools.ts

@@ -27,21 +27,25 @@
  * `defineConnection({ effects })` filters the listing before names are
  * assigned: only tools whose MCP annotations classify as an intended
  * effect are advertised. Unclassified tools are omitted, not guessed.
+ * `defineConnection({ tools: [...] })` keeps only the named tools.
+ * `disallowedTools` drops names. A name filter that matches nothing on
+ * the server fails the turn.
  * Tools whose `annotations.title` is `do-not-call` are dropped as well
  * (vendor host-UI / MCP Apps helpers that still carry `readOnlyHint`).
  */
 
-import type {
-  DiscoveredConnection,
-  DiscoveredTool,
-  HostMcpCallResult,
-  HostMcpToolInfo,
-  JsonSchemaObject,
-  McpToolAnnotations,
-  ResolvedAgent,
-  SessionInfo,
-  ToolDefinition,
-  ToolEffect,
+import {
+  connectionAllowsTool,
+  type DiscoveredConnection,
+  type DiscoveredTool,
+  type HostMcpCallResult,
+  type HostMcpToolInfo,
+  type JsonSchemaObject,
+  type McpToolAnnotations,
+  type ResolvedAgent,
+  type SessionInfo,
+  type ToolDefinition,
+  type ToolEffect,
 } from "../types.js";
 import { brandDefinition } from "./brand.js";
 import type { HostMcpOneOff } from "./mcp-host.js";
@@ -136,7 +140,14 @@ export async function resolveAdvertisedTools(args: {
       try {
         const source = await sourceFor(connection, args.session, args.hostMcp);
         const listed = await source.listTools();
-        return { connection, ok: true, source, listed };
+        return {
+          connection,
+          ok: true,
+          source,
+          listed: listed.filter((info) =>
+            connectionAllowsTool(connection, info.name)
+          ),
+        };
       } catch (error) {
         return { connection, ok: false, error };
       }
@@ -157,6 +168,20 @@ export async function resolveAdvertisedTools(args: {
       );
     }
     const { source, listed } = listing;
+    if (
+      (connection.tools !== undefined ||
+        connection.disallowedTools !== undefined) &&
+      listed.length === 0
+    ) {
+      const error = new Error(
+        `Advertised connection "${connection.name}" tool filter matched no tools on the server.`
+      );
+      if (args.onConnectionError !== undefined) {
+        args.onConnectionError(connection.name, error);
+        continue;
+      }
+      throw error;
+    }
     const intended = listed.filter(
       (info) =>
         !isDoNotCallTool(info.annotations) &&

package/src/internal/as-of.ts

@@ -105,3 +105,166 @@ export function timeArgViolation(
   }
   return undefined;
 }
+
+// Whole-string only: a query that merely contains "now" is not a bound.
+// Duration-only strings (`30m`, `2h`) and last/this plus a non-window word
+// (`last modified`) are not time bounds. Calendar-aligned `now/d` is.
+const TIME_UNIT =
+  "(?:s|sec|secs|second|seconds|m|min|mins|minute|minutes|h|hr|hrs|hour|hours|d|day|days|w|week|weeks|mo|month|months|y|yr|yrs|year|years)";
+const WINDOW_WORD =
+  "(?:second|seconds|minute|minutes|hour|hours|day|days|week|weeks|month|months|year|years|quarter|quarters|weekend|monday|tuesday|wednesday|thursday|friday|saturday|sunday|morning|afternoon|evening|night)";
+const RELATIVE_TIME_EXPRESSION = new RegExp(
+  `^(?:now(?:\\s*[+-]\\s*\\d+\\s*${TIME_UNIT}\\b.*|/[a-zA-Z]+.*)?|[+-]\\d+\\s*${TIME_UNIT}|today|yesterday|tomorrow|(?:last|this)\\s+${WINDOW_WORD})$`,
+  "i"
+);
+
+function forwardTimeReason(
+  value: unknown,
+  asOf: string,
+  frozenMs: number
+): string | undefined {
+  if (typeof value !== "string") {
+    return undefined;
+  }
+  const trimmed = value.trim();
+  if (trimmed === "") {
+    return undefined;
+  }
+  if (RELATIVE_TIME_EXPRESSION.test(trimmed)) {
+    return (
+      `Argument ${JSON.stringify(value)} is a relative time expression, ` +
+      `which reads against the real present. This session reads the world ` +
+      `as of ${asOf}; supply an absolute ISO-8601 instant with a timezone ` +
+      `at or before that instant and retry.`
+    );
+  }
+  const instant = parseInstant(trimmed);
+  if (instant !== undefined && instant.getTime() > frozenMs) {
+    return (
+      `Argument ${JSON.stringify(value)} is later than the instant this ` +
+      `session reads the world as of (${asOf}). Supply a bound at or before ` +
+      `that instant and retry.`
+    );
+  }
+  return undefined;
+}
+
+/** Relative expressions or instants after `asOf`. Numeric epochs need `timeArgs`. */
+export function forwardTimeArgument(
+  input: unknown,
+  asOf: string
+): string | undefined {
+  const frozenMs = new Date(asOf).getTime();
+  const seen = new Set<unknown>();
+  const walk = (value: unknown, depth: number): string | undefined => {
+    if (depth > 8) {
+      return undefined;
+    }
+    const reason = forwardTimeReason(value, asOf, frozenMs);
+    if (reason !== undefined) {
+      return reason;
+    }
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        const found = walk(item, depth + 1);
+        if (found !== undefined) {
+          return found;
+        }
+      }
+      return undefined;
+    }
+    if (typeof value === "object" && value !== null) {
+      if (seen.has(value)) {
+        return undefined;
+      }
+      seen.add(value);
+      for (const item of Object.values(value as Record<string, unknown>)) {
+        const found = walk(item, depth + 1);
+        if (found !== undefined) {
+          return found;
+        }
+      }
+    }
+    return undefined;
+  };
+  return walk(input, 0);
+}
+
+/**
+ * Property names that carry a query's time window when a vendor schema
+ * declares them. Deliberately narrower than the embedded-filter key list:
+ * these must be safe to *require*, so only unambiguous window names — never
+ * `timestamp`/`date`, which name data fields more often than bounds.
+ */
+const TIME_WINDOW_KEYS = new Set([
+  "from",
+  "to",
+  "since",
+  "until",
+  "start",
+  "end",
+  "start_time",
+  "end_time",
+  "starttime",
+  "endtime",
+]);
+
+/**
+ * The string-typed time-window properties a tool's input schema declares.
+ * String-typed only: a numeric `from` is a pagination offset more often than
+ * an instant, and requiring an ISO value there would break the call.
+ */
+export function schemaTimeWindowKeys(
+  inputSchema: { properties?: Record<string, unknown> } | undefined
+): string[] {
+  const properties = inputSchema?.properties;
+  if (properties === undefined) {
+    return [];
+  }
+  const keys: string[] = [];
+  for (const [name, spec] of Object.entries(properties)) {
+    if (!TIME_WINDOW_KEYS.has(name.toLowerCase())) {
+      continue;
+    }
+    const type =
+      typeof spec === "object" && spec !== null
+        ? (spec as { type?: unknown }).type
+        : undefined;
+    const types = Array.isArray(type) ? type : [type];
+    if (types.includes("string")) {
+      keys.push(name);
+    }
+  }
+  return keys;
+}
+
+/**
+ * An omitted time window on a vendor tool is not "no window" — the vendor
+ * fills it with a live default (Datadog: `now-1h`..`now`), which the walker
+ * cannot see because the value is never present. In a frozen session a call
+ * that omits a schema-declared window key is refused so the model supplies
+ * the bound explicitly, where {@link forwardTimeArgument} then checks it.
+ */
+export function missingTimeWindow(
+  input: unknown,
+  windowKeys: readonly string[],
+  asOf: string
+): string | undefined {
+  if (windowKeys.length === 0) {
+    return undefined;
+  }
+  const record =
+    typeof input === "object" && input !== null
+      ? (input as Record<string, unknown>)
+      : {};
+  const missing = windowKeys.filter((key) => record[key] === undefined);
+  if (missing.length === 0) {
+    return undefined;
+  }
+  return (
+    `This tool fills omitted time bounds (${missing.join(", ")}) with a ` +
+    `live default window, which reads the real present. This session reads ` +
+    `the world as of ${asOf}; supply each bound explicitly as an absolute ` +
+    `ISO-8601 instant with a timezone at or before that instant and retry.`
+  );
+}

package/src/internal/cli-deploy.ts

@@ -329,6 +329,14 @@ export async function cmdDeploy(options: DeployCliOptions): Promise<number> {
   if (manifests.every((manifest) => manifest.architecture === "v2")) {
     return deployAgentsdkApplication(ctx, options, targets, {
       hasScmChannels: manifests.some((manifest) => manifest.hasScmChannels),
+      declaredSecretNames: [
+        ...new Set(
+          manifests.flatMap((manifest) => manifest.hosting?.secretNames ?? [])
+        ),
+      ],
+      hasDeploymentsChannels: manifests.some(
+        (manifest) => manifest.hasDeploymentsChannels
+      ),
     });
   }
   if (
@@ -741,6 +749,8 @@ async function deployOne(
       agentPath,
       repositories: options.cursorEventsRepos,
       hasScmChannels: manifest.hasScmChannels,
+      declaredSecretNames: hosting?.secretNames,
+      hasDeploymentsChannels: manifest.hasDeploymentsChannels,
       multiTenant: options.multiTenant === true,
     });
   }
@@ -871,7 +881,11 @@ async function deployAgentsdkApplication(
   ctx: DeployCliContext,
   options: DeployCliOptions,
   targets: readonly DeployTarget[],
-  declarations: { hasScmChannels: boolean }
+  declarations: {
+    hasScmChannels: boolean;
+    declaredSecretNames: string[];
+    hasDeploymentsChannels: boolean;
+  }
 ): Promise<number> {
   const parentDir = resolve(options.dir ?? ".");
   const slug = slugFromDirectoryName(basename(parentDir));
@@ -936,16 +950,7 @@ async function deployAgentsdkApplication(
     );
   }
 
-  // Components bake sequentially on the control plane, so the default wait
-  // budget is per component; otherwise a 2+ component deploy routinely hits
-  // the client-side timeout while the server-side deploy is still fine. An
-  // explicitly passed timeout always wins.
-  const waitCtx =
-    options.timeoutMs === undefined
-      ? { ...ctx, timeoutMs: ctx.timeoutMs * targets.length }
-      : ctx;
-
-  return deployOneAgentsdk(waitCtx, undefined, {
+  return deployOneAgentsdk(ctx, undefined, {
     slug,
     gitRepoUrl,
     gitRef,
@@ -953,12 +958,14 @@ async function deployAgentsdkApplication(
     components,
     repositories: options.cursorEventsRepos,
     hasScmChannels: declarations.hasScmChannels,
+    declaredSecretNames: declarations.declaredSecretNames,
+    hasDeploymentsChannels: declarations.hasDeploymentsChannels,
     multiTenant: options.multiTenant === true,
   });
 }
 
 /**
- * `architecture: "v2"` deploy: POST `/internal/agentkit/deployments` and
+ * `architecture: "v2"` deploy: POST `/internal/agentsdk/deployments` and
  * poll the matching GET. The v2 accept path starts freeze bake; it does
  * not mint an engine alias or alias token.
  */
@@ -974,6 +981,10 @@ async function deployOneAgentsdk(
     repositories: string[] | undefined;
     /** Any component declares a GitHub/Origin channel. */
     hasScmChannels: boolean;
+    /** Union of application component secret declarations. */
+    declaredSecretNames?: string[];
+    /** Any component declares a deployments channel (same repo scope). */
+    hasDeploymentsChannels?: boolean;
     /** Redeploy an existing Cursor-managed product. */
     multiTenant: boolean;
   }
@@ -1048,6 +1059,9 @@ async function deployOneAgentsdk(
     );
     return 1;
   }
+  warnMissingSecrets(ctx, slug, args.declaredSecretNames, detail.secretNames);
+  const watchesRepositories =
+    args.hasScmChannels || args.hasDeploymentsChannels === true;
   ctx.out(
     `Deployed ${slug} (team ${ctx.teamId})\n` +
       `  status:       running\n` +
@@ -1059,15 +1073,16 @@ async function deployOneAgentsdk(
         : `  components:   ${args.components
             .map((component) => component.componentKey)
             .join(", ")}\n`) +
-      (detail.repositories === undefined || !args.hasScmChannels
+      (detail.repositories === undefined || !watchesRepositories
         ? ""
         : `  watching:     ${detail.repositories.length === 0 ? "(nothing)" : detail.repositories.join(", ")}\n`)
   );
-  // An agent with GitHub/Origin channels bound to no repository scope gets
-  // no deliveries at all, which is otherwise invisible in this output.
-  if (args.hasScmChannels && detail.repositories?.length === 0) {
+  // An agent with GitHub/Origin/deployments channels bound to no repository
+  // scope gets no deliveries at all (deployments channels receive the
+  // watched repos' deployment events), which is otherwise invisible here.
+  if (watchesRepositories && detail.repositories?.length === 0) {
     ctx.err(
-      `warning: ${slug} watches no repositories, so its GitHub/Origin channels receive no events.\n` +
+      `warning: ${slug} watches no repositories, so its GitHub/Origin/deployments channels receive no events.\n` +
         `  Redeploy with --cursor-events-repo <owner>/<name> to set the scope.\n`
     );
   }
@@ -1185,6 +1200,12 @@ interface DeployManifest {
    * while the deployment is bound to at least one `owner/name` scope.
    */
   hasScmChannels: boolean;
+  /**
+   * The agent has deployments channels; deploy-source edges derive from
+   * the same watched-repo set as GitHub/Origin, so it too receives
+   * nothing while the deployment watches no repositories.
+   */
+  hasDeploymentsChannels: boolean;
 }
 
 /**
@@ -1224,6 +1245,9 @@ async function readDeployManifest(dir: string): Promise<DeployManifest> {
       const kind = channel.definition.meta?.kind;
       return kind === "github" || kind === "origin";
     }),
+    hasDeploymentsChannels: project.channels.some(
+      (channel) => channel.definition.meta?.kind === "deployments"
+    ),
   };
 }
 
@@ -1450,6 +1474,9 @@ function renderAgentkitDeploymentStatus(
       }`
     );
   }
+  if (detail.secretNames !== undefined && detail.secretNames.length > 0) {
+    lines.push(`  secrets:      ${detail.secretNames.join(", ")}`);
+  }
   if (detail.lastError !== null && detail.lastError !== undefined) {
     lines.push(`  last error:   ${sanitizeCustomerError(detail.lastError)}`);
   }
@@ -1478,7 +1505,7 @@ export async function cmdStop(
   // deploy). The v2 agentsdk control plane goes first: v1 endpoints refuse
   // `architecture: "v2"` slugs with a 409 rather than a 404, so v1-first
   // could not fall through. A v2 404 (including an older backend without
-  // the `/internal/agentkit` mount) falls back to the v1 stop.
+  // the `/internal/agentsdk` mount) falls back to the v1 stop.
   let architecture: "v1" | "v2" = "v2";
   let accepted: StopAccepted | AgentkitStopAccepted;
   try {
@@ -1650,6 +1677,21 @@ export async function cmdRotatePodCredential(
 // secrets set|list|unset
 // ============================================================================
 
+async function secretDeploymentArchitecture(
+  ctx: DeployCliContext,
+  slug: string
+): Promise<"v1" | "v2"> {
+  try {
+    await ctx.client.getAgentkitDeploy({ teamId: ctx.teamId, slug });
+    return "v2";
+  } catch (error) {
+    if (error instanceof DeployApiError && error.status === 404) {
+      return "v1";
+    }
+    throw error;
+  }
+}
+
 export async function cmdSecretsSet(
   slug: string | undefined,
   specs: string[],
@@ -1712,11 +1754,19 @@ export async function cmdSecretsSet(
 
   let secretNames: string[];
   try {
-    secretNames = await ctx.client.setSecrets({
-      teamId: ctx.teamId,
-      slug,
-      secrets,
-    });
+    const architecture = await secretDeploymentArchitecture(ctx, slug);
+    secretNames =
+      architecture === "v2"
+        ? await ctx.client.setAgentkitSecrets({
+            teamId: ctx.teamId,
+            slug,
+            secrets,
+          })
+        : await ctx.client.setSecrets({
+            teamId: ctx.teamId,
+            slug,
+            secrets,
+          });
   } catch (error) {
     return renderApiError(error, ctx.err);
   }
@@ -1748,7 +1798,11 @@ export async function cmdSecretsList(
   }
   let secrets: SecretInfo[];
   try {
-    secrets = await ctx.client.listSecrets({ teamId: ctx.teamId, slug });
+    const architecture = await secretDeploymentArchitecture(ctx, slug);
+    secrets =
+      architecture === "v2"
+        ? await ctx.client.listAgentkitSecrets({ teamId: ctx.teamId, slug })
+        : await ctx.client.listSecrets({ teamId: ctx.teamId, slug });
   } catch (error) {
     return renderApiError(error, ctx.err);
   }
@@ -1787,7 +1841,16 @@ export async function cmdSecretsUnset(
     return ctx;
   }
   try {
-    await ctx.client.deleteSecret({ teamId: ctx.teamId, slug, name });
+    const architecture = await secretDeploymentArchitecture(ctx, slug);
+    if (architecture === "v2") {
+      await ctx.client.deleteAgentkitSecret({
+        teamId: ctx.teamId,
+        slug,
+        name,
+      });
+    } else {
+      await ctx.client.deleteSecret({ teamId: ctx.teamId, slug, name });
+    }
   } catch (error) {
     if (error instanceof DeployApiError && error.status === 404) {
       ctx.err(

package/src/internal/continuation-identity.ts

@@ -119,7 +119,9 @@ export const BUILTINS: readonly ContinuationBuiltin[] = [
   {
     type: "deployment",
     kind: "deployments",
-    events: ["deployment.created", "deployment.succeeded"],
+    // All three factory stream events carry `deploymentId`; keep in
+    // lockstep with the control plane's `conversation/deployments.ts`.
+    events: ["deployment.created", "deployment.succeeded", "deployment.failed"],
     format: "deployments:{deploymentId}",
   },
 ] as const;

package/src/internal/conversation-mirror.ts

@@ -383,18 +383,13 @@ export function selectConversationMirror(input: {
     return undefined;
   }
   const env = input.env ?? process.env;
-  const frameworkStoreId = cursorFrameworkStoreSourceId(
-    env as NodeJS.ProcessEnv
-  );
-  if (
-    env[AGENT_SERVE_GENERATION_ENV_VAR] === undefined ||
-    frameworkStoreId === undefined
-  ) {
+  if (env[AGENT_SERVE_GENERATION_ENV_VAR] === undefined) {
     return undefined;
   }
+  const envSnapshot = env as NodeJS.ProcessEnv;
   return createConversationMirror({
     sink: cursorHostedFiles({
-      storeSourceId: frameworkStoreId,
+      resolveStoreSourceId: () => cursorFrameworkStoreSourceId(envSnapshot),
       // Full chain (env → key file → stored login): frozen engines listen
       // unsigned and bind CURSOR_API_KEY_FILE at task time, after this sink
       // is constructed.

package/src/internal/cursor/hosted-deployment-secrets.ts

@@ -0,0 +1,72 @@
+/**
+ * Task-time application secrets for hosted v2 freeze restores.
+ *
+ * The deployment host rewrites this tmpfs document before each admission and
+ * execution request. July reloads it synchronously because the process was
+ * already running in the frozen snapshot when the task-specific values
+ * arrived.
+ */
+
+import { readFileSync } from "node:fs";
+
+export const DEFAULT_AGENT_SERVE_DEPLOYMENT_SECRETS_FILE =
+  "/run/cursor/secrets/AGENT_SERVE_DEPLOYMENT_SECRETS.json";
+
+const SECRET_NAME_PATTERN = /^[A-Z][A-Z0-9_]{0,63}$/;
+const appliedSecretNames = new Set<string>();
+
+function parseBoundSecrets(path: string): Record<string, string> | undefined {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    return undefined;
+  }
+  if (parsed === null || typeof parsed !== "object") {
+    return undefined;
+  }
+  const envelope = parsed as { v?: unknown; secrets?: unknown };
+  if (
+    envelope.v !== 1 ||
+    envelope.secrets === null ||
+    typeof envelope.secrets !== "object" ||
+    Array.isArray(envelope.secrets)
+  ) {
+    return undefined;
+  }
+  const secrets: Record<string, string> = {};
+  for (const [name, value] of Object.entries(envelope.secrets)) {
+    if (
+      SECRET_NAME_PATTERN.test(name) &&
+      !name.startsWith("CURSOR_") &&
+      typeof value === "string"
+    ) {
+      secrets[name] = value;
+    }
+  }
+  return secrets;
+}
+
+/**
+ * Refresh `process.env` from the latest bound document. A missing or malformed
+ * file is a no-op; an empty valid document removes values loaded by an earlier
+ * bind after the deployment secret was unset.
+ */
+export function refreshBoundDeploymentSecrets(
+  path: string = DEFAULT_AGENT_SERVE_DEPLOYMENT_SECRETS_FILE
+): void {
+  const secrets = parseBoundSecrets(path);
+  if (secrets === undefined) {
+    return;
+  }
+  for (const name of appliedSecretNames) {
+    if (!(name in secrets)) {
+      delete process.env[name];
+    }
+  }
+  appliedSecretNames.clear();
+  for (const [name, value] of Object.entries(secrets)) {
+    process.env[name] = value;
+    appliedSecretNames.add(name);
+  }
+}

package/src/internal/cursor/hosted-store-secrets.ts

@@ -0,0 +1,72 @@
+/**
+ * Task-time bind paths for hosted deployment file-store source ids.
+ *
+ * Freeze v2 snapshots start `agent-serve serve` at bake time without a service
+ * account, so neither store id is in process env. Execute-from-freeze binds
+ * the deployment credential and store ids into `/run/cursor/secrets/` without
+ * restarting July — the same pattern as {@link DEFAULT_CURSOR_API_KEY_FILE}.
+ */
+
+import { readFileSync } from "node:fs";
+
+export const DEFAULT_AGENT_SERVE_STORE_SOURCE_ID_FILE =
+  "/run/cursor/secrets/AGENT_SERVE_STORE_SOURCE_ID";
+
+export const DEFAULT_AGENT_SERVE_FRAMEWORK_STORE_SOURCE_ID_FILE =
+  "/run/cursor/secrets/AGENT_SERVE_FRAMEWORK_STORE_SOURCE_ID";
+
+const STORE_SOURCE_ID_ENV = "AGENT_SERVE_STORE_SOURCE_ID";
+const FRAMEWORK_STORE_SOURCE_ID_ENV = "AGENT_SERVE_FRAMEWORK_STORE_SOURCE_ID";
+const STORE_SOURCE_ID_FILE_ENV = "AGENT_SERVE_STORE_SOURCE_ID_FILE";
+const FRAMEWORK_STORE_SOURCE_ID_FILE_ENV =
+  "AGENT_SERVE_FRAMEWORK_STORE_SOURCE_ID_FILE";
+
+function readTrimmedFile(path: string): string | undefined {
+  try {
+    const raw = readFileSync(path, "utf8").trim();
+    return raw === "" ? undefined : raw;
+  } catch {
+    return undefined;
+  }
+}
+
+function readBoundSecretFile(
+  fileEnvVar: string,
+  defaultPath: string,
+  env: NodeJS.ProcessEnv
+): string | undefined {
+  const configured = env[fileEnvVar]?.trim();
+  const path =
+    configured !== undefined && configured !== "" ? configured : defaultPath;
+  return readTrimmedFile(path);
+}
+
+/** Deployment user-land store: env, then task-bind file. */
+export function resolveDeploymentStoreSourceIdSync(
+  env: NodeJS.ProcessEnv = process.env
+): string | undefined {
+  const fromEnv = env[STORE_SOURCE_ID_ENV]?.trim();
+  if (fromEnv !== undefined && fromEnv !== "") {
+    return fromEnv;
+  }
+  return readBoundSecretFile(
+    STORE_SOURCE_ID_FILE_ENV,
+    DEFAULT_AGENT_SERVE_STORE_SOURCE_ID_FILE,
+    env
+  );
+}
+
+/** Engine framework store: env, then task-bind file. */
+export function resolveFrameworkStoreSourceIdSync(
+  env: NodeJS.ProcessEnv = process.env
+): string | undefined {
+  const fromEnv = env[FRAMEWORK_STORE_SOURCE_ID_ENV]?.trim();
+  if (fromEnv !== undefined && fromEnv !== "") {
+    return fromEnv;
+  }
+  return readBoundSecretFile(
+    FRAMEWORK_STORE_SOURCE_ID_FILE_ENV,
+    DEFAULT_AGENT_SERVE_FRAMEWORK_STORE_SOURCE_ID_FILE,
+    env
+  );
+}