@agent-native/core 0.132.1 → 0.133.0

package/corpus/core/src/extensions/url-safety.ts

@@ -167,6 +167,21 @@ function normalizeLookupHostname(hostname: string): string {
   return hostname.toLowerCase().replace(/^\[|\]$/g, "");
 }
 
+function loopbackHostnameVariants(hostname: string): string[] {
+  const normalized = normalizeLookupHostname(hostname);
+  if (
+    normalized !== "localhost" &&
+    normalized !== "127.0.0.1" &&
+    normalized !== "::1"
+  ) {
+    return [normalized];
+  }
+  // Local workspace manifests can identify the same child server as
+  // localhost, 127.0.0.1, or ::1. They are equivalent only for loopback; do
+  // not alias arbitrary private or public hostnames.
+  return ["localhost", "127.0.0.1", "::1"];
+}
+
 function normalizeAllowedPrivateOriginKeys(
   origins: readonly string[],
 ): Set<string> {
@@ -178,7 +193,30 @@ function normalizeAllowedPrivateOriginKeys(
         continue;
       }
       const port = parsed.port || (parsed.protocol === "https:" ? "443" : "80");
-      keys.add(`${normalizeLookupHostname(parsed.hostname)}:${port}`);
+      for (const hostname of loopbackHostnameVariants(parsed.hostname)) {
+        keys.add(`${hostname}:${port}`);
+      }
+    } catch {
+      // coercion-ok: malformed deployment configuration is omitted, preserving the fail-closed private-IP guard.
+    }
+  }
+  return keys;
+}
+
+function normalizeAllowedPrivateOriginOriginKeys(
+  origins: readonly string[],
+): Set<string> {
+  const keys = new Set<string>();
+  for (const origin of origins) {
+    try {
+      const parsed = new URL(origin);
+      if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+        continue;
+      }
+      const port = parsed.port || (parsed.protocol === "https:" ? "443" : "80");
+      for (const hostname of loopbackHostnameVariants(parsed.hostname)) {
+        keys.add(`${parsed.protocol}//${hostname}:${port}`);
+      }
     } catch {
       // Ignore malformed deployment configuration and retain the private-IP guard.
     }
@@ -309,21 +347,17 @@ export async function ssrfSafeFetch(
   const dispatcher =
     (await createSsrfSafeDispatcher(options.allowedPrivateOrigins)) ??
     undefined;
-  const allowedPrivateOrigins = new Set(
-    (options.allowedPrivateOrigins ?? [])
-      .map((origin) => {
-        try {
-          return new URL(origin).origin;
-        } catch {
-          return "";
-        }
-      })
-      .filter(Boolean),
+  const allowedPrivateOrigins = normalizeAllowedPrivateOriginOriginKeys(
+    options.allowedPrivateOrigins ?? [],
   );
   const isAllowedPrivateOrigin = (candidate: string): boolean => {
     if (allowedPrivateOrigins.size === 0) return false;
     try {
-      return allowedPrivateOrigins.has(new URL(candidate).origin);
+      const parsed = new URL(candidate);
+      const port = parsed.port || (parsed.protocol === "https:" ? "443" : "80");
+      return allowedPrivateOrigins.has(
+        `${parsed.protocol}//${normalizeLookupHostname(parsed.hostname)}:${port}`,
+      );
     } catch {
       return false;
     }

package/corpus/core/src/integrations/adapters/slack.ts

@@ -11,7 +11,7 @@ import { consumeIntegrationAwaitingInput } from "../awaiting-input-store.js";
 import { createIntegrationControl } from "../controls-store.js";
 import {
   getActiveIntegrationInstallationByKey,
-  getActiveIntegrationInstallationForTenant,
+  listActiveIntegrationInstallationsForTenant,
   listIntegrationInstallations,
   resolveIntegrationTokenBundle,
 } from "../installations-store.js";
@@ -666,13 +666,18 @@ export function slackAdapter(
           channelId: target.destination,
           threadTs: target.threadRef,
           teamId: target.tenantId,
+          installationKey: target.installationKey,
         },
         tenantId: target.tenantId,
         timestamp: Date.now(),
       };
       const token = await resolveBotToken(targetContext);
       if (!token) {
-        console.error("[slack] SLACK_BOT_TOKEN not configured");
+        console.error(
+          "[slack] no bot token for outbound target" +
+            (target.tenantId ? ` (tenant ${target.tenantId})` : "") +
+            "; set SLACK_BOT_TOKEN or pass installationKey to name the app",
+        );
         return;
       }
 
@@ -808,25 +813,42 @@ async function resolveManagedSlackBotToken(
     typeof incoming.platformContext.enterpriseId === "string"
       ? incoming.platformContext.enterpriseId
       : undefined;
+  const installationKeyHint =
+    typeof incoming.platformContext.installationKey === "string"
+      ? incoming.platformContext.installationKey
+      : undefined;
   if (!teamId && !enterpriseId) return undefined;
   try {
-    let installation = apiAppId
+    let installation = installationKeyHint
       ? await getActiveIntegrationInstallationByKey(
           "slack",
-          slackInstallationKey({ teamId, enterpriseId, apiAppId }),
+          installationKeyHint,
         )
       : null;
-    if (!installation && !apiAppId && teamId) {
-      installation = await getActiveIntegrationInstallationForTenant(
+    if (!installation && apiAppId) {
+      installation = await getActiveIntegrationInstallationByKey(
         "slack",
-        teamId,
+        slackInstallationKey({ teamId, enterpriseId, apiAppId }),
       );
     }
-    if (!installation && !apiAppId && enterpriseId) {
-      installation = await getActiveIntegrationInstallationForTenant(
+    if (!installation && !apiAppId) {
+      // Without an app id the tenant can match several connected Slack apps.
+      // Sending as an arbitrary one posts under the wrong bot identity, so
+      // only proceed when the tenant resolves to exactly one installation.
+      const tenant = teamId ?? enterpriseId!;
+      const candidates = await listActiveIntegrationInstallationsForTenant(
         "slack",
-        enterpriseId,
+        tenant,
       );
+      if (candidates.length > 1) {
+        console.error(
+          `[slack] ${candidates.length} connected Slack apps for tenant ${tenant}; ` +
+            `cannot choose one without an app id. Pass installationKey on the outbound target. ` +
+            `Candidates: ${candidates.map((c) => c.installationKey).join(", ")}`,
+        );
+        return undefined;
+      }
+      installation = candidates[0] ?? null;
     }
     const key =
       installation?.installationKey ??

package/corpus/core/src/integrations/google-docs-poller.ts

@@ -1,3 +1,4 @@
+import { isInBackgroundFunctionRuntime } from "../agent/durable-background.js";
 import { createAnthropicEngine } from "../agent/engine/index.js";
 import type { EngineMessage } from "../agent/engine/types.js";
 import {
@@ -518,7 +519,17 @@ async function processComment(
               signal,
             },
             undefined,
-            { useHostedDefault: true },
+            // Same omission the scheduled-job runner had: without this, a
+            // poller-driven reply inherits the interactive clamp (40s soft
+            // timeout, a no-progress backstop at 0.75x that, 6 continuations)
+            // even though no client is waiting on a response. Uses the runtime
+            // check rather than a hardcoded `true` — matching webhook-handler.ts
+            // in this same subsystem — because unlike the job runner there is no
+            // hard-abort cap here to bound a wider ceiling.
+            {
+              useHostedDefault: true,
+              backgroundFunction: isInBackgroundFunctionRuntime(),
+            },
           ),
       );
     },

package/corpus/core/src/integrations/installations-store.ts

@@ -675,3 +675,33 @@ export async function getActiveIntegrationInstallationForTenant(
     ? toSafeInstallation(rowToRaw(rows[0] as Record<string, unknown>))
     : null;
 }
+
+/**
+ * Every connected installation for a tenant, newest first.
+ *
+ * A workspace can legitimately have several apps of the same platform
+ * connected at once (e.g. a product-specific Slack app alongside a generic
+ * one). Callers that cannot name an app id must see that ambiguity rather
+ * than receive an arbitrary winner — picking the most recently updated row
+ * silently sends as whichever app happened to reconnect last.
+ */
+export async function listActiveIntegrationInstallationsForTenant(
+  platform: string,
+  tenantId: string,
+): Promise<IntegrationInstallation[]> {
+  await ensureTable();
+  const { rows } = await getDbExec().execute({
+    sql: `SELECT * FROM ${TABLE}
+      WHERE platform = ? AND (team_id = ? OR enterprise_id = ?)
+        AND status = 'connected'
+      ORDER BY updated_at DESC`,
+    args: [
+      normalizePlatform(platform),
+      required(tenantId, "tenantId"),
+      required(tenantId, "tenantId"),
+    ],
+  });
+  return rows.map((row) =>
+    toSafeInstallation(rowToRaw(row as Record<string, unknown>)),
+  );
+}

package/corpus/core/src/integrations/plugin.ts

@@ -93,7 +93,6 @@ import {
   INTEGRATION_RETRY_SWEEP_TOKEN_SUBJECT,
   integrationDispatchScopeValue,
   isInIntegrationRecoveryRuntime,
-  isIntegrationDurableDispatchConfigured,
   isIntegrationDurableDispatchEnabledForTask,
 } from "./integration-durable-dispatch.js";
 import {
@@ -1787,15 +1786,16 @@ export function createIntegrationsPlugin(
           setResponseStatus(event, 401);
           return { error: "Invalid or expired internal token" };
         }
-        if (!isIntegrationDurableDispatchConfigured()) {
-          return { ok: true, disabled: true };
-        }
         const webhookBaseUrl = getBaseUrl(event);
         const [pendingTasks, campaigns, a2aContinuations] = await Promise.all([
+          // Portable (fire-and-forget) dispatch loses tasks whenever the
+          // self-dispatch POST dies with the container, and the in-process
+          // retry interval does not survive a serverless freeze. Sweeping only
+          // durable scopes left those deployments with no recovery at all, so
+          // the queue is swept regardless of dispatch mode.
           retryStuckPendingTasks({
             webhookBaseUrl,
             limit: 20,
-            durableOnly: true,
           }).catch((error) => {
             console.error(
               "[integrations] Pending-task recovery failed:",

package/corpus/core/src/integrations/types.ts

@@ -163,6 +163,13 @@ export interface OutboundTarget {
   tenantId?: string;
   /** Managed installation id when the caller already resolved it. */
   installationId?: string;
+  /**
+   * Provider installation key identifying which connected app to send as.
+   * Required when a tenant has more than one app of the same platform
+   * connected — without it the adapter cannot tell them apart and refuses to
+   * guess rather than posting under the wrong bot identity.
+   */
+  installationKey?: string;
 }
 
 /**

package/corpus/core/src/integrations/webhook-handler.ts

@@ -606,7 +606,7 @@ async function enqueueAndDispatch(
         ),
       )
     : PROCESSOR_DISPATCH_SETTLE_WAIT_MS;
-  await dispatchPendingIntegrationTask({
+  const outcome = await dispatchPendingIntegrationTask({
     taskId,
     task: {
       platform: incoming.platform,
@@ -617,6 +617,29 @@ async function enqueueAndDispatch(
     baseUrl,
     portableSettleMs: settleWaitMs,
   });
+
+  // A definitive dispatch failure leaves a queued task nobody is running while
+  // the placeholder above already told the user work had started. Say so
+  // instead of leaving that indicator spinning until the sweep — if it runs.
+  if (outcome === "failed") {
+    console.error(
+      `[integrations] dispatch failed for task ${taskId} (${incoming.platform}/${incoming.externalThreadId})`,
+    );
+    try {
+      await options.adapter.sendResponse(
+        {
+          text: "I couldn't start working on that — the request was accepted but never handed off. Please try again.",
+          platformContext: incoming.platformContext,
+        },
+        incoming,
+      );
+    } catch (err) {
+      console.error(
+        "[integrations] failed to report dispatch failure to user:",
+        err,
+      );
+    }
+  }
 }
 
 /**

package/corpus/core/src/jobs/background-automation-runner.ts

@@ -15,6 +15,7 @@ import {
 } from "../agent/production-agent.js";
 import { runAgentLoopDirectWithSoftTimeout } from "../agent/run-loop-with-resume.js";
 import { resolveRunSoftTimeoutMs, startRun } from "../agent/run-manager.js";
+import { claimBackgroundRun, insertRun } from "../agent/run-store.js";
 import { attachToolSearch } from "../agent/tool-search.js";
 import {
   resolveAutomationExecutionIdentity,
@@ -290,8 +291,23 @@ export async function runBackgroundAutomation(
       const systemPrompt = await deps.getSystemPrompt(ownerEmail);
       const thread = await createThread(ownerEmail, { title: threadTitle });
       const runId = createRunId(options.runIdPrefix);
+      // Scheduled work is background work: it has no synchronous serverless
+      // caller waiting on it, so it must not inherit the interactive clamp
+      // (40s soft timeout, a 30s no-progress backstop at 0.75x that, and 6
+      // continuations). A dashboard render or digest legitimately spends
+      // minutes across many tool calls, and dies the first time any gap
+      // between two of them exceeds 30s — recorded as `no_progress` after
+      // several minutes of real work, because the backstop is suspended
+      // while a tool is in flight but not between tools.
+      //
+      // Hardcoded rather than `isInBackgroundFunctionRuntime()` (what
+      // webhook-handler.ts uses): a webhook can arrive on either runtime, but
+      // a scheduler tick never serves a synchronous request, so the
+      // interactive clamp never applies to it. The wider soft ceiling stays
+      // bounded by this runner's own BACKGROUND_RUN_HARD_TIMEOUT_MS abort.
       const softTimeoutMs = resolveRunSoftTimeoutMs(undefined, {
         useHostedDefault: true,
+        backgroundFunction: true,
       });
 
       const usageRef: {
@@ -300,6 +316,26 @@ export async function runBackgroundAutomation(
       let responseText = "";
       let hardAbortTimer: ReturnType<typeof setTimeout> | null = null;
 
+      // This runner executes in-process, synchronously — there is no HTTP
+      // self-dispatch to a separate worker. Self-claim the row into
+      // 'background-processing' right away, exactly like a genuine HTTP
+      // background worker does immediately after its own insert (see
+      // production-agent.ts's `claimBackgroundWorkerRunEarly`). Without this,
+      // the row sits at dispatch_mode='background' for its whole life with no
+      // worker ever claiming it, which is indistinguishable from a lost HTTP
+      // handoff to the unclaimed-background-run sweep — it gets reaped as
+      // "background_worker_never_started" out from under a still-executing
+      // job the moment any single tool call runs past the 25s grace window.
+      await insertRun(runId, thread.id, undefined, {
+        dispatchMode: "background",
+      });
+      const claimedOwnRun = await claimBackgroundRun(runId);
+      if (!claimedOwnRun) {
+        throw new Error(
+          `Background automation "${automation.name}" (run "${runId}") could not claim its own freshly-inserted run row`,
+        );
+      }
+
       await new Promise<void>((resolve, reject) => {
         const activeRun = startRun(
           runId,
@@ -329,6 +365,7 @@ export async function runBackgroundAutomation(
                 runId,
               },
               softTimeoutMs,
+              { backgroundFunction: true },
             );
           },
           async (run) => {
@@ -360,7 +397,7 @@ export async function runBackgroundAutomation(
           },
           {
             softTimeoutMs,
-            dispatchMode: "background",
+            backgroundFunction: true,
             model,
             engineName: engine.name,
           },

package/corpus/core/src/provider-api/index.ts

@@ -3997,8 +3997,14 @@ async function resolveRequiredCredential(options: {
   connectionId?: string | null;
 }): Promise<ProviderApiResolvedCredential> {
   const credential = await resolveOptionalCredential(options);
-  if (!credential?.value) throw new Error(`${options.key} not configured`);
-  return credential;
+  if (credential?.value) return credential;
+  const scopeGap = await describeCredentialScopeGap([options.key], options.ctx)
+    // coercion-ok: only enriches an error we throw either way — losing the scope
+    // hint still surfaces the real "not configured" failure, never a success.
+    .catch(() => null);
+  throw new Error(
+    `${options.key} not configured${scopeGap ? `. ${scopeGap}` : ""}`,
+  );
 }
 
 async function resolveOptionalCredential(options: {

package/corpus/core/src/scripts/call-agent.ts

@@ -30,6 +30,7 @@ import { findAgent, discoverAgents } from "../server/agent-discovery.js";
 import {
   getRequestUserEmail,
   getRequestOrgId,
+  getRequestRunContext,
   isIntegrationCallerRequest,
   getIntegrationRequestContext,
 } from "../server/request-context.js";
@@ -93,8 +94,13 @@ function buildDelegationCorrelation(
   const inheritedDepth = Number.isInteger(context?.delegationDepth)
     ? Math.max(0, Number(context?.delegationDepth))
     : 0;
+  // The model this turn is actually running on, so a receiver with no model of
+  // its own can match the user's selection instead of its own default. A
+  // preference only — the receiver bounds it to its own engine's catalog.
+  const callerModel = getRequestRunContext()?.model?.trim();
   return {
     ...(selfAppId?.trim() ? { callerApp: selfAppId.trim() } : {}),
+    ...(callerModel ? { callerModel } : {}),
     ...(context?.threadId ? { callerThreadId: context.threadId } : {}),
     ...(context?.runId ? { parentRunId: context.runId } : {}),
     ...(context?.turnId ? { parentTurnId: context.turnId } : {}),

package/corpus/core/src/server/agent-chat-plugin.ts

@@ -58,6 +58,7 @@ import {
   createAnthropicEngine,
   getStoredModelForEngine,
   normalizeModelForEngine,
+  resolveDelegatedRunModel,
   getAgentEngineEntry,
   isAgentEnginePackageInstalled,
   isStoredEngineUsableForRequest,
@@ -83,6 +84,7 @@ import {
   callerHasThreadAccess,
 } from "../agent/run-ownership.js";
 import { markTurnAborted, readBackgroundRunClaim } from "../agent/run-store.js";
+import type { UnclaimedBackgroundRunRow } from "../agent/run-store.js";
 import {
   buildCurrentTimeUserContext,
   buildRuntimeContextPrompt,
@@ -107,10 +109,12 @@ import type {
 import { readAppStateForCurrentTab } from "../application-state/script-helpers.js";
 import { runChatThreadDataMigrations } from "../chat-threads/migrations.js";
 import {
+  adoptThreadScopeIfUnscoped,
   createThread,
   forkThread,
   getThread,
   registerChatThreadsShareable,
+  resolveRunThreadScope,
   resolveThreadAccess,
   listThreads,
   searchThreads,
@@ -1614,13 +1618,17 @@ export function createAgentChatPlugin(
             : await buildSchemaBlock(owner, databaseToolsMode);
           const extra = await resolveExtraContext(context.event, owner);
 
-          const a2aModelCandidate =
-            options?.model ??
-            (await getStoredModelForEngine(a2aEngine, {
+          const model = resolveDelegatedRunModel(a2aEngine, {
+            explicitModel: options?.model,
+            storedModel: await getStoredModelForEngine(a2aEngine, {
               appId: options?.appId,
-            })) ??
-            a2aEngine.defaultModel;
-          const model = normalizeModelForEngine(a2aEngine, a2aModelCandidate);
+            }),
+            // Preference only, and last before the default: an app that pinned
+            // a model keeps it. Read separately from the correlation sanitizer
+            // below so it stays out of every identity/access path.
+            callerModelHint: sanitizeA2ACorrelationMetadata(context.metadata)
+              .callerModel,
+          });
           if (a2aRunContext) {
             a2aRunContext.engine = a2aEngine;
             a2aRunContext.model = model;
@@ -2538,11 +2546,16 @@ export function createAgentChatPlugin(
           getRequestRunContext()?.owner ?? getRequestUserEmail();
         if (!ownerEmail) return;
 
+        const runScope = getRequestRunContext()?.chatScope ?? null;
+
         await withThreadDataLock(threadId, async () => {
           let thread = await getThread(threadId);
           if (!thread) {
             try {
-              thread = await createThread(ownerEmail, { id: threadId });
+              thread = await createThread(ownerEmail, {
+                id: threadId,
+                scope: runScope,
+              });
             } catch {
               thread = await getThread(threadId);
             }
@@ -2566,6 +2579,14 @@ export function createAgentChatPlugin(
             });
           }
 
+          const nextScope = resolveRunThreadScope(thread.scope, runScope);
+          if (nextScope && nextScope !== thread.scope) {
+            thread = {
+              ...thread,
+              scope: await adoptThreadScopeIfUnscoped(threadId, nextScope),
+            };
+          }
+
           let repo: any;
           try {
             repo = JSON.parse(thread.threadData || "{}");
@@ -5878,7 +5899,15 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
       const attemptUnclaimedBackgroundRunRedispatch = async (row: {
         id: string;
         startedAt: number;
+        hasDispatchPayload: boolean;
       }): Promise<void> => {
+        // Eligibility for this sweep does not mean the row is redispatchable.
+        // The marker below asserts `payloadRef: true`, and a worker that then
+        // finds no payload fails the run as `dispatch_payload_missing` — so
+        // redispatching a payload-less row does not recover it, it destroys it.
+        // Leave it for the slow sweep's reap, which reports the true cause
+        // (`background_worker_never_started`) and is client-recoverable.
+        if (!row.hasDispatchPayload) return;
         const { updateRunHeartbeat } = await import("../agent/run-store.js");
         const { resolveAgentChatProcessRunDispatchPath } =
           await import("../agent/durable-background.js");
@@ -5959,7 +5988,7 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
                 // idempotent, re-checks staleness at UPDATE time and honours
                 // the in-flight grace, so it is safe on this cadence.
                 await reapAllStaleRuns().catch(() => {});
-                let rows: { id: string; startedAt: number }[];
+                let rows: UnclaimedBackgroundRunRow[];
                 try {
                   rows = await listUnclaimedBackgroundRunRows();
                 } catch {
@@ -6004,7 +6033,7 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
                 reapUnclaimedBackgroundRun,
                 shouldRedispatchUnclaimedBackgroundRun,
               } = await import("../agent/run-store.js");
-              let rows: { id: string; startedAt: number }[];
+              let rows: UnclaimedBackgroundRunRow[];
               try {
                 rows = await listUnclaimedBackgroundRunRows();
               } catch {
@@ -6012,7 +6041,14 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
               }
               for (const row of rows) {
                 try {
-                  if (shouldRedispatchUnclaimedBackgroundRun(row)) {
+                  // A row with no `dispatch_payload` can never be rehydrated by
+                  // a redispatched worker, so waiting out the redispatch bound
+                  // buys nothing — fall straight through to the reap below and
+                  // fail it loudly with its real cause.
+                  if (
+                    row.hasDispatchPayload &&
+                    shouldRedispatchUnclaimedBackgroundRun(row)
+                  ) {
                     await attemptUnclaimedBackgroundRunRedispatch(row);
                     continue;
                   }

package/corpus/core/src/server/agent-discovery.ts

@@ -101,6 +101,8 @@ export interface WorkspaceAppManifestEntry {
   description: string;
   path: string;
   url?: string | null;
+  /** Local-only child port used to authorize loopback A2A calls. */
+  port?: number;
   isDispatch?: boolean;
   audience?: WorkspaceAppAudience;
   publicPaths?: string[];

package/corpus/core/src/server/builder-design-systems.ts

@@ -57,8 +57,15 @@ export interface BuilderDesignSystemProxyFieldsOptions {
   projectName?: string;
   description?: string;
   surface: "design" | "slides";
+  sourceKind?: BuilderDesignSystemSourceKind;
 }
 
+export type BuilderDesignSystemSourceKind =
+  | "figma"
+  | "code"
+  | "github"
+  | "mixed";
+
 export interface BuilderDesignSystemProxyFields {
   title: string;
   description: string;
@@ -68,6 +75,7 @@ export interface BuilderDesignSystemProxyFields {
 
 export interface BuilderDesignSystemProxyReference {
   source: "builder";
+  sourceKind?: BuilderDesignSystemSourceKind;
   builderDesignSystemId: string;
   builderJobId: string;
   builderProjectId?: string;
@@ -532,6 +540,7 @@ export function createBuilderDesignSystemProxyFields({
   projectName,
   description,
   surface,
+  sourceKind,
 }: BuilderDesignSystemProxyFieldsOptions): BuilderDesignSystemProxyFields {
   const title = projectName?.trim() || "Builder indexed design system";
   const fallbackDescription =
@@ -540,6 +549,7 @@ export function createBuilderDesignSystemProxyFields({
   const spacingKey = surface === "slides" ? "slidePadding" : "pagePadding";
   const data = JSON.stringify({
     source: "builder",
+    ...(sourceKind ? { sourceKind } : {}),
     builderDesignSystemId: result.designSystemId,
     builderJobId: result.jobId,
     builderProjectId: result.projectId,
@@ -611,8 +621,19 @@ export function parseBuilderDesignSystemProxyReference(
   if (value.source !== "builder") return null;
   if (typeof value.builderDesignSystemId !== "string") return null;
   if (typeof value.builderJobId !== "string") return null;
+  const sourceKind = value.sourceKind;
+  if (
+    sourceKind !== undefined &&
+    sourceKind !== "figma" &&
+    sourceKind !== "code" &&
+    sourceKind !== "github" &&
+    sourceKind !== "mixed"
+  ) {
+    return null;
+  }
   return {
     source: "builder",
+    ...(sourceKind ? { sourceKind } : {}),
     builderDesignSystemId: value.builderDesignSystemId,
     builderJobId: value.builderJobId,
     builderProjectId: