@agent-native/core 0.182.1 → 0.182.2-nightly-20260917225811

package/corpus/templates/design/shared/component-library.ts

@@ -22,7 +22,11 @@ import {
   buildCodeLayerProjection,
   type CodeLayerSource,
 } from "./code-layer.js";
-import { componentNameFor, isComponentInstance } from "./component-model.js";
+import {
+  COMPONENT_ID_ATTR,
+  COMPONENT_REF_ATTR,
+  componentNameFor,
+} from "./component-model.js";
 
 export interface ComponentLibraryFile {
   id: string;
@@ -34,6 +38,10 @@ export interface ComponentLibraryFile {
 export interface ComponentLibraryEntry {
   /** Component name from `data-agent-native-component`. */
   name: string;
+  /** Opaque id on a canonical component root, when present. */
+  componentId?: string;
+  /** Opaque id referenced by a linked component instance, when present. */
+  componentRef?: string;
   fileId: string;
   filename: string;
   /** `data-agent-native-node-id` (or fallback) of the instance root. */
@@ -50,7 +58,12 @@ export interface ComponentLibraryEntry {
 export function scanComponentLibrary(
   files: ComponentLibraryFile[],
 ): ComponentLibraryEntry[] {
-  const entries: ComponentLibraryEntry[] = [];
+  const entries: Array<
+    Omit<ComponentLibraryEntry, "name"> & {
+      name?: string;
+    }
+  > = [];
+  const namesByIdentity = new Map<string, string>();
 
   for (const file of files) {
     const html = file.content ?? "";
@@ -68,9 +81,15 @@ export function scanComponentLibrary(
     });
 
     for (const node of projection.nodes) {
-      if (!isComponentInstance(node)) continue;
-      const name = componentNameFor(node);
-      if (!name) continue;
+      const name = componentNameFor(node) ?? undefined;
+      const componentId =
+        node.dataAttributes[COMPONENT_ID_ATTR]?.trim() || undefined;
+      const componentRef =
+        node.dataAttributes[COMPONENT_REF_ATTR]?.trim() || undefined;
+      if (!name && !componentId && !componentRef) continue;
+
+      if (name && componentId) namesByIdentity.set(componentId, name);
+      if (name && componentRef) namesByIdentity.set(componentRef, name);
 
       // `node.id` is an ephemeral id scoped to this one projection call — it
       // is NOT the same as the durable `data-agent-native-node-id` attribute
@@ -85,6 +104,8 @@ export function scanComponentLibrary(
 
       entries.push({
         name,
+        componentId,
+        componentRef,
         fileId: file.id,
         filename: file.filename,
         nodeId,
@@ -93,7 +114,16 @@ export function scanComponentLibrary(
     }
   }
 
-  return entries;
+  return entries.flatMap((entry) => {
+    const name =
+      entry.name ??
+      (entry.componentRef
+        ? namesByIdentity.get(entry.componentRef)
+        : entry.componentId
+          ? namesByIdentity.get(entry.componentId)
+          : undefined);
+    return name ? [{ ...entry, name }] : [];
+  });
 }
 
 /**

package/corpus/templates/design/shared/component-model.ts

@@ -44,6 +44,15 @@ export const COMPONENT_OVERRIDES_ATTR = "data-agent-native-component-overrides";
 /** Prefix for simple prop attributes stamped next to the component root. */
 export const COMPONENT_PROP_PREFIX = "data-agent-native-prop-";
 
+/** Return the identity that survives projection rebuilds and reloads. */
+export function stableComponentNodeId(node: CodeLayerNode): string {
+  return node.dataAttributes["data-agent-native-node-id"]?.trim() || node.id;
+}
+
+export function componentIndexId(designId: string, name: string): string {
+  return `ci_${designId}_${name.toLowerCase().replace(/[^a-z0-9]/g, "_")}`;
+}
+
 // ─── Extracted prop value ─────────────────────────────────────────────────────
 
 export interface ComponentPropValue {
@@ -228,14 +237,15 @@ export function instanceFromNode(
   const alpineDataRaw = node.attributes["x-data"];
   const alpineData =
     typeof alpineDataRaw === "string" ? alpineDataRaw : undefined;
+  const stableNodeId = stableComponentNodeId(node);
 
   return {
-    instanceId: node.id,
+    instanceId: stableNodeId,
     name,
     props: extractProps(node),
     alpineData,
     selector: node.selector,
-    nodeId: node.id,
+    nodeId: stableNodeId,
     componentIndexId,
     componentId: node.dataAttributes[COMPONENT_ID_ATTR]?.trim() || undefined,
     componentRef: node.dataAttributes[COMPONENT_REF_ATTR]?.trim() || undefined,

package/corpus/templates/design/shared/local-jsx-visual-edit.ts

@@ -32,7 +32,18 @@ export type LocalJsxLeafIntent =
       from?: string;
       to?: string;
     }
-  | { kind: "style"; property: string; value: string };
+  | { kind: "style"; property: string; value: string }
+  | {
+      kind: "attribute";
+      name: string;
+      value: string;
+      expectedValue?: string;
+    }
+  | {
+      kind: "attributes";
+      values: Record<string, string>;
+      expectedValues?: Record<string, string | undefined>;
+    };
 
 export interface LocalJsxVisualEditResult {
   content: string;
@@ -51,6 +62,23 @@ interface OpeningTag {
   selfClosing: boolean;
 }
 
+export interface LocalJsxLiteralProp {
+  name: string;
+  value: string;
+}
+
+function isEscaped(value: string, index: number): boolean {
+  let backslashes = 0;
+  for (
+    let cursor = index - 1;
+    cursor >= 0 && value[cursor] === "\\";
+    cursor--
+  ) {
+    backslashes += 1;
+  }
+  return backslashes % 2 === 1;
+}
+
 function offsetAt(
   content: string,
   line: number,
@@ -108,7 +136,7 @@ function scanOpeningTags(content: string): OpeningTag[] {
     ) {
       const quote = content[start];
       for (start += 1; start < content.length; start += 1) {
-        if (content[start] === quote && content[start - 1] !== "\\") break;
+        if (content[start] === quote && !isEscaped(content, start)) break;
       }
       continue;
     }
@@ -127,7 +155,7 @@ function scanOpeningTags(content: string): OpeningTag[] {
     ) {
       const char = content[index] ?? "";
       if (quote) {
-        if (char === quote && content[index - 1] !== "\\") quote = "";
+        if (char === quote && !isEscaped(content, index)) quote = "";
         continue;
       }
       if (char === '"' || char === "'") {
@@ -153,6 +181,104 @@ function scanOpeningTags(content: string): OpeningTag[] {
   return tags;
 }
 
+/**
+ * Read quoted component props from the authored opening tag at a verified
+ * source anchor. Dynamic and shorthand attributes make the full literal prop
+ * set uncertain, so this reader fails closed; spreads can shadow every prop.
+ */
+export function readLiteralJsxPropsAtAnchor(args: {
+  content: string;
+  anchor: LocalJsxSourceAnchor;
+}): LocalJsxLiteralProp[] | undefined {
+  const { content, anchor } = args;
+  if (
+    anchor.positionPrecision !== "authored" ||
+    (anchor.runtimeMultiplicity ?? 1) !== 1 ||
+    anchor.scope === "repeated-render" ||
+    anchor.scope === "shared-component-definition"
+  ) {
+    return undefined;
+  }
+  if (offsetAt(content, anchor.line, anchor.column) === null) return undefined;
+  const candidates = scanOpeningTags(content).filter((tag) => {
+    const position = positionAt(content, tag.start);
+    return (
+      position.line === anchor.line &&
+      Math.abs(position.column - anchor.column) <= 1
+    );
+  });
+  if (candidates.length !== 1) return undefined;
+
+  const tag = candidates[0]!;
+  const opening = content.slice(tag.start, tag.end);
+  if (/\{\s*\.\.\./.test(opening)) return undefined;
+
+  const props: LocalJsxLiteralProp[] = [];
+  const reserved = new Set(["children", "key", "ref"]);
+  let sawUnsupported = false;
+  let index = 1 + tag.name.length;
+  while (index < opening.length - 1) {
+    while (/\s/.test(opening[index] ?? "")) index += 1;
+    if (opening[index] === ">" || opening.slice(index, index + 2) === "/>")
+      break;
+    if (opening[index] === "{") {
+      let depth = 0;
+      do {
+        const char = opening[index];
+        if (char === "{") depth += 1;
+        else if (char === "}") depth -= 1;
+        index += 1;
+      } while (index < opening.length && depth > 0);
+      if (depth > 0) return undefined;
+      sawUnsupported = true;
+      continue;
+    }
+
+    const nameMatch = /^[A-Za-z_:][A-Za-z0-9:_.-]*/.exec(opening.slice(index));
+    if (!nameMatch) return undefined;
+    const name = nameMatch[0]!;
+    index += name.length;
+    while (/\s/.test(opening[index] ?? "")) index += 1;
+    if (opening[index] !== "=") {
+      return undefined;
+    }
+    index += 1;
+    while (/\s/.test(opening[index] ?? "")) index += 1;
+    const quote = opening[index];
+    if (quote !== '"' && quote !== "'") {
+      let depth = 0;
+      if (opening[index] === "{") {
+        do {
+          const char = opening[index];
+          if (char === "{") depth += 1;
+          else if (char === "}") depth -= 1;
+          index += 1;
+        } while (index < opening.length && depth > 0);
+      }
+      if (depth > 0) return undefined;
+      sawUnsupported = true;
+      continue;
+    }
+    index += 1;
+    const valueStart = index;
+    while (
+      index < opening.length &&
+      (opening[index] !== quote || isEscaped(opening, index))
+    ) {
+      index += 1;
+    }
+    if (index >= opening.length) return undefined;
+    if (!reserved.has(name)) {
+      props.push({
+        name,
+        value: decodeJsxAttributeValue(opening.slice(valueStart, index)),
+      });
+    }
+    index += 1;
+  }
+  return sawUnsupported && props.length === 0 ? undefined : props;
+}
+
 function fail(
   content: string,
   status: LocalJsxVisualEditResult["result"]["status"],
@@ -190,6 +316,32 @@ function jsxText(value: string): string {
     .join("&#125;");
 }
 
+function jsxAttributeValue(value: string): string {
+  return value
+    .split("&")
+    .join("&amp;")
+    .split('"')
+    .join("&quot;")
+    .split("<")
+    .join("&lt;")
+    .split(">")
+    .join("&gt;");
+}
+
+function decodeJsxAttributeValue(value: string): string {
+  return value
+    .replace(/&quot;/g, '"')
+    .replace(/&apos;/g, "'")
+    .replace(/&lt;/g, "<")
+    .replace(/&gt;/g, ">")
+    .replace(/&amp;/g, "&");
+}
+
+function jsxAttributeName(name: string): string | null {
+  const normalized = name.trim();
+  return /^[A-Za-z_:][A-Za-z0-9:_.-]*$/.test(normalized) ? normalized : null;
+}
+
 function camelProperty(property: string): string | null {
   const value = property
     .trim()
@@ -203,11 +355,11 @@ export function planLocalJsxVisualEdit(args: {
   intent: LocalJsxLeafIntent;
 }): LocalJsxVisualEditResult {
   const { content, anchor, intent } = args;
-  if (anchor.positionPrecision === "transformed") {
+  if (anchor.positionPrecision !== "authored") {
     return fail(
       content,
       "needsAgent",
-      "The source anchor's line and column are the dev server's transformed coordinates (React 19 exposes no authored position), so they cannot be seeked in the authored file.",
+      "The source anchor does not have verified authored coordinates, so it cannot be seeked safely in the authored file.",
     );
   }
   if (
@@ -353,6 +505,80 @@ export function planLocalJsxVisualEdit(args: {
     );
   }
 
+  if (intent.kind === "attribute" || intent.kind === "attributes") {
+    const values =
+      intent.kind === "attribute"
+        ? { [intent.name]: intent.value }
+        : intent.values;
+    const entries = Object.entries(values);
+    if (entries.length === 0) {
+      return fail(
+        content,
+        "unsupported",
+        "At least one JSX attribute is required.",
+      );
+    }
+
+    let nextOpening = opening;
+    for (const [rawName, value] of entries) {
+      const name = jsxAttributeName(rawName);
+      if (!name) {
+        return fail(
+          content,
+          "unsupported",
+          `The JSX attribute name "${rawName}" is not a safe literal identifier.`,
+        );
+      }
+      const escapedName = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      const literal = new RegExp(
+        `(\\s${escapedName}\\s*=\\s*)(["'])((?:\\\\.|(?!\\2)[\\s\\S])*)\\2`,
+        "s",
+      );
+      const literalMatch = literal.exec(nextOpening);
+      const expectedValue =
+        intent.kind === "attribute" && rawName === intent.name
+          ? intent.expectedValue
+          : intent.kind === "attributes"
+            ? intent.expectedValues?.[rawName]
+            : undefined;
+      if (expectedValue !== undefined) {
+        if (
+          !literalMatch ||
+          decodeJsxAttributeValue(literalMatch[3] ?? "") !== expectedValue
+        ) {
+          return fail(
+            content,
+            "conflict",
+            `The JSX prop "${name}" changed since the selected instance was read. Refresh and retry.`,
+          );
+        }
+      }
+      if (literalMatch) {
+        nextOpening = nextOpening.replace(
+          literal,
+          (_match, prefix: string) => `${prefix}"${jsxAttributeValue(value)}"`,
+        );
+        continue;
+      }
+      if (new RegExp(`\\s${escapedName}(?:\\s|=|/?>)`).test(nextOpening)) {
+        return fail(
+          content,
+          "needsAgent",
+          `The JSX attribute "${name}" is dynamic or shorthand and requires semantic source inspection.`,
+        );
+      }
+      const insertAt = nextOpening.lastIndexOf(tag.selfClosing ? "/>" : ">");
+      nextOpening = `${nextOpening.slice(0, insertAt)} ${name}="${jsxAttributeValue(value)}"${nextOpening.slice(insertAt)}`;
+    }
+    return replaceRange(
+      content,
+      tag.start,
+      tag.end,
+      nextOpening,
+      "Literal JSX attributes updated.",
+    );
+  }
+
   const property = camelProperty(intent.property);
   if (!property)
     return fail(

package/corpus/templates/design/shared/source-mode.ts

@@ -117,6 +117,28 @@ export type ElementProvenanceFramework =
   | "angular"
   | "lwc";
 
+/**
+ * Runtime component boundary discovered by a framework bridge. This is
+ * deliberately separate from the durable component annotations used by the
+ * inline component model: the bridge can identify an unannotated React
+ * boundary before promotion, while promotion still writes the canonical
+ * `data-agent-native-component` marker.
+ */
+export interface RuntimeComponentIdentity {
+  componentId: string;
+  instanceId: string;
+  name: string;
+  framework: ElementProvenanceFramework;
+  sourceFile?: string;
+  line?: number;
+  column?: number;
+  method?: ElementProvenanceMethod;
+  ownerKey?: string;
+  props: Array<{ name: string; value: string }>;
+  writeCapability: "authored-jsx-literal" | "unsupported";
+  reason?: string;
+}
+
 export const ELEMENT_PROVENANCE_METHODS: readonly ElementProvenanceMethod[] = [
   "data-attribute",
   "debug-source",

package/dist/automation/index.d.ts

@@ -186,8 +186,8 @@ export declare function createAutomationCallbackHandler(runtime: AutomationRunti
     duplicate?: undefined;
     eventId?: undefined;
 } | {
-    error?: undefined;
     accepted: boolean;
     duplicate: boolean;
     eventId: string;
+    error?: undefined;
 }>;

package/dist/client/AssistantChat.d.ts

@@ -168,8 +168,9 @@ export declare function resolveAssistantChatRunningState({ forceStopped, isRunti
     isRunning: boolean;
     showRunningInUI: boolean;
 };
-export declare function resolveAssistantChatRunningStatusLabel({ runningActivityLabel, isAutoResuming, isReconnecting, hasReconnectContent, labels, }: {
+export declare function resolveAssistantChatRunningStatusLabel({ runningActivityLabel, runningActivityTool, isAutoResuming, isReconnecting, hasReconnectContent, labels, }: {
     runningActivityLabel: string | null | undefined;
+    runningActivityTool?: string | null;
     isAutoResuming: boolean;
     isReconnecting: boolean;
     hasReconnectContent: boolean;
@@ -183,6 +184,8 @@ export declare function resolveAssistantChatRunningStatusLabel({ runningActivity
         preparing?: (activity: string) => string;
         writing?: (activity: string) => string;
         stillGenerating?: (activity: string) => string;
+        runningTool?: (toolName: string) => string;
+        toolDisplayName?: (toolName: string) => string;
     };
 }): string;
 export declare function resolveAssistantChatComposerPlaceholder(composerPlaceholder: string | null | undefined): string;

package/dist/client/AssistantChat.js

@@ -43,6 +43,7 @@ import { claimRunStream, createRunStreamToken, ownsRunStream, releaseRunStream,
 import { signOut } from "./sign-out.js";
 import { AgentAutoContinueSignal, readSSEStreamRaw, settleInterruptedToolCalls, } from "./sse-event-processor.js";
 import { ThinkingDisplayProvider } from "./thinking-display.js";
+import { humanizeToolName, runningToolLabel, toolLabel, } from "./tool-display.js";
 import { callAction, useActionMutation, useActionQuery } from "./use-action.js";
 import { useAgentEngineConfigured } from "./use-agent-engine-configured.js";
 import { appendChatThreadScopeParams, } from "./use-chat-threads.js";
@@ -1129,7 +1130,7 @@ export function resolveAssistantChatRunningState({ forceStopped, isRuntimeRunnin
         showRunningInUI: !forceStopped && !hasTerminalRunError && (isRunning || isAutoResuming),
     };
 }
-export function resolveAssistantChatRunningStatusLabel({ runningActivityLabel, isAutoResuming, isReconnecting, hasReconnectContent, labels = {
+export function resolveAssistantChatRunningStatusLabel({ runningActivityLabel, runningActivityTool, isAutoResuming, isReconnecting, hasReconnectContent, labels = {
     thinking: "Thinking",
     resuming: "Resuming",
     stillWorking: "Still working",
@@ -1143,6 +1144,15 @@ export function resolveAssistantChatRunningStatusLabel({ runningActivityLabel, i
         if (runningActivityLabel === "Contacting model") {
             return labels.contactingModel ?? "Contacting model";
         }
+        // `tool_start` stores the English `runningToolLabel(tool)`. The tool name
+        // rides along in state, so re-derive the label here instead of shipping the
+        // stored English through to the status line.
+        const activityTool = runningActivityTool?.trim();
+        if (activityTool &&
+            labels.runningTool &&
+            runningActivityLabel === runningToolLabel(activityTool)) {
+            return labels.runningTool(activityTool);
+        }
         const localizedActivityPatterns = [
             [/^Starting (.+)\.\.\.$/, labels.starting],
             [/^Preparing (.+)\.\.\.$/, labels.preparing],
@@ -1151,8 +1161,16 @@ export function resolveAssistantChatRunningStatusLabel({ runningActivityLabel, i
         ];
         for (const [pattern, translateActivity] of localizedActivityPatterns) {
             const match = runningActivityLabel.match(pattern);
-            if (match?.[1] && translateActivity)
-                return translateActivity(match[1]);
+            if (match?.[1] && translateActivity) {
+                // The captured activity is the derived action name. When it matches the
+                // tool this run is on, prefer the app's catalog label for it.
+                const activity = activityTool &&
+                    labels.toolDisplayName &&
+                    match[1] === humanizeToolName(activityTool)
+                    ? labels.toolDisplayName(activityTool)
+                    : match[1];
+                return translateActivity(activity);
+            }
         }
         return runningActivityLabel;
     }
@@ -2123,6 +2141,7 @@ const AssistantChatInner = forwardRef(function AssistantChatInner({ emptyStateTe
     // ongoing work instead of exposing "Reconnecting" mid-chat.
     const runningStatusLabel = resolveAssistantChatRunningStatusLabel({
         runningActivityLabel,
+        runningActivityTool,
         isAutoResuming,
         isReconnecting,
         hasReconnectContent: reconnectContent.length > 0,
@@ -2136,6 +2155,10 @@ const AssistantChatInner = forwardRef(function AssistantChatInner({ emptyStateTe
             preparing: (activity) => t("agentChat.status.preparing", { activity }),
             writing: (activity) => t("agentChat.status.writing", { activity }),
             stillGenerating: (activity) => t("agentChat.status.stillGenerating", { activity }),
+            runningTool: (toolName) => t("agentChat.status.runningTool", {
+                activity: toolLabel(t, toolName),
+            }),
+            toolDisplayName: (toolName) => toolLabel(t, toolName),
         },
     });
     const reconnectActivityContent = useMemo(() => isReconnecting || reconnectFrozen