@agent-native/core 0.101.10 → 0.101.12

package/dist/extensions/actions.js

@@ -1,7 +1,9 @@
 import { ACTION_CHAT_UI_INLINE_EXTENSION_RENDERER } from "../action-ui.js";
 import { writeAppState } from "../application-state/script-helpers.js";
-import { getRequestRunContext } from "../server/request-context.js";
+import { readResource } from "../resources/script-helpers.js";
+import { getRequestOrgId, getRequestRunContext, getRequestUserEmail, } from "../server/request-context.js";
 import { resolveAccess } from "../sharing/access.js";
+import { readWorkspaceFile, } from "../workspace-files/store.js";
 import { getLocalExtension, isLocalExtensionRow, listLocalExtensions, } from "./local.js";
 import { extensionPath } from "./path.js";
 import { addExtensionSlotTarget, installExtensionSlot, uninstallExtensionSlot, listExtensionsForSlot, listSlotsForExtension, } from "./slots/store.js";
@@ -392,7 +394,7 @@ export function createExtensionActionEntries() {
         },
         "create-extension": {
             tool: {
-                description: 'Create a persisted sandboxed Alpine.js mini-app extension and render it inline in the chat. Use this when the user wants generated UI that should be saved, reusable, or visible in the Extensions view: extensions, widgets, dashboards, calculators, mini-apps, and reusable interactive utilities. For one-time chat-only UI, use render-inline-extension instead. The content must be a self-contained Alpine.js HTML body snippet that can use appAction(), appFetch(), dbQuery(), extensionFetch(), extensionData, agentNative.ui.output(value, opts?), and agentNative.chat.send()/sendToAgentChat(). Use appAction() for app data writes and extensionData for extension-owned persisted UI state; dbQuery() is for read-only inspection of known app SQL tables. Use agentNative.ui.output for passive current values from knobs, sliders, and selections; it writes application state at inline-ui:<extension id>:output, which the agent can read later with readAppState when the user says to use that value. Use agentNative.chat.send for visible submit/apply actions. Persist reusable user-edited state with extensionData: if the extension has checkboxes, todos, notes, filters, preferences, or any control whose value should survive reload/reopen, load that state on init and save changes with extensionData, usually at user scope, instead of keeping it only in Alpine state. IMPORTANT — hosting a pasted file: if the user pasted a large HTML/Alpine file (it appears in your context as an <attachment name="pasted-text-…"> block) and asked you to host it as-is, do NOT copy that file into `content`. Instead leave `content` empty and pass `contentFromAttachment` set to that attachment\'s name (or the literal "latest" for the most recent pasted block) — the server reads the file verbatim. Re-emitting a large pasted file as `content` regularly gets cut off mid-stream and stalls the turn. Prefer appAction(name, params) for app data and actions, including read actions mounted as GET; do not call template /api/* routes from appFetch because the extension bridge only allows framework /_agent-native/* paths. Parse JSON string action results before aggregating; use dbQuery() only for known existing SQL tables and never for writes. Keep the initial create-extension payload compact and working; for complex extensions, create a useful v1 first, then use focused update-extension edits for refinements rather than assembling one enormous initial tool input. For any non-trivial component (more than a couple of state fields, any methods, any string formatting, any branching) put the component in a <script> block via Alpine.data(\'name\', () => ({...})) and reference it with x-data="name" — do NOT cram methods, template literals, or branching logic into an inline x-data="{...}" attribute (HTML parser pitfalls cause ReferenceError failures). Define every variable referenced from x-text/x-show/x-if/x-for on the data object\'s initial state. If the extension\'s value depends on an LLM call, require a real key via \\${keys.OPENAI_API_KEY}/\\${keys.ANTHROPIC_API_KEY} (and tell the user to add it in the Dispatch Vault, or in app Settings → API Keys & Connections for standalone apps, if missing) or route the AI work to the agent chat — never ship a stubbed analysis step that renders a placeholder/boolean as the result.',
+                description: 'Create a persisted sandboxed Alpine.js mini-app extension and render it inline in the chat. Use this when the user wants generated UI that should be saved, reusable, or visible in the Extensions view: extensions, widgets, dashboards, calculators, mini-apps, and reusable interactive utilities. For one-time chat-only UI, use render-inline-extension instead. The content must be a self-contained Alpine.js HTML body snippet that can use appAction(), appFetch(), dbQuery(), extensionFetch(), extensionData, agentNative.ui.output(value, opts?), and agentNative.chat.send()/sendToAgentChat(). Use appAction() for app data writes and extensionData for extension-owned persisted UI state; dbQuery() is for read-only inspection of known app SQL tables. Use agentNative.ui.output for passive current values from knobs, sliders, and selections; it writes application state at inline-ui:<extension id>:output, which the agent can read later with readAppState when the user says to use that value. Use agentNative.chat.send for visible submit/apply actions. Persist reusable user-edited state with extensionData: if the extension has checkboxes, todos, notes, filters, preferences, or any control whose value should survive reload/reopen, load that state on init and save changes with extensionData, usually at user scope, instead of keeping it only in Alpine state. IMPORTANT — hosting a pasted file: if the user pasted a large HTML/Alpine file (it appears in your context as an <attachment name="pasted-text-…"> block) and asked you to host it as-is, do NOT copy that file into `content`. Instead leave `content` empty and pass `contentFromAttachment` set to that attachment\'s name (or the literal "latest" for the most recent pasted block) — the server reads the file verbatim. Re-emitting a large pasted file as `content` regularly gets cut off mid-stream and stalls the turn. IMPORTANT — cloning a large extension that lives as a workspace resource (not a chat attachment): leave `content` empty and pass `contentFromWorkspaceFile` set to the resource path (e.g. "intuit-analytics-extension.html"); the server reads the full file. Do NOT try to reconstruct the body with run-code or route create-extension through run-code (mutating actions are not callable there). Prefer appAction(name, params) for app data and actions, including read actions mounted as GET; do not call template /api/* routes from appFetch because the extension bridge only allows framework /_agent-native/* paths. Parse JSON string action results before aggregating; use dbQuery() only for known existing SQL tables and never for writes. Keep the initial create-extension payload compact and working; for complex extensions, create a useful v1 first, then use focused update-extension edits for refinements rather than assembling one enormous initial tool input. For any non-trivial component (more than a couple of state fields, any methods, any string formatting, any branching) put the component in a <script> block via Alpine.data(\'name\', () => ({...})) and reference it with x-data="name" — do NOT cram methods, template literals, or branching logic into an inline x-data="{...}" attribute (HTML parser pitfalls cause ReferenceError failures). Define every variable referenced from x-text/x-show/x-if/x-for on the data object\'s initial state. If the extension\'s value depends on an LLM call, require a real key via \\${keys.OPENAI_API_KEY}/\\${keys.ANTHROPIC_API_KEY} (and tell the user to add it in the Dispatch Vault, or in app Settings → API Keys & Connections for standalone apps, if missing) or route the AI work to the agent chat — never ship a stubbed analysis step that renders a placeholder/boolean as the result.',
                 parameters: {
                     type: "object",
                     properties: {
@@ -412,6 +414,10 @@ export function createExtensionActionEntries() {
                             type: "string",
                             description: 'Host a pasted/attached file verbatim WITHOUT re-typing it. Set this to the name of an attachment on the current turn (e.g. "pasted-text-1718000000000-ab12cd.txt") or the literal "latest" for the most recent pasted block; the server resolves it into the extension content. Use this instead of `content` whenever the user pasted a large file to host — it avoids re-emitting thousands of tokens. When set, leave `content` empty.',
                         },
+                        contentFromWorkspaceFile: {
+                            type: "string",
+                            description: 'Host a workspace/shared resource file verbatim WITHOUT re-typing it. Set this to the resource path (e.g. "intuit-analytics-extension.html"); the server reads the full file and uses it as the extension content. Use this — NOT run-code or contentFromAttachment — when cloning a large extension body that already exists as a workspace resource. When set, leave `content` empty.',
+                        },
                         icon: {
                             type: "string",
                             description: "Optional icon name or short label.",
@@ -428,7 +434,7 @@ export function createExtensionActionEntries() {
                 const name = String(args?.name ?? "").trim();
                 if (!name)
                     return "Error: name is required.";
-                const resolved = resolveExtensionContent(args, ctx);
+                const resolved = await resolveExtensionContentAsync(args, ctx);
                 if ("error" in resolved)
                     return resolved.error;
                 const content = resolved.content.trim();
@@ -462,9 +468,12 @@ export function createExtensionActionEntries() {
                     catch {
                         // Non-fatal — agent can still mention the path in its reply.
                     }
+                    const hiddenIds = await getHiddenExtensionIdsForCurrentUser();
                     return {
                         ok: true,
-                        extension: { ...existing, path: existingPath },
+                        // Compact summary (contentLength + contentHash, no full body). Echoing
+                        // the whole HTML back is pure token waste — the agent just supplied it.
+                        extension: await summarizeExtension(existing, hiddenIds, false),
                         path: existingPath,
                         next: `Extension was already created in this session (recovered from a connection retry). The user is being navigated to it — no further navigation tool calls needed.`,
                     };
@@ -492,9 +501,12 @@ export function createExtensionActionEntries() {
                 catch {
                     // Non-fatal — agent can still mention the path in its reply.
                 }
+                const hiddenIds = await getHiddenExtensionIdsForCurrentUser();
                 return {
                     ok: true,
-                    extension: { ...extension, path },
+                    // Compact summary (contentLength + contentHash, no full body). Echoing
+                    // the whole HTML back is pure token waste — the agent just supplied it.
+                    extension: await summarizeExtension(extension, hiddenIds, false),
                     path,
                     next: `Created. The user is being navigated to the new extension automatically — no further navigation tool calls needed.`,
                 };
@@ -526,6 +538,10 @@ export function createExtensionActionEntries() {
                             type: "string",
                             description: 'Optional full replacement sourced from a pasted/attached file on the current turn, by attachment name (or the literal "latest" for the most recent pasted block). Use instead of `content` when replacing the whole body with a large pasted file so you do not have to re-type it. Ignored when `content` is provided.',
                         },
+                        contentFromWorkspaceFile: {
+                            type: "string",
+                            description: 'Optional full replacement sourced from a workspace/shared resource file, by resource path (e.g. "intuit-analytics-extension.html"). The server reads the full file and uses it as the replacement body. Use instead of `content` when replacing the whole body with a large file that exists as a workspace resource. Ignored when `content` is provided.',
+                        },
                         patches: {
                             type: "string",
                             description: 'Legacy optional JSON array of { "find": "...", "replace": "...", "all"?: true, "expectedMatches"?: 1, "required"?: true } patches. Missing required targets fail instead of silently no-oping.',
@@ -568,8 +584,9 @@ export function createExtensionActionEntries() {
                     ? args.content
                     : undefined;
                 if (replacementContent === undefined &&
-                    args?.contentFromAttachment !== undefined) {
-                    const resolved = resolveExtensionContent(args, ctx);
+                    (args?.contentFromAttachment !== undefined ||
+                        args?.contentFromWorkspaceFile !== undefined)) {
+                    const resolved = await resolveExtensionContentAsync(args, ctx);
                     if ("error" in resolved)
                         return resolved.error;
                     replacementContent = resolved.content;
@@ -1154,6 +1171,111 @@ function resolveExtensionContent(args, ctx) {
     }
     return { content: resolved };
 }
+/**
+ * Resolve the workspace-files bridge scope exactly the way run-code's
+ * workspaceRead/workspaceWrite do: org-preferred (org → shared owner) with the
+ * requesting user's email as the solo fallback. Kept in lockstep with
+ * `resolveScope` in `workspace-files/tool.ts`.
+ */
+function workspaceFilesBridgeScope() {
+    const orgId = getRequestOrgId();
+    if (orgId)
+        return { scope: "org", scopeId: orgId };
+    const email = getRequestUserEmail();
+    if (email)
+        return { scope: "user", scopeId: email };
+    return null;
+}
+/**
+ * Read a workspace/shared/personal resource file's FULL content by path.
+ *
+ * Precedence (single, documented rule so this never silently resolves a
+ * different file than the agent inspected):
+ *   1. The run-code `workspace-files` bridge scope (org → shared owner, else the
+ *      user's email). This is the SAME owner/scope `workspaceRead` /
+ *      `workspaceWrite` use, so a body the agent staged via `workspaceWrite` is
+ *      resolved here verbatim — the two paths cannot diverge.
+ *   2. User-managed Resources (personal override → org/shared → workspace
+ *      default) as a fallback, for pre-built resources that were created in the
+ *      Resources panel rather than staged through the bridge.
+ *
+ * Unlike attachments, resource content is not capped/truncated on the way in, so
+ * this is the correct path for cloning a large extension body that already
+ * exists as a workspace resource (e.g. a per-customer dashboard).
+ */
+async function readWorkspaceFileContent(path) {
+    const trimmed = path.trim();
+    if (!trimmed)
+        return null;
+    // 1) Bridge parity — resolve exactly the file workspaceRead/workspaceWrite see.
+    const bridgeScope = workspaceFilesBridgeScope();
+    if (bridgeScope) {
+        let bridgeFile;
+        try {
+            bridgeFile = await readWorkspaceFile(bridgeScope, trimmed);
+        }
+        catch {
+            // A THROW here is a transient store error or invalid path — NOT a
+            // definitive "not found". Fail closed rather than silently hosting a
+            // possibly-different same-path Resources body than workspaceRead
+            // inspected. A retry re-runs this read cleanly.
+            return null;
+        }
+        // A null result means the file genuinely does not exist in the bridge scope;
+        // fall through to user-managed Resources for pre-built resource-panel files.
+        if (bridgeFile && typeof bridgeFile.content === "string") {
+            return bridgeFile.content;
+        }
+    }
+    // 2) Fallback — user-managed Resources by scope precedence.
+    for (const scope of ["personal", "shared", "workspace"]) {
+        try {
+            const content = await readResource(trimmed, { scope });
+            if (typeof content === "string")
+                return content;
+        }
+        catch {
+            // A given scope can throw (e.g. `personal` when no user identity is
+            // resolvable in this context). Don't let one scope abort the lookup —
+            // fall through and try the next one.
+        }
+    }
+    return null;
+}
+/**
+ * Resolve the extension HTML body from (in priority order) inline `content`, a
+ * `contentFromWorkspaceFile` resource path, or a `contentFromAttachment` handle.
+ *
+ * The workspace-file path exists because a large extension body frequently lives
+ * as a workspace resource (not a chat attachment). Without it the model has no
+ * viable route — inline is too large to shuttle reliably, contentFromAttachment
+ * only sees chat attachments, and mutating actions cannot run from run-code — so
+ * it loops and the run aborts with no_progress.
+ */
+async function resolveExtensionContentAsync(args, ctx) {
+    const inline = args?.content !== undefined ? String(args.content) : undefined;
+    if (inline !== undefined && inline.trim().length > 0) {
+        return { content: inline };
+    }
+    const wsRef = args?.contentFromWorkspaceFile !== undefined
+        ? String(args.contentFromWorkspaceFile).trim()
+        : "";
+    if (wsRef) {
+        const content = await readWorkspaceFileContent(wsRef);
+        if (content === null) {
+            return {
+                error: `Error: contentFromWorkspaceFile="${wsRef}" did not match any readable workspace/shared/personal resource file. Check the exact path (e.g. "intuit-analytics-extension.html"), or pass the HTML inline via content.`,
+            };
+        }
+        if (content.trim().length === 0) {
+            return {
+                error: `Error: workspace file "${wsRef}" is empty. Pass non-empty HTML inline via content, or point contentFromWorkspaceFile at a file with content.`,
+            };
+        }
+        return { content };
+    }
+    return resolveExtensionContent(args, ctx);
+}
 function coerceBoolean(value) {
     return value === true || value === "true";
 }