@agent-native/core 0.114.16 → 0.115.3

package/corpus/core/src/client/blocks/library/wireframe.tsx

@@ -142,7 +142,7 @@ function ArtboardFrame({
   const fitRef = useRef<HTMLDivElement>(null);
   const isDark = useIsDark();
   const theme: "light" | "dark" = isDark ? "dark" : "light";
-  const style = useWireframeStyle();
+  const preferredStyle = useWireframeStyle();
   const preset = SURFACE_PRESETS[surface] ?? SURFACE_PRESETS.desktop;
   const width = canvasWidth ?? preset.width;
   // AUTO-HEIGHT: with no explicit `canvasSize` the artboard height is driven by
@@ -164,6 +164,7 @@ function ArtboardFrame({
     fixedHeight ?? null,
   );
   const designMode = renderMode === "design";
+  const style = designMode ? "clean" : preferredStyle;
   const sketchy = !designMode && style === "sketchy" && !skeleton;
   const roughEnabled = sketchy && roughOverlay;
   const frameBorder = skeleton
@@ -409,6 +410,7 @@ function KitArtboard({
       surface={data.surface}
       compact={compact}
       skeleton={data.skeleton}
+      renderMode={data.renderMode}
       showFrame={showFrame}
       selector="[data-rough]"
       caption={data.caption}

package/corpus/core/src/client/chat/message-components.tsx

@@ -859,6 +859,27 @@ export function assistantMessageHasUnresolvedTool(content: unknown): boolean {
   });
 }
 
+// Only the last assistant message may shimmer as "the currently running
+// tool" — an older message's dangling unresolved tool-call must never
+// shimmer once a later run is active.
+export function computeLatestRunningToolCallId(
+  content: ContentPart[] | undefined,
+  { chatRunning, isLast }: { chatRunning: boolean; isLast: boolean },
+): string | null {
+  if (!isLast) return null;
+  return (
+    content?.reduce(
+      (latestToolCallId, part) =>
+        part.type === "tool-call" &&
+        part.result === undefined &&
+        (chatRunning || part.activity === true)
+          ? part.toolCallId
+          : latestToolCallId,
+      null as string | null,
+    ) ?? null
+  );
+}
+
 export function shouldShowAssistantMessageFooter({
   isLast,
   chatRunning,
@@ -1157,6 +1178,10 @@ export function AssistantMessage() {
         (p.type !== "tool-call" || p.activity !== true) &&
         isCollapsibleAssistantWorkPart(p),
     );
+  const latestRunningToolCallId = computeLatestRunningToolCallId(msgContent, {
+    chatRunning,
+    isLast,
+  });
 
   if (!hasRenderableContent) return null;
 
@@ -1201,7 +1226,16 @@ export function AssistantMessage() {
               case "reasoning":
                 return <ReasoningMessagePart />;
               case "tool-call":
-                return part.toolUI ?? <ToolCallFallback {...part} />;
+                return (
+                  part.toolUI ?? (
+                    <ToolCallFallback
+                      {...part}
+                      isLatestRunning={
+                        part.toolCallId === latestRunningToolCallId
+                      }
+                    />
+                  )
+                );
               default:
                 return null;
             }

package/corpus/core/src/client/chat/tool-call-display.tsx

@@ -104,6 +104,10 @@ function ToolLongRunningHintShell({
   children: React.ReactNode;
 }) {
   const [showLongRunningHint, setShowLongRunningHint] = useState(false);
+  // useState initializer runs once at mount: a row that mounts already
+  // resolved never animates, while a tool appended during an active stream
+  // mounts running and animates in.
+  const [animateEntry] = useState(isRunning);
 
   useEffect(() => {
     if (!isRunning) {
@@ -118,14 +122,21 @@ function ToolLongRunningHintShell({
   }, [isRunning, toolName]);
 
   return (
-    <>
+    <div
+      className={cn(
+        "agent-tool-call",
+        animateEntry &&
+          "motion-safe:animate-in motion-safe:fade-in-0 motion-safe:slide-in-from-bottom-1 motion-safe:duration-200 motion-safe:ease-[var(--ease-out-strong)]",
+      )}
+      data-running={isRunning ? "true" : undefined}
+    >
       {children}
       {isRunning && showLongRunningHint && (
         <div className="mt-0.5 px-2.5 text-[11px] leading-snug text-muted-foreground/80">
           Still working. Large updates can take a minute or two.
         </div>
       )}
-    </>
+    </div>
   );
 }
 
@@ -542,6 +553,7 @@ export function ToolCallDisplay({
   structuredMeta,
   approval,
   repeatCount,
+  isLatestRunning = isRunning,
 }: {
   toolName: string;
   argsText?: string;
@@ -553,6 +565,7 @@ export function ToolCallDisplay({
   structuredMeta?: Record<string, unknown>;
   approval?: { approvalKey: string; dismissed?: boolean };
   repeatCount?: number;
+  isLatestRunning?: boolean;
 }) {
   // Delegate to bespoke cells when structured metadata is present.
   // These must be separate components so hook order in ToolCallDisplayGeneric
@@ -603,6 +616,7 @@ export function ToolCallDisplay({
       mcpApp={mcpApp}
       chatUI={chatUI}
       isRunning={isRunning}
+      isLatestRunning={isLatestRunning}
       approval={approval}
       repeatCount={repeatCount}
     />,
@@ -617,6 +631,7 @@ function ToolCallDisplayGeneric({
   mcpApp,
   chatUI,
   isRunning,
+  isLatestRunning,
   approval,
   repeatCount,
 }: {
@@ -627,6 +642,7 @@ function ToolCallDisplayGeneric({
   mcpApp?: AgentMcpAppPayload;
   chatUI?: ActionChatUIConfig;
   isRunning: boolean;
+  isLatestRunning: boolean;
   approval?: { approvalKey: string; dismissed?: boolean };
   repeatCount?: number;
 }) {
@@ -786,7 +802,14 @@ function ToolCallDisplayGeneric({
             </>
           )}
         </span>
-        <span className="min-w-0 truncate font-normal">{displayName}</span>
+        <span
+          className={cn(
+            "min-w-0 truncate font-normal",
+            isRunning && isLatestRunning && "agent-running-shimmer",
+          )}
+        >
+          {displayName}
+        </span>
         {repeatCount && repeatCount > 1 && (
           <span
             className="shrink-0 rounded border border-border/60 px-1.5 py-0.5 text-[10px] leading-none text-muted-foreground"
@@ -864,6 +887,7 @@ export function ToolCallFallback({
   activity?: boolean;
   approval?: { approvalKey: string; dismissed?: boolean };
   repeatCount?: number;
+  isLatestRunning?: boolean;
 }) {
   const chatRunning = React.useContext(ChatRunningContext);
   const isRunning =
@@ -884,6 +908,7 @@ export function ToolCallFallback({
       chatUI={rest.chatUI}
       structuredMeta={rest.structuredMeta}
       isRunning={isRunning}
+      isLatestRunning={rest.isLatestRunning}
       approval={rest.approval}
       repeatCount={rest.repeatCount}
     />
@@ -910,6 +935,15 @@ export function ReconnectStreamMessage({
     content.at(-1)?.type === "text" ? content.length - 1 : -1;
   const streamingReasoningPartIndex =
     content.at(-1)?.type === "reasoning" ? content.length - 1 : -1;
+  const latestRunningToolIndex = content.reduce(
+    (latestIndex, part, index) =>
+      part.type === "tool-call" &&
+      part.result === undefined &&
+      (chatRunning || part.activity === true)
+        ? index
+        : latestIndex,
+    -1,
+  );
 
   const renderPart = (part: ContentPart, i: number) => {
     if (part.type === "text") {
@@ -949,6 +983,7 @@ export function ReconnectStreamMessage({
         isRunning={
           part.result === undefined && (chatRunning || part.activity === true)
         }
+        isLatestRunning={i === latestRunningToolIndex}
         approval={part.approval}
         repeatCount={part.repeatCount}
       />

package/corpus/core/src/connections/catalog.ts

@@ -13,6 +13,7 @@ export type WorkspaceConnectionTemplateUse =
   | "calendar"
   | "clips"
   | "content"
+  | "crm"
   | "design"
   | "dispatch"
   | "forms"
@@ -27,6 +28,7 @@ export type WorkspaceConnectionProviderId =
   | "gmail"
   | "google_drive"
   | "hubspot"
+  | "salesforce"
   | "jira"
   | "sentry"
   | "granola"
@@ -239,7 +241,24 @@ export const WORKSPACE_CONNECTION_PROVIDERS = [
       ],
     },
     capabilities: ["search", "import", "crm"],
-    recommendedTemplateUses: ["analytics", "brain", "mail", "dispatch"],
+    recommendedTemplateUses: ["analytics", "brain", "crm", "mail", "dispatch"],
+  }),
+  defineWorkspaceConnectionProvider({
+    id: "salesforce",
+    label: "Salesforce",
+    description:
+      "CRM accounts, contacts, opportunities, custom objects, and activity history for customer-aware apps.",
+    credentialKeys: [],
+    oauth: {
+      provider: "salesforce",
+      authorizationUrl:
+        "https://login.salesforce.com/services/oauth2/authorize",
+      tokenUrl: "https://login.salesforce.com/services/oauth2/token",
+      refreshUrl: "https://login.salesforce.com/services/oauth2/token",
+      scopes: ["api", "refresh_token", "id"],
+    },
+    capabilities: ["search", "import", "crm"],
+    recommendedTemplateUses: ["analytics", "brain", "crm", "dispatch"],
   }),
   defineWorkspaceConnectionProvider({
     id: "jira",

package/corpus/core/src/connections/reader.ts

@@ -506,6 +506,71 @@ export const PROVIDER_READERS = [
     notes:
       "Templates define object allow-lists and property projections; core only documents the reader shape.",
   }),
+  defineProviderReader({
+    providerId: "salesforce",
+    label: "Salesforce reader",
+    description:
+      "Normalized metadata for CRM object lookup through template-owned Salesforce integrations.",
+    implementationStatus: "template-owned",
+    credentialKeys: providerCredentialKeys("salesforce"),
+    requiredCredentialKeys: requiredCredentialKeys("salesforce"),
+    capabilities: [
+      {
+        capability: "search",
+        label: "CRM search",
+        description:
+          "Search Salesforce CRM records with provider-native SOQL or object filters.",
+      },
+      {
+        capability: "crm",
+        label: "CRM retrieval",
+        description:
+          "Read Salesforce standard and custom CRM objects when a template owns object mapping.",
+      },
+    ],
+    operations: [
+      operation(
+        "search",
+        "Search Salesforce CRM",
+        "Find CRM records matching text, SOQL, or provider-native filters.",
+        "template-owned",
+        [
+          ...searchParameters,
+          {
+            name: "objectType",
+            type: "string",
+            description:
+              "Optional Salesforce object API name such as Account, Contact, Opportunity, or a custom object.",
+          },
+        ],
+      ),
+      operation(
+        "get",
+        "Get Salesforce CRM object",
+        "Load one Salesforce CRM record by object API name and id.",
+        "template-owned",
+        [
+          ...getParameters,
+          {
+            name: "objectType",
+            type: "string",
+            required: true,
+            description:
+              "Salesforce object API name such as Account, Contact, Opportunity, or a custom object.",
+          },
+        ],
+      ),
+      operation(
+        "listRecent",
+        "List recent Salesforce CRM objects",
+        "List recently updated CRM records visible to the connected Salesforce user.",
+        "template-owned",
+        listRecentParameters,
+      ),
+    ],
+    notes:
+      "Templates define object allow-lists, field projections, and API-version selection; core only documents the reader shape.",
+  }),
   defineProviderReader({
     providerId: "gmail",
     label: "Gmail reader",

package/corpus/core/src/dashboard-storage/index.ts

@@ -0,0 +1,27 @@
+export {
+  createDashboardStorageSchema,
+  type DashboardStorageSchema,
+  type DashboardStorageSchemaOptions,
+} from "./schema.js";
+export {
+  createDashboardStorage,
+  DashboardStorageConflictError,
+  type DashboardRecord,
+  type DashboardRevisionRecord,
+  type DashboardStorageOptions,
+  type DashboardWriteInput,
+} from "./store.js";
+export {
+  createPanelSourceResolverRegistry,
+  createProgramPanelSourceResolver,
+  parseProgramPanelDescriptor,
+  type DashboardPanelColumn,
+  type PanelSourceFailure,
+  type PanelSourceRequest,
+  type PanelSourceResolver,
+  type PanelSourceResolverRegistry,
+  type PanelSourceResponse,
+  type PanelSourceResult,
+  type ProgramPanelContext,
+  type ProgramPanelDescriptor,
+} from "./panel-source.js";

package/corpus/core/src/dashboard-storage/panel-source.ts

@@ -0,0 +1,168 @@
+import { runDataProgram } from "../data-programs/index.js";
+
+export interface DashboardPanelColumn {
+  name: string;
+  type: string;
+}
+
+export interface PanelSourceRequest<TSource extends string = string> {
+  source: TSource;
+  query: string;
+}
+
+export interface PanelSourceResult {
+  rows: Record<string, unknown>[];
+  schema?: DashboardPanelColumn[];
+  truncated?: boolean;
+  bytesProcessed?: number;
+}
+
+export interface PanelSourceFailure {
+  error: string;
+  message?: string;
+}
+
+export type PanelSourceResponse = PanelSourceResult | PanelSourceFailure;
+
+export interface PanelSourceResolver<
+  TSource extends string = string,
+  TContext = unknown,
+> {
+  source: TSource;
+  resolve(
+    request: PanelSourceRequest<TSource>,
+    context: TContext,
+  ): Promise<PanelSourceResponse>;
+}
+
+export interface PanelSourceResolverRegistry<
+  TSource extends string = string,
+  TContext = unknown,
+> {
+  readonly sources: readonly TSource[];
+  resolve(
+    request: PanelSourceRequest<TSource>,
+    context: TContext,
+  ): Promise<PanelSourceResponse>;
+}
+
+export function createPanelSourceResolverRegistry<
+  TSource extends string = string,
+  TContext = unknown,
+>(options: {
+  resolvers: readonly PanelSourceResolver<TSource, TContext>[];
+}): PanelSourceResolverRegistry<TSource, TContext> {
+  const resolvers = new Map<TSource, PanelSourceResolver<TSource, TContext>>();
+  for (const resolver of options.resolvers) {
+    const source = resolver.source.trim() as TSource;
+    if (!source) throw new Error("Panel source resolver requires a source.");
+    if (resolvers.has(source)) {
+      throw new Error(`Duplicate panel source resolver: ${source}`);
+    }
+    resolvers.set(source, resolver);
+  }
+
+  return {
+    sources: [...resolvers.keys()],
+    async resolve(request, context) {
+      const resolver = resolvers.get(request.source);
+      if (!resolver) {
+        throw new Error(
+          `Unsupported dashboard panel source: ${request.source}`,
+        );
+      }
+      return resolver.resolve(request, context);
+    },
+  };
+}
+
+export interface ProgramPanelContext {
+  userEmail: string;
+  orgId?: string | null;
+}
+
+export interface ProgramPanelDescriptor {
+  programId: string;
+  params?: Record<string, unknown>;
+}
+
+export interface ProgramPanelRunResult {
+  ok: boolean;
+  rows?: Record<string, unknown>[];
+  schema?: DashboardPanelColumn[];
+  truncated?: boolean;
+  lastGoodRun?: {
+    rows: Record<string, unknown>[];
+    schema: DashboardPanelColumn[];
+    truncated?: boolean;
+  };
+  error?: { code: string; message: string };
+}
+
+export function parseProgramPanelDescriptor(
+  query: string,
+): ProgramPanelDescriptor {
+  let value: unknown;
+  try {
+    value = JSON.parse(query);
+  } catch {
+    throw new Error("Program panel query must be a JSON object.");
+  }
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("Program panel query must be a JSON object.");
+  }
+  const descriptor = value as Record<string, unknown>;
+  if (
+    typeof descriptor.programId !== "string" ||
+    !descriptor.programId.trim()
+  ) {
+    throw new Error("Program panel query requires a programId.");
+  }
+  const params =
+    descriptor.params &&
+    typeof descriptor.params === "object" &&
+    !Array.isArray(descriptor.params)
+      ? (descriptor.params as Record<string, unknown>)
+      : undefined;
+  return { programId: descriptor.programId.trim(), params };
+}
+
+export function createProgramPanelSourceResolver(options: {
+  appId: string;
+  run?: (args: {
+    programId: string;
+    appId: string;
+    params?: Record<string, unknown>;
+    ctx: { userEmail: string; orgId: string | null };
+    triggeredBy: "panel_view";
+  }) => Promise<ProgramPanelRunResult>;
+}): PanelSourceResolver<"program", ProgramPanelContext> {
+  const run = options.run ?? runDataProgram;
+  return {
+    source: "program",
+    async resolve(request, context) {
+      const descriptor = parseProgramPanelDescriptor(request.query);
+      const result = await run({
+        programId: descriptor.programId,
+        appId: options.appId,
+        params: descriptor.params,
+        ctx: {
+          userEmail: context.userEmail,
+          orgId: context.orgId ?? null,
+        },
+        triggeredBy: "panel_view",
+      });
+      if (result.ok) {
+        return {
+          rows: result.rows ?? [],
+          schema: result.schema,
+          truncated: result.truncated,
+        };
+      }
+      if (result.lastGoodRun) return result.lastGoodRun;
+      throw new Error(
+        `${result.error?.code ?? "program_failed"}: ${result.error?.message ?? "Data program failed."}`,
+      );
+    },
+  };
+}

package/corpus/core/src/dashboard-storage/schema.ts

@@ -0,0 +1,62 @@
+import {
+  createSharesTable,
+  index,
+  now,
+  ownableColumns,
+  table,
+  text,
+} from "../db/schema.js";
+
+export interface DashboardStorageSchemaOptions {
+  dashboardsTable?: string;
+  revisionsTable?: string;
+  sharesTable?: string;
+}
+
+export function createDashboardStorageSchema(
+  options: DashboardStorageSchemaOptions = {},
+) {
+  const dashboardsTable = options.dashboardsTable ?? "dashboards";
+  const revisionsTable = options.revisionsTable ?? "dashboard_revisions";
+  const sharesTable = options.sharesTable ?? "dashboard_shares";
+
+  const dashboards = table(dashboardsTable, {
+    id: text("id").primaryKey(),
+    kind: text("kind").notNull(),
+    title: text("title").notNull().default("Untitled"),
+    config: text("config").notNull(),
+    createdAt: text("created_at").notNull().default(now()),
+    updatedAt: text("updated_at").notNull().default(now()),
+    updatedBy: text("updated_by"),
+    archivedAt: text("archived_at"),
+    ...ownableColumns(),
+  });
+
+  const dashboardShares = createSharesTable(sharesTable);
+
+  const dashboardRevisions = table(
+    revisionsTable,
+    {
+      id: text("id").primaryKey(),
+      dashboardId: text("dashboard_id").notNull(),
+      kind: text("kind").notNull(),
+      title: text("title").notNull(),
+      config: text("config").notNull(),
+      createdAt: text("created_at").notNull().default(now()),
+      createdBy: text("created_by"),
+      ...ownableColumns(),
+    },
+    (revision) => ({
+      dashboardCreatedIdx: index(`${revisionsTable}_dashboard_created_idx`).on(
+        revision.dashboardId,
+        revision.createdAt,
+      ),
+    }),
+  );
+
+  return { dashboards, dashboardRevisions, dashboardShares };
+}
+
+export type DashboardStorageSchema = ReturnType<
+  typeof createDashboardStorageSchema
+>;