@agent-native/core 0.105.0 → 0.106.1

package/corpus/core/src/templates/workspace-core/.agents/skills/external-agents/SKILL.md

@@ -68,6 +68,52 @@ the real app focused on exactly what was produced. It reuses the existing
 `navigate` / `application_state` contract the UI already drains every 2s (see
 **context-awareness**) — we never invent a second navigation mechanism.
 
+## App-facing MCP connectors
+
+Apps can also consume connected remote MCP servers as a server-side API. The
+framework stores each connector's OAuth client registration, discovery metadata,
+access token, and refresh token in the encrypted `oauth_tokens` store, scoped to
+the user or organization. The browser and sandboxed MCP App iframes never
+receive those credentials.
+
+Use the hidden core actions `list-mcp-tools` and `call-mcp-tool` when an app UI
+needs a request-scoped API surface. Server-side app actions can import
+`listVisibleMcpTools` and `callMcpTool` from `@agent-native/core/mcp-client`.
+Both paths require an authenticated request context and enforce user/org server
+visibility plus MCP App visibility metadata. Pass the configured server id and
+the server's original tool name; the framework resolves the internal prefixed
+tool name and injects the connector's bearer token.
+
+```ts
+import { callMcpTool } from "@agent-native/core/mcp-client";
+
+const result = await callMcpTool("org_acme_linear", "list_issues", {
+  project: "<PROJECT_ID>",
+});
+```
+
+Use this for bounded product workflows (for example, syncing issues or
+refreshing analytics). Do not expose a raw token, arbitrary server URL, or
+unbounded proxy from an app action. Keep provider-specific schemas and access
+checks in the app action, and use the connector catalog/OAuth button for setup.
+
+## Provider API connectors
+
+The shared workspace connection catalog is also the setup surface for provider
+APIs. When a provider advertises OAuth, show that connection as the primary
+setup action and retain its API key or token as an explicit fallback. Current
+shared OAuth providers include Figma, GitHub, Google Drive, HubSpot, Jira Cloud, Notion, and Sentry. Slack
+uses its managed messaging-install OAuth flow. Gmail,
+Calendar, and Slides may use template-owned Google OAuth flows with broader
+scopes; do not replace those flows with the narrower Drive connection.
+
+Provider API actions resolve credentials server-side. Pass a granted
+`connectionId` when a request must use a particular OAuth account; never copy
+the access token into a browser, extension, MCP App, prompt, or stored action
+payload. Key-only providers should remain in the normal scoped secrets flow
+until their upstream OAuth app, scopes, refresh behavior, and identity mapping
+have been implemented and configured.
+
 ## How
 
 ### 1. Connect to hosted apps

package/corpus/templates/analytics/app/lib/data-source-status.ts

@@ -68,7 +68,9 @@ export interface SharedConnectionStatus {
 const dataSourceWorkspaceProviderIds: Record<string, string> = {
   github: "github",
   hubspot: "hubspot",
+  jira: "jira",
   notion: "notion",
+  sentry: "sentry",
   slack: "slack",
 };
 

package/corpus/templates/analytics/app/pages/DataSources.tsx

@@ -26,6 +26,7 @@ import {
   IconCopy,
   IconDotsVertical,
   IconBrandGithub,
+  IconPlugConnected,
 } from "@tabler/icons-react";
 import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query";
 import { useEffect, useState } from "react";
@@ -427,6 +428,55 @@ function GitHubOAuthView({
   );
 }
 
+function WorkspaceOAuthView({
+  provider,
+  label,
+  connected,
+}: {
+  provider: string;
+  label: string;
+  connected: boolean;
+}) {
+  const t = useT();
+  const connect = () => {
+    const params = new URLSearchParams({
+      appId: "analytics",
+      return: "/data-sources",
+    });
+    window.location.assign(
+      agentNativePath(
+        `/_agent-native/connections/oauth/${provider}/start?${params.toString()}`,
+      ),
+    );
+  };
+
+  return (
+    <div className="space-y-3 rounded-md border border-border/50 bg-muted/20 p-3">
+      <div className="flex items-start justify-between gap-3">
+        <div className="flex items-start gap-3">
+          <div className="flex h-8 w-8 shrink-0 items-center justify-center rounded-md bg-background text-muted-foreground">
+            <IconPlugConnected className="h-4 w-4" />
+          </div>
+          <div className="min-w-0 space-y-1">
+            <p className="text-xs font-medium text-foreground">{label}</p>
+            <p className="text-xs text-muted-foreground">
+              {t("dataSources.sharedIntegration")}
+            </p>
+          </div>
+        </div>
+        <Button
+          size="sm"
+          variant={connected ? "outline" : "default"}
+          onClick={connect}
+          className="shrink-0 text-xs"
+        >
+          {connected ? t("dataSources.reconnect") : t("dataSources.connect")}
+        </Button>
+      </div>
+    </div>
+  );
+}
+
 function SharedConnectionBadge({ status }: { status: SharedConnectionStatus }) {
   const tone =
     status.kind === "ready"
@@ -1101,6 +1151,17 @@ function DataSourceCard({
               />
             </div>
           )}
+          {(["notion", "hubspot", "jira", "sentry"] as const).includes(
+            source.id as "notion" | "hubspot" | "jira" | "sentry",
+          ) && (
+            <div className="mb-4">
+              <WorkspaceOAuthView
+                provider={source.id}
+                label={source.name}
+                connected={readyViaWorkspace}
+              />
+            </div>
+          )}
           {sharedConnectionStatus && (
             <SharedConnectionStatusRow status={sharedConnectionStatus} />
           )}

package/corpus/templates/analytics/server/handlers/jira.ts

@@ -1,3 +1,4 @@
+import { resolveWorkspaceConnectionForApp } from "@agent-native/core/workspace-connections";
 import { defineEventHandler, getQuery, setResponseStatus } from "h3";
 
 import {
@@ -17,6 +18,12 @@ import {
 async function requireJiraCredentials(
   event: Parameters<typeof requireCredential>[0],
 ) {
+  const workspaceConnection = await resolveWorkspaceConnectionForApp({
+    appId: "analytics",
+    provider: "jira",
+    requireConnected: true,
+  });
+  if (workspaceConnection.available) return null;
   return (
     (await requireCredential(event, "JIRA_BASE_URL", "Jira")) ||
     (await requireCredential(event, "JIRA_USER_EMAIL", "Jira")) ||

package/corpus/templates/analytics/server/lib/jira.ts

@@ -1,11 +1,7 @@
 // Jira Cloud REST API client
-// Uses Basic auth (email + API token)
 
-import { resolveCredential } from "./credentials";
-import {
-  requireRequestCredentialContext,
-  scopedCredentialCacheKey,
-} from "./credentials-context";
+import { scopedCredentialCacheKey } from "./credentials-context";
+import { executeProviderApiRequest } from "./provider-api";
 
 const API_V3 = "/rest/api/3";
 const API_AGILE = "/rest/agile/1.0";
@@ -15,29 +11,6 @@ const cache = new Map<string, { data: unknown; ts: number }>();
 const CACHE_TTL_MS = 10 * 60 * 1000;
 const MAX_CACHE = 100;
 
-async function getAuth(): Promise<{
-  baseUrl: string;
-  headers: Record<string, string>;
-}> {
-  const ctx = requireRequestCredentialContext("JIRA_BASE_URL");
-  const baseUrl = await resolveCredential("JIRA_BASE_URL", ctx);
-  const email = await resolveCredential("JIRA_USER_EMAIL", ctx);
-  const token = await resolveCredential("JIRA_API_TOKEN", ctx);
-  if (!baseUrl || !email || !token) {
-    throw new Error(
-      "JIRA_BASE_URL, JIRA_USER_EMAIL, and JIRA_API_TOKEN are not configured",
-    );
-  }
-  const encoded = Buffer.from(`${email}:${token}`).toString("base64");
-  return {
-    baseUrl: baseUrl.replace(/\/$/, ""),
-    headers: {
-      Authorization: `Basic ${encoded}`,
-      Accept: "application/json",
-    },
-  };
-}
-
 async function jiraGet<T>(
   path: string,
   params?: Record<string, string>,
@@ -53,21 +26,20 @@ async function jiraGet<T>(
     return cached.data as T;
   }
 
-  const { baseUrl, headers } = await getAuth();
-  const url = new URL(path, baseUrl);
-  if (params) {
-    for (const [k, v] of Object.entries(params)) {
-      url.searchParams.set(k, v);
-    }
-  }
-
-  const res = await fetch(url.toString(), { headers });
-  if (!res.ok) {
-    const text = await res.text();
-    throw new Error(`Jira API error ${res.status}: ${text}`);
+  const result = (await executeProviderApiRequest({
+    provider: "jira",
+    path,
+    query: params,
+  })) as {
+    response: { ok: boolean; status: number; json?: unknown; text?: string };
+  };
+  if (!result.response.ok) {
+    throw new Error(
+      `Jira API error ${result.response.status}: ${String(result.response.text ?? "")}`,
+    );
   }
 
-  const data = await res.json();
+  const data = result.response.json;
   if (cache.size >= MAX_CACHE) {
     const oldest = cache.keys().next().value;
     if (oldest) cache.delete(oldest);

package/corpus/templates/analytics/server/routes/api/test-connection.post.ts

@@ -1,4 +1,5 @@
 import { readBody } from "@agent-native/core/server";
+import { resolveWorkspaceConnectionForApp } from "@agent-native/core/workspace-connections";
 import { defineEventHandler } from "h3";
 
 import {
@@ -141,6 +142,16 @@ export default defineEventHandler(async (event) => {
         }
 
         case "jira": {
+          const workspaceConnection = await resolveWorkspaceConnectionForApp({
+            appId: "analytics",
+            provider: "jira",
+            requireConnected: true,
+          });
+          if (workspaceConnection.available) {
+            const { getProjects } = await import("../../lib/jira");
+            await getProjects();
+            return { ok: true };
+          }
           const baseUrl = await resolveCredential("JIRA_BASE_URL", ctx);
           const email = await resolveCredential("JIRA_USER_EMAIL", ctx);
           const token = await resolveCredential("JIRA_API_TOKEN", ctx);

package/corpus/templates/design/.agents/skills/visual-edit/SKILL.md

@@ -47,6 +47,28 @@ iframe-backed screens on the infinite canvas.
   and create one screen per URL/path. Shorthand like
   `localhost:1234/onboarding/1` means `http://localhost:1234/onboarding/1`.
 
+## Select And Reprompt
+
+When a chat message begins with `[Reprompt selection]`, the selected subtree is
+a hard write boundary. The only mutation path is `propose-node-rewrite` with
+the exact `repromptId`, target, and `baseVersionHash` captured in
+`design-reprompt-pending:<designId>:<fileId>`. Never use `apply-visual-edit`,
+`apply-source-edit`, `write-source`, `write-local-file`, `edit-design`, or any
+other content-writing action for that request. Clarifying questions are allowed,
+but a requested change must remain a proposal.
+
+Produce one variant by default. Produce two or three only when the instruction
+asks for options. A retry includes `priorProposalId`; keep the same target and
+base version, incorporate the feedback, and call `propose-node-rewrite` again.
+The UI previews the returned subtree without persisting it.
+
+Use `resolve-node-rewrite` for the accept/reject lifecycle. Accept applies the
+chosen variant as one version-checked inline/Yjs content transaction so one
+undo restores the prior structure; reject clears the proposal without changing
+content. For conversational resolution such as “apply the second one,” call
+`view-screen`, read the active `design.reprompt.proposal`, and pass its
+`proposalId` plus the zero-based `variantIndex` to `resolve-node-rewrite`.
+
 ## Review Quality
 
 - Treat the running app as the truth. Preserve its component language, tokens,

package/corpus/templates/design/AGENTS.md

@@ -16,6 +16,13 @@ patterns live in `.agents/skills/`.
 - Never hardcode API keys, tokens, webhook URLs, signing secrets, private Builder/internal data, customer data, or credential-looking literals. Use secrets/OAuth/runtime configuration and obvious placeholders in examples.
 - Use the app actions for designs, files, versions, design systems, variants,
   export, and sharing. Do not write design rows directly with SQL.
+- A message beginning with `[Reprompt selection]` is preview-only. Call
+  `propose-node-rewrite` with its exact `repromptId`, target, and base hash;
+  never call `edit-design`, `update-design`, `update-file`, `generate-design`,
+  `apply-visual-edit`, or another content writer. Only the frontend-only
+  `resolve-node-rewrite` action may persist an explicitly accepted proposal.
+- A message beginning with `[Selection question]` is read-only. Answer about
+  the captured element and subtree without calling content-writing actions.
 - When a user wants an established public system as a starting point, call
   `create-design-system` with `templateId: material-3`, `carbon-white`, or
   `primer-light`. These are source-linked, versioned token snapshots with
@@ -268,6 +275,15 @@ patterns live in `.agents/skills/`.
   generation planning state created by `generate-screens` (canvas region
   assignments and per-frame instructions consumed by `generate-design` and
   `view-screen`; not rendered as canvas overlays).
+- `design-reprompt-pending:<designId>:<fileId>` is the client-captured source
+  selection, instruction, base hash, and authoritative current request id for
+  a scoped regenerate request.
+- `design-reprompt-proposal:<designId>:<fileId>:<repromptId>` is one
+  request-specific preview-only subtree proposal. Candidate payloads have a
+  256 KiB aggregate serialized limit. Resolution and cancellation use atomic
+  compare-and-set cleanup so an older request cannot erase a newer one.
+  `view-screen` lists only proposals paired to the current pending request as
+  `pendingCandidateReviews`.
 - `show-design-questions` opens focused pre-generation questions in the main
   design canvas (`show-questions` application state).
 - `guided-questions` may contain a one-click chat choice for the current

package/corpus/templates/design/actions/cancel-node-rewrite-request.ts

@@ -0,0 +1,54 @@
+import { defineAction } from "@agent-native/core";
+import {
+  compareAndSetAppState,
+  readAppState,
+} from "@agent-native/core/application-state";
+import { assertAccess } from "@agent-native/core/sharing";
+import { z } from "zod";
+
+import {
+  designRepromptPendingStateKey,
+  designRepromptProposalStateKey,
+  isNodeRewriteProposal,
+  isPendingDesignReprompt,
+} from "../shared/node-rewrite.js";
+
+export default defineAction({
+  agentTool: false,
+  description:
+    "Cancel one pending node rewrite only when it is still the current request.",
+  schema: z.object({
+    designId: z.string().min(1),
+    fileId: z.string().min(1),
+    repromptId: z.string().min(1),
+  }),
+  run: async ({ designId, fileId, repromptId }) => {
+    await assertAccess("design", designId, "editor");
+    const pendingKey = designRepromptPendingStateKey(designId, fileId);
+    const pending = await readAppState(pendingKey);
+    if (
+      !isPendingDesignReprompt(pending) ||
+      pending.repromptId !== repromptId
+    ) {
+      return { cancelled: false, superseded: true };
+    }
+
+    const proposalKey = designRepromptProposalStateKey(
+      designId,
+      fileId,
+      repromptId,
+    );
+    const proposal = await readAppState(proposalKey);
+    const [pendingCancelled, proposalCancelled] = await Promise.all([
+      compareAndSetAppState(pendingKey, pending, null),
+      isNodeRewriteProposal(proposal)
+        ? compareAndSetAppState(proposalKey, proposal, null)
+        : Promise.resolve(false),
+    ]);
+    return {
+      cancelled: pendingCancelled,
+      proposalCancelled,
+      superseded: !pendingCancelled,
+    };
+  },
+});

package/corpus/templates/design/actions/propose-node-rewrite.ts

@@ -0,0 +1,290 @@
+import { defineAction } from "@agent-native/core";
+import {
+  compareAndSetAppState,
+  readAppState,
+  writeAppState,
+} from "@agent-native/core/application-state";
+import { accessFilter, assertAccess } from "@agent-native/core/sharing";
+import { and, eq } from "drizzle-orm";
+import { nanoid } from "nanoid";
+import { z } from "zod";
+
+import { getDb, schema } from "../server/db/index.js";
+import {
+  readLiveSourceFile,
+  type SourceWorkspaceFile,
+} from "../server/source-workspace.js";
+import type { CodeLayerSource } from "../shared/code-layer.js";
+import {
+  designRepromptPendingStateKey,
+  designRepromptProposalStateKey,
+  MAX_NODE_REWRITE_PROPOSAL_BYTES,
+  resolveNodeRewriteTarget,
+  validateNodeRewriteVariant,
+  type NodeHtmlPreviewBridgeMessage,
+  type NodeRewriteProposal,
+  type NodeRewriteTarget,
+} from "../shared/node-rewrite.js";
+import { designSourceTypeFromData } from "../shared/source-mode.js";
+
+const sourceSchema = z
+  .object({
+    designId: z.string().min(1).optional(),
+    fileId: z.string().min(1).optional(),
+    filename: z.string().min(1).optional(),
+  })
+  .superRefine((source, ctx) => {
+    if (!source.designId && !source.fileId) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ["designId"],
+        message: "source.designId or source.fileId is required",
+      });
+    }
+  });
+
+const targetSchema = z
+  .object({
+    nodeId: z.string().min(1).optional(),
+    selector: z.string().min(1).optional(),
+  })
+  .superRefine((target, ctx) => {
+    if (!target.nodeId && !target.selector) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ["nodeId"],
+        message: "target.nodeId or target.selector is required",
+      });
+    }
+  });
+
+const variantSchema = z.object({
+  html: z
+    .string()
+    .min(1)
+    .max(250_000)
+    .describe("Replacement outerHTML for the selected subtree"),
+  summary: z.string().trim().min(1).max(240),
+});
+
+const pendingRepromptSchema = z.object({
+  repromptId: z.string().min(1),
+  designId: z.string().min(1),
+  fileId: z.string().min(1),
+  target: targetSchema,
+  baseVersionHash: z.string().min(1),
+  instruction: z.string(),
+  createdAt: z.string(),
+  priorProposalId: z.string().min(1).optional(),
+  priorRepromptId: z.string().min(1).optional(),
+});
+
+interface EditableDesignFile extends SourceWorkspaceFile {
+  designData: string | null;
+}
+
+async function resolveEditableDesignFile(source: {
+  designId?: string;
+  fileId?: string;
+  filename?: string;
+}): Promise<EditableDesignFile> {
+  const db = getDb();
+  const conditions = [
+    accessFilter(schema.designs, schema.designShares),
+    source.fileId
+      ? eq(schema.designFiles.id, source.fileId)
+      : eq(schema.designFiles.designId, source.designId ?? ""),
+  ];
+  if (!source.fileId) {
+    conditions.push(
+      eq(schema.designFiles.filename, source.filename ?? "index.html"),
+    );
+  }
+
+  const [file] = await db
+    .select({
+      id: schema.designFiles.id,
+      designId: schema.designFiles.designId,
+      filename: schema.designFiles.filename,
+      fileType: schema.designFiles.fileType,
+      content: schema.designFiles.content,
+      createdAt: schema.designFiles.createdAt,
+      updatedAt: schema.designFiles.updatedAt,
+      designData: schema.designs.data,
+    })
+    .from(schema.designFiles)
+    .innerJoin(
+      schema.designs,
+      eq(schema.designFiles.designId, schema.designs.id),
+    )
+    .where(and(...conditions))
+    .limit(1);
+
+  if (!file) throw new Error("Design HTML file not found.");
+  if (source.designId && source.designId !== file.designId) {
+    throw new Error(
+      `source.designId "${source.designId}" does not match file "${file.id}"`,
+    );
+  }
+  if (source.filename && source.filename !== file.filename) {
+    throw new Error(
+      `source.filename "${source.filename}" does not match file "${file.id}"`,
+    );
+  }
+  if (file.fileType !== "html") {
+    throw new Error("Node rewrites only support HTML design files.");
+  }
+  if (designSourceTypeFromData(file.designData) !== "inline") {
+    throw new Error("Node rewrites only support inline design screens.");
+  }
+  await assertAccess("design", file.designId, "editor");
+  return file;
+}
+
+function targetsMatch(a: NodeRewriteTarget, b: NodeRewriteTarget): boolean {
+  const nodeIdsConflict = a.nodeId && b.nodeId && a.nodeId !== b.nodeId;
+  const selectorsConflict =
+    a.selector && b.selector && a.selector !== b.selector;
+  if (nodeIdsConflict || selectorsConflict) return false;
+  return Boolean(
+    (a.nodeId && b.nodeId && a.nodeId === b.nodeId) ||
+    (a.selector && b.selector && a.selector === b.selector),
+  );
+}
+
+export default defineAction({
+  description:
+    "Propose one to three scoped HTML rewrites for a pending Design selection. " +
+    "This previews only: it stores proposal state and never changes the design file. " +
+    "The target must identify, and the reprompt id and base hash must exactly match, the pending client selection.",
+  schema: z.object({
+    source: sourceSchema,
+    target: targetSchema,
+    baseVersionHash: z.string().min(1),
+    variants: z.array(variantSchema).min(1).max(3),
+    repromptId: z.string().min(1),
+  }),
+  run: async ({ source, target, baseVersionHash, variants, repromptId }) => {
+    const file = await resolveEditableDesignFile(source);
+    const sourceDescriptor: CodeLayerSource = {
+      kind: "design-file",
+      sourceType: "inline",
+      designId: file.designId,
+      fileId: file.id,
+      filename: file.filename,
+    };
+    const live = await readLiveSourceFile(file);
+    if (live.versionHash !== baseVersionHash) {
+      throw new Error(
+        "Screen changed since the selection was captured — regenerate the proposal.",
+      );
+    }
+
+    const pendingKey = designRepromptPendingStateKey(file.designId, file.id);
+    const pending = pendingRepromptSchema.parse(await readAppState(pendingKey));
+    if (pending.repromptId !== repromptId) {
+      throw new Error("Pending reprompt does not match this request.");
+    }
+    if (
+      pending.designId !== file.designId ||
+      pending.fileId !== file.id ||
+      !targetsMatch(pending.target, target)
+    ) {
+      throw new Error(
+        "The proposed target does not match the pending selected subtree.",
+      );
+    }
+    if (pending.baseVersionHash !== baseVersionHash) {
+      throw new Error(
+        "The proposal base hash does not match the pending selection.",
+      );
+    }
+
+    const authoritativeTarget = pending.target;
+    const node = resolveNodeRewriteTarget(
+      live.content,
+      authoritativeTarget,
+      sourceDescriptor,
+    );
+    const validatedVariants = variants.map((variant) =>
+      validateNodeRewriteVariant(variant, sourceDescriptor),
+    );
+    const proposalId = `node-rewrite-${nanoid()}`;
+    const resolvedTarget = {
+      nodeId: node.id,
+      selector: node.selector,
+    };
+    const proposal: NodeRewriteProposal = {
+      proposalId,
+      repromptId,
+      designId: file.designId,
+      fileId: file.id,
+      filename: file.filename,
+      target: authoritativeTarget,
+      resolvedTarget,
+      baseVersionHash,
+      variants: validatedVariants,
+      chosenIndex: 0,
+      createdAt: new Date().toISOString(),
+    };
+    const serializedProposal = JSON.stringify(proposal);
+    if (
+      Buffer.byteLength(serializedProposal, "utf8") >
+      MAX_NODE_REWRITE_PROPOSAL_BYTES
+    ) {
+      throw new Error(
+        "Generated candidates are too large to preview safely. Use fewer variants or regenerate a smaller selected subtree.",
+      );
+    }
+    const proposalKey = designRepromptProposalStateKey(
+      file.designId,
+      file.id,
+      repromptId,
+    );
+    await writeAppState(
+      proposalKey,
+      proposal as unknown as Record<string, unknown>,
+    );
+    const currentPending = await readAppState(pendingKey);
+    if (currentPending?.repromptId !== repromptId) {
+      await compareAndSetAppState(
+        proposalKey,
+        proposal as unknown as Record<string, unknown>,
+        null,
+      );
+      throw new Error(
+        "This regeneration was superseded by a newer request before its candidates were published.",
+      );
+    }
+    if (pending.priorProposalId && pending.priorRepromptId) {
+      const priorProposalKey = designRepromptProposalStateKey(
+        file.designId,
+        file.id,
+        pending.priorRepromptId,
+      );
+      const priorProposal = await readAppState(priorProposalKey);
+      if (priorProposal?.proposalId === pending.priorProposalId) {
+        await compareAndSetAppState(priorProposalKey, priorProposal, null);
+      }
+    }
+
+    const bridgeMessages: NodeHtmlPreviewBridgeMessage[] = [
+      {
+        type: "node-html-preview",
+        proposalId,
+        target: resolvedTarget,
+        html: validatedVariants[0]!.html,
+        operation: "preview",
+      },
+    ];
+    return {
+      proposalId,
+      repromptId,
+      designId: file.designId,
+      fileId: file.id,
+      target: resolvedTarget,
+      variants: validatedVariants,
+      bridgeMessages,
+    };
+  },
+});