@agent-native/core 0.78.9 → 0.79.1

package/corpus/README.md

@@ -27,5 +27,5 @@ rg -n "defineAction|useActionQuery" node_modules/@agent-native/core/corpus
 
 ## Generated Counts
 
-- core files: 1937
-- template files: 4351
+- core files: 1941
+- template files: 4365

package/corpus/core/CHANGELOG.md

@@ -1,5 +1,22 @@
 # @agent-native/core
 
+## 0.79.1
+
+### Patch Changes
+
+- 43ea142: diag(agent): capture the durable background worker's API-key resolution state (engine, owner resolved, owner key, effective key, deploy-fallback-blocked) just before the anthropic key check. The worker stalls at `post_model_ok` and never reaches `aw_env` — the only exit between them is the anthropic key check's early return, so this pinpoints whether the worker bails for lack of an `effectiveApiKey`.
+
+## 0.79.0
+
+### Minor Changes
+
+- 6e25485: Add Generative UI support for transient and persisted sandboxed inline extensions in chat.
+
+### Patch Changes
+
+- 6e25485: Improve session replay playback and inline extension chat surfaces.
+- 6e25485: Teach generated saved extensions to persist reusable user-edited state with extensionData.
+
 ## 0.78.9
 
 ### Patch Changes

package/corpus/core/docs/content/actions.md

@@ -390,8 +390,9 @@ The query is cached under `["action", "get-lead", { leadId }]` and auto-invalida
 
 Actions can return structured widget data that the in-app chat renders
 natively. This is the first-party chat path for reusable tables, charts, setup
-summaries, and insight cards; use [MCP Apps](/docs/mcp-apps) for inline UI in
-external MCP hosts.
+summaries, and insight cards. Use [Generative UI](/docs/generative-ui) when the
+agent needs to generate arbitrary interactive controls inside the in-app chat,
+and use [MCP Apps](/docs/mcp-apps) for inline UI in external MCP hosts.
 
 ```ts
 import { defineAction } from "@agent-native/core/action";
@@ -581,3 +582,4 @@ const args = parseArgs(["--name", "Steve", "--verbose", "--count=3"]);
 - [**Context Awareness**](/docs/context-awareness) — the `view-screen` + `navigate` pattern in depth
 - [**A2A Protocol**](/docs/a2a-protocol) — how other agents discover and call your actions
 - [**MCP Protocol**](/docs/mcp-protocol) — exposing actions over MCP
+- [**Generative UI**](/docs/generative-ui) — rendering transient or persisted generated UI inline in chat

package/corpus/core/docs/content/agent-surfaces.md

@@ -17,6 +17,7 @@ you want, then use the matching primitive.
 | ----------------------------- | ----------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------- |
 | **Headless agent**            | Code, jobs, scripts, another app, or another agent should call the work directly.                           | `agent-native create --headless`, `defineAction`, `agent-native agent`, HTTP, CLI, MCP, A2A |
 | **Rich chat on Agent-Native** | You want a standalone or embedded chat backed by the built-in agent loop.                                   | [Chat template](/docs/template-chat), `<AgentChatSurface>`, `<AssistantChat>`               |
+| **Generated inline UI**       | The agent should create temporary or reusable controls, pickers, calculators, or visualizers inside chat.   | [Generative UI](/docs/generative-ui), `render-inline-extension`, `create-extension`         |
 | **Rich chat on your agent**   | You built the agent elsewhere and want Agent-Native's composer, transcript, tool cards, and native widgets. | `AgentChatRuntime`, `<AssistantChat runtime={runtime}>`                                     |
 | **Embedded sidecar**          | You already have a SaaS app and want an agent beside it with page context and host commands.                | `createAgentNativeEmbeddedPlugin()`, `AgentNativeEmbedded`                                  |
 | **Full application**          | Humans and agents should share durable screens, data, navigation, and collaboration.                        | Templates, actions, SQL state, context awareness                                            |
@@ -269,6 +270,10 @@ export function ProjectChat({ threadId }: { threadId: string }) {
 Actions can return explicit native widget results so chat output is not just
 text. Tables, charts, and typed product cards render as first-party React
 components in the chat, without iframes. See [Native Chat UI](/docs/native-chat-ui).
+When the agent needs arbitrary generated controls instead of a predefined
+React widget, use [Generative UI](/docs/generative-ui): it renders sandboxed
+Alpine/Tailwind UI inline, can read app state and slot context, and can send
+selected values back to chat.
 
 ## Rich chat on your agent {#byo-agent}
 
@@ -367,6 +372,8 @@ Full apps add product UI around the same action and agent contract:
 - **Live sync** — agent changes update the UI, and UI changes update the agent's context.
 - **Deep links** — action results can open the right app view.
 - **Native chat widgets** — tables, charts, cards, approvals, and typed results appear inline.
+- **Generative UI and extensions** — the agent can create inline controls now
+  and save reusable mini-apps when the workflow needs to persist.
 
 Start from the [Chat template](/docs/template-chat) when you want a minimal app
 around your actions, or from a domain [template](/docs/cloneable-saas) when you
@@ -378,6 +385,7 @@ want a complete product shape.
 | --------------------------------------------------------------- | ------------------------- |
 | "I just need a callable tool or workflow."                      | Headless agent            |
 | "I want the framework's agent, but chat should be the main UI." | Rich chat on Agent-Native |
+| "I want the agent to make an interactive control right now."    | Generated inline UI       |
 | "I already have an agent; I need a polished chat UI for it."    | Rich chat on your agent   |
 | "I already have a SaaS app; add an agent beside it."            | Embedded sidecar          |
 | "The agent and UI should evolve together as the product."       | Full application          |
@@ -390,6 +398,7 @@ need to browse, compare, configure, or collaborate over persistent objects.
 
 - [Actions](/docs/actions) — define the headless operation once.
 - [Native Chat UI](/docs/native-chat-ui) — render typed action results in chat.
+- [Generative UI](/docs/generative-ui) — generate transient or persisted sandboxed UI inline in chat.
 - [Drop-in Agent](/docs/drop-in-agent) — mount chat, sidebar, or panel surfaces.
 - [Component API](/docs/components) — lower-level React chat/composer pieces.
 - [Embedding SDK](/docs/embedding-sdk) — add Agent-Native to an existing app.

package/corpus/core/docs/content/extensions.md

@@ -7,6 +7,12 @@ description: "Mini-apps your users build inside your template — a custom KPI t
 
 Extensions are **mini-apps your users build inside your template**.
 
+When the agent needs a one-time interactive answer inside the chat itself, use
+[Generative UI](/docs/generative-ui) instead. Generative UI uses the same
+sandbox and bridge helpers, but `render-inline-extension` keeps the result
+transient, while `create-extension` saves a reusable extension that also appears
+in the Extensions view.
+
 If you've used QuickBooks Online, you've seen the model: QBO ships a core accounting product, and users layer on small custom widgets — a custom report, a payroll calculator, a tax-rule checker — that live inside the same app and use the same data. Extensions are the agent-native version of that idea, except your users don't write any code. They describe what they want, and the agent builds it.
 
 The framing matters: an extension isn't a generic "do whatever you want" sandbox. It's a **mini-app that extends a specific template** — Mail, Analytics, Calendar, Clips, Design — and uses that template's actions and data. A Mail extension reads emails. An Analytics extension reads a dashboard's metrics. A Calendar extension acts on the open event. They feel like part of the host product because they _are_ part of the host product.
@@ -169,12 +175,16 @@ Inside the iframe sandbox, every extension has these helpers on `window`:
 | `extensionData.list(collection, opts?)`          | List persisted items                                      | `extensionData.list('notes', { scope: 'all' })`           |
 | `extensionData.get(collection, id, opts?)`       | Get a single item                                         | `extensionData.get('notes', 'note-1')`                    |
 | `extensionData.remove(collection, id, opts?)`    | Delete a persisted item                                   | `extensionData.remove('notes', 'note-1')`                 |
+| `window.slotContext`                             | Read the page/chat context passed into this slot          | `window.slotContext?.contactEmail`                        |
+| `agentNative.ui.output(value, opts?)`            | Record passive inline UI output in application state      | `agentNative.ui.output({ threshold })`                    |
+| `agentNative.chat.send(message, opts?)`          | Send a prompt or selected value back to the agent chat    | `agentNative.chat.send('Use Q2', { context: { q: 2 } })`  |
 
 Three rules of thumb:
 
 - **Prefer `appAction` over `dbQuery`.** Actions are the template's official surface — they handle access control, scoping, and validation for you. Reach for raw SQL only when no action fits.
 - **Use `appAction` for template data.** Extension `appFetch` is limited to framework `/_agent-native/*` endpoints; template `/api/*` routes are blocked by the iframe bridge.
 - **Prefer `extensionData` over making new tables.** Each extension gets its own isolated key-value store. No schema, no migration. Set `{ scope: 'org' }` to share with the user's org, `'user'` (default) for private.
+- **Use `agentNative.ui.output` for inline control values the agent should read later.** It writes `inline-ui:<extensionId>:output` to application state; `agentNative.chat.send` is for visible submit/apply messages.
 
 ```html
 <script>

package/corpus/core/docs/content/generative-ui.md

@@ -0,0 +1,217 @@
+---
+title: "Generative UI"
+description: "Let the agent generate sandboxed interactive UI inline in chat, either transient for one turn or saved as reusable Extensions."
+search: "generative UI inline extension render-inline-extension create-extension show-extension-inline sandboxed Alpine Tailwind slotContext sendToAgentChat agentNative.chat.send agentNative.ui.output"
+---
+
+# Generative UI
+
+Generative UI is the chat-native path for interactive surfaces the agent creates
+at runtime. Instead of replying with only prose or a static table, the agent can
+render a sandboxed Alpine.js/Tailwind mini-app directly inside the transcript:
+controls, knobs, calculators, pickers, visualizers, dashboards, or any focused
+surface that helps the user inspect and adjust an answer.
+
+There are two lifetimes:
+
+- **Transient** — `render-inline-extension` renders a one-time UI in the
+  current chat. It is not saved to the Extensions view.
+- **Persisted** — `create-extension` saves the UI as an Extension and renders it
+  inline immediately. Later, `show-extension-inline` can load that saved
+  extension back into any chat.
+
+Both paths use the same sandboxed extension runtime as [Extensions](/docs/extensions):
+the generated HTML runs in an iframe with no host DOM access and reaches the app
+only through scoped bridge helpers.
+
+```an-diagram title="Generated UI in chat" summary="The agent chooses a lifetime, returns an inline-extension payload, and chat mounts the sandboxed extension frame."
+{
+  "html": "<div class=\"diagram-generative-ui\"><div class=\"diagram-card\" data-rough><strong>User asks</strong><small class=\"diagram-muted\">\"give me sliders for this model\"</small></div><div class=\"diagram-arrow diagram-muted\" aria-hidden=\"true\">&rarr;</div><div class=\"diagram-panel\"><span class=\"diagram-pill accent\">Agent</span><small class=\"diagram-muted\">writes Alpine + Tailwind</small><div class=\"diagram-row\"><span class=\"diagram-pill\">transient</span><span class=\"diagram-pill\">persisted</span></div></div><div class=\"diagram-arrow diagram-muted\" aria-hidden=\"true\">&rarr;</div><div class=\"diagram-card\" data-rough><strong>Chat iframe</strong><small class=\"diagram-muted\">same theme · app bridge · chat output</small></div></div>",
+  "css": ".diagram-generative-ui{display:flex;align-items:center;gap:12px;flex-wrap:wrap}.diagram-generative-ui .diagram-card,.diagram-generative-ui .diagram-panel{display:flex;flex-direction:column;gap:7px;padding:14px 16px;min-width:180px}.diagram-generative-ui .diagram-row{display:flex;gap:6px;flex-wrap:wrap}.diagram-generative-ui .diagram-arrow{font-size:22px;line-height:1}"
+}
+```
+
+## When to use it {#when-to-use-it}
+
+Use generative UI when the user needs to manipulate or inspect an answer in the
+chat itself:
+
+- tune weights, thresholds, ranges, or filters with controls
+- compare generated variants side by side
+- preview a calculation before committing it
+- select items from app data and send the choice back to chat
+- explore a temporary chart or dashboard without adding a route
+
+Use a normal [Native Chat UI](/docs/native-chat-ui) data widget when a typed
+action already knows the result shape, such as a table, chart, or insights
+summary. Use [MCP Apps](/docs/mcp-apps) when an external host like Claude or
+ChatGPT should render a real app route inline. Use a full app screen when the
+surface is a durable product workflow users will browse outside chat.
+
+## Agent actions {#actions}
+
+The built-in extension actions are the agent-facing API:
+
+| Action                    | Saves to Extensions | Renders inline | Use it for                                     |
+| ------------------------- | ------------------- | -------------- | ---------------------------------------------- |
+| `render-inline-extension` | No                  | Yes            | one-time controls, pickers, calculators, demos |
+| `create-extension`        | Yes                 | Yes            | reusable widgets, dashboards, mini-apps        |
+| `show-extension-inline`   | Already saved       | Yes            | reopening a saved extension inside a chat      |
+| `update-extension`        | Yes                 | On next render | editing an existing saved extension            |
+
+The action result declares `chatUI: { renderer: "core.inline-extension" }`.
+Assistant chat and the lightweight `AgentConversation` transcript both use that
+metadata to render the sandboxed UI instead of showing raw JSON.
+
+## Inputs from chat {#inputs}
+
+Pass chat inputs through the action `context` argument. The generated iframe
+receives that object as `window.slotContext`, and can subscribe to updates with
+`window.onSlotContext(fn)`.
+
+```html
+<div x-data="thresholdTuner">
+  <label class="text-sm font-medium text-foreground">Threshold</label>
+  <input
+    type="range"
+    min="0"
+    max="100"
+    x-model.number="threshold"
+    class="w-full"
+  />
+  <p class="text-sm text-muted-foreground" x-text="`Current: ${threshold}`"></p>
+</div>
+
+<script>
+  Alpine.data("thresholdTuner", () => ({
+    threshold: 50,
+    init() {
+      this.threshold = Number(window.slotContext?.threshold ?? 50);
+      window.onSlotContext?.((ctx) => {
+        if (ctx.threshold !== undefined) this.threshold = Number(ctx.threshold);
+      });
+    },
+  }));
+</script>
+```
+
+## App state and app data {#app-state}
+
+Generated UI can see and update the app through the standard extension bridge:
+
+- `appAction(name, params)` calls template/framework actions.
+- `appFetch(path, options)` calls allowed framework routes under
+  `/_agent-native/*`, including application-state endpoints.
+- `extensionData` stores per-extension data. Transient inline UIs get a local
+  chat-scoped adapter; persisted extensions use the normal authenticated
+  database-backed extension data API.
+- `dbQuery`, `dbExec`, and `extensionFetch` are available with the same role and
+  route gates as saved extensions.
+
+Prefer `appAction` for domain data. Actions carry validation, access checks, and
+business rules; raw SQL is for cases where no action exists.
+
+For transient UIs, `extensionData` is intentionally local to the browser. It is
+stored in host `localStorage`, is not visible to the agent or backend, does not
+sync across devices, does not migrate if the UI is later promoted to a saved
+Extension, and is not garbage-collected by the server. Use it only for
+throwaway local UI state. If the agent or the app needs to observe a value, use
+`agentNative.ui.output`, application state through `appFetch`, an `appAction`, or
+`agentNative.chat.send`.
+
+## Outputs back to chat {#outputs}
+
+Use passive output for controls whose current value should be readable later
+without forcing the user to click a submit button:
+
+```html
+<div x-data="{ threshold: 50 }">
+  <input
+    type="range"
+    min="0"
+    max="100"
+    x-model.number="threshold"
+    @input="agentNative.ui.output({ threshold }, { label: 'Threshold' })"
+    class="w-full"
+  />
+</div>
+```
+
+`agentNative.ui.output(value, options)` writes the current value to
+application state under a conventioned key:
+
+```txt
+inline-ui:<extensionId>:output
+```
+
+The stored value includes the submitted `value`, `updatedAt`, `extensionId`, and
+`source: "inline-ui"`, plus optional `label`, `context`, or `meta` fields. When
+the user says "use that value" or "apply the current selection", the agent reads
+that key with `readAppState("inline-ui:<id>:output")`.
+
+Generated UI can send a visible prompt or result back into the current app chat:
+
+```html
+<button
+  class="rounded-md bg-primary px-3 py-2 text-primary-foreground"
+  @click="agentNative.chat.send(`Use threshold ${threshold}`, {
+    context: JSON.stringify({ threshold }),
+    submit: true
+  })"
+>
+  Apply in chat
+</button>
+```
+
+`agentNative.chat.send(message, options)` is also available as
+`sendToAgentChat(message, options)`.
+
+Options:
+
+| Option        | Default | Effect                                           |
+| ------------- | ------- | ------------------------------------------------ |
+| `context`     | none    | hidden context appended to the submitted message |
+| `submit`      | `true`  | `false` pre-fills/reviews instead of auto-submit |
+| `openSidebar` | `true`  | opens the agent sidebar when the message is sent |
+
+This is the same app chat bridge used by normal UI components, so generated
+controls can hand structured selections back to the agent without calling an LLM
+directly from the iframe.
+
+## Styling and theming {#theming}
+
+Generated UI uses the app's Tailwind theme tokens. Prefer semantic classes:
+
+- `bg-background`, `text-foreground`, `border-border`
+- `bg-card`, `text-card-foreground`
+- `bg-primary`, `text-primary-foreground`
+- `text-muted-foreground`, `bg-accent`
+
+The extension shell injects the same CSS variables as the parent app and pushes
+theme updates into the iframe. Avoid hardcoded one-off colors unless the user
+asks for a specific brand treatment.
+
+## Security model {#security}
+
+Generative UI is arbitrary user-authored HTML, so it always runs in the
+extension sandbox:
+
+- iframe sandbox excludes `allow-same-origin`
+- no parent DOM or cookies are exposed to generated code
+- bridge requests are path-allowlisted under `/_agent-native/*`
+- viewer/editor/owner role policy is enforced in the parent before requests are
+  sent, and again server-side for saved extension data
+- template `/api/*` routes are not reachable through `appFetch`; expose domain
+  operations as actions instead
+
+Do not put provider tokens, private data, or internal secrets directly in the
+generated HTML. Use `extensionFetch()` with `${keys.NAME}` placeholders or
+template actions that resolve credentials server-side.
+
+## Related docs {#related}
+
+- [Extensions](/docs/extensions) — saved sandboxed mini-apps and the bridge API.
+- [Native Chat UI](/docs/native-chat-ui) — typed first-party React widgets for
+  action results.
+- [MCP Apps](/docs/mcp-apps) — inline app routes in external MCP hosts.
+- [Actions](/docs/actions) — the app/API surface generated UI should call.

package/corpus/core/docs/content/key-concepts.md

@@ -246,9 +246,9 @@ See [Context Awareness](/docs/context-awareness) for the full pattern: navigatio
 
 ## One action, many surfaces {#protocols}
 
-Implement a domain operation once as an action; the framework exposes it to every consumer. The same `defineAction()` becomes an agent tool, a typesafe UI hook, an HTTP endpoint, a CLI command, an MCP tool, and an A2A tool, with optional `link`, `mcpApp`, or explicit native-widget metadata added only when a surface needs it. Skills and instructions cover behavior.
+Implement a domain operation once as an action; the framework exposes it to every consumer. The same `defineAction()` becomes an agent tool, a typesafe UI hook, an HTTP endpoint, a CLI command, an MCP tool, and an A2A tool, with optional `link`, `mcpApp`, native-widget metadata, or Generative UI wrappers added only when a surface needs richer interaction. Skills and instructions cover behavior.
 
-For the full protocol/surface matrix (MCP server and OAuth, MCP Apps, A2A, deep links, native chat widgets, AgentChatRuntime connectors, Agent Web, and the adapter horizon for ACP and A2UI), and for choosing a product shape — headless, rich chat, embedded sidecar, or full app — see [Agent Surfaces](/docs/agent-surfaces).
+For the full protocol/surface matrix (MCP server and OAuth, MCP Apps, A2A, deep links, native chat widgets, Generative UI, AgentChatRuntime connectors, Agent Web, and the adapter horizon for ACP and A2UI), and for choosing a product shape — headless, rich chat, embedded sidecar, or full app — see [Agent Surfaces](/docs/agent-surfaces).
 
 ## Agent modifies code {#agent-modifies-code}
 

package/corpus/core/docs/content/mcp-apps.md

@@ -12,11 +12,12 @@ description: "Author and embed interactive MCP App UIs inside Claude, ChatGPT, a
 | Connect an external agent/host to your app                   | [External Agents](/docs/external-agents) |
 | Give your agent more tools (consume other MCP servers)       | [MCP Clients](/docs/mcp-clients)         |
 | Build inline UIs that render in Claude/ChatGPT               | **This page** — MCP Apps                 |
+| Build generated inline UI inside Agent-Native chat           | [Generative UI](/docs/generative-ui)     |
 | Lower-level MCP server reference (auth, tools, custom mount) | [MCP Protocol](/docs/mcp-protocol)       |
 
 MCP Apps are the official `io.modelcontextprotocol/ui` extension that lets compatible hosts — Claude, Claude Desktop, ChatGPT, VS Code GitHub Copilot, Goose, Postman, MCPJam, and Cursor — render interactive UIs inline in chat. In agent-native apps, every MCP App is a **real React route**, not a separate plain-HTML widget.
 
-Inside an Agent-Native app's own chat, prefer [native chat renderers](/docs/native-chat-ui) for first-party widgets such as tables, charts, typed results, and approval affordances. Use MCP Apps for external/cross-host inline UI in Claude, ChatGPT, Copilot, Cursor, and other compatible hosts, with the action `link` as the universal deep-link fallback.
+Inside an Agent-Native app's own chat, prefer [native chat renderers](/docs/native-chat-ui) for first-party widgets such as tables, charts, typed results, and approval affordances. Use [Generative UI](/docs/generative-ui) when the in-app agent should create arbitrary sandboxed controls or visualizers inline. Use MCP Apps for external/cross-host inline UI in Claude, ChatGPT, Copilot, Cursor, and other compatible hosts, with the action `link` as the universal deep-link fallback.
 
 ## Authoring: optional MCP Apps UI {#mcp-apps}
 
@@ -141,7 +142,4 @@ Test MCP Apps with the lightweight fixtures around `embedApp()` and `McpAppRende
 - [External Agents](/docs/external-agents) — connecting Claude, ChatGPT, Codex, and Cursor to hosted apps; MCP Apps compatibility matrix; catalog tiers; deep links.
 - [MCP Protocol](/docs/mcp-protocol) — the auto-mounted MCP server, auth, tools, and `ask-agent`.
 - [Actions](/docs/actions) — `defineAction`, the `link` builder, `publicAgent`.
-
-```
-
-```
+- [Generative UI](/docs/generative-ui) — generated inline UI inside the app's own chat.

package/corpus/core/docs/content/native-chat-ui.md

@@ -13,9 +13,11 @@ normal app chat.
 
 Use native chat UI when the user should inspect output where the agent is
 already speaking: query results, response insights, setup summaries,
-approval/denial controls, or links into app views. Use [MCP Apps](/docs/mcp-apps)
-when an external host such as Claude, ChatGPT, Copilot, or Cursor should render
-an inline route from your app.
+approval/denial controls, or links into app views. Use
+[Generative UI](/docs/generative-ui) when the agent needs to create arbitrary
+one-off controls, pickers, calculators, or visualizers in the in-app chat. Use
+[MCP Apps](/docs/mcp-apps) when an external host such as Claude, ChatGPT,
+Copilot, or Cursor should render an inline route from your app.
 
 ```an-diagram title="The native render path" summary="An action returns JSON; the runtime matches an explicit widget discriminant or chatUI.renderer; AssistantChat mounts a real React component. No iframe, no HTML execution."
 {
@@ -155,12 +157,14 @@ requiring each template to ship its own chat renderer:
 Keep chart data compact. For large datasets, aggregate in the action and link
 to the full app view with `display.primaryAction` or action `link` metadata.
 
-## Native widgets vs MCP Apps {#native-vs-mcp-apps}
+## Native widgets vs Generative UI vs MCP Apps {#native-vs-mcp-apps}
 
-Native chat widgets and MCP Apps are complementary:
+Native chat widgets, Generative UI, and MCP Apps are complementary:
 
 - **Native widgets** are for the app's own chat runtime. The action result is
   JSON, and the framework renders the built-in React widget.
+- **Generative UI** is for arbitrary sandboxed Alpine/Tailwind UI that the
+  agent creates or reloads inline in the app's own chat.
 - **MCP Apps** are for external hosts. The action declares `mcpApp` and usually
   `link`, and the host renders a real app route inline when supported.
 - **Deep links** remain the universal fallback. Use action `link` or

package/corpus/core/docs/content/tracking.md

@@ -144,7 +144,8 @@ configureTracking({
   endpoint: "https://analytics.example.com/api/analytics/track",
   sessionReplay: {
     enabled: true,
-    sampleRate: 1,
+    requireSignedInUser: true,
+    sampleRate: 0.1,
   },
   getDefaultProps: (_event, props) => ({
     ...props,
@@ -156,15 +157,20 @@ configureTracking({
 
 When `sessionReplay.enabled` is truthy, the client dynamically imports `@rrweb/record` after startup and posts replay chunks to the replay endpoint. If `endpoint` ends in `/api/analytics/track` or `/track`, the replay endpoint is derived automatically as `/api/analytics/replay`. Override it explicitly with `sessionReplay.endpoint` when the replay collector lives somewhere else.
 
-Agent Native template roots already call `configureTracking()`, so hosted template deployments can use Vite/Netlify environment variables instead of editing code:
+Agent Native template roots already call `configureTracking()`. Hosted template deployments can turn replay on with Vite/Netlify environment variables, while library consumers should prefer the explicit `configureTracking({ key, endpoint, sessionReplay })` form above:
 
 ```bash
 VITE_AGENT_NATIVE_ANALYTICS_PUBLIC_KEY=anpk_...
 VITE_AGENT_NATIVE_ANALYTICS_ENDPOINT=https://analytics.example.com/api/analytics/track
 VITE_AGENT_NATIVE_SESSION_REPLAY_ENABLED=true
-VITE_AGENT_NATIVE_SESSION_REPLAY_SAMPLE_RATE=1
+VITE_AGENT_NATIVE_SESSION_REPLAY_REQUIRE_AUTH=true
+VITE_AGENT_NATIVE_SESSION_REPLAY_SAMPLE_RATE=0.1
 ```
 
+The browser helper also performs a best-effort, non-blocking read of the current Agent Native auth session. When `requireSignedInUser` or `VITE_AGENT_NATIVE_SESSION_REPLAY_REQUIRE_AUTH` is enabled, replay does not start unless the session resolves to a signed-in user. Signed-in replays include `userId`/`userEmail` plus `orgId`; if auth gating is disabled, anonymous recordings remain queryable by anonymous visitor, session, app/template, hostname, and path.
+
+Session replay is sampled deterministically per browser session. A `sampleRate` of `0.1` records about 10% of eligible sessions; use `1` when the eligible population is intentionally small, such as logged-in-only dogfooding.
+
 Privacy defaults are intentionally conservative but still useful for playback:
 
 - Inputs are masked by default (`maskAllInputs: true`).

package/corpus/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-native/core",
-  "version": "0.78.9",
+  "version": "0.79.1",
   "description": "Framework for agent-native application development — where AI agents and UI share SQL state, actions, and context",
   "homepage": "https://github.com/BuilderIO/agent-native#readme",
   "bugs": {

package/corpus/core/src/action-ui.ts

@@ -2,6 +2,7 @@ export const ACTION_CHAT_UI_DATA_TABLE_RENDERER = "core.data-table";
 export const ACTION_CHAT_UI_DATA_CHART_RENDERER = "core.data-chart";
 export const ACTION_CHAT_UI_DATA_INSIGHTS_RENDERER = "core.data-insights";
 export const ACTION_CHAT_UI_DATA_WIDGET_RENDERER = "core.data-widget";
+export const ACTION_CHAT_UI_INLINE_EXTENSION_RENDERER = "core.inline-extension";
 
 export interface ActionChatUIConfig {
   /**

package/corpus/core/src/agent/production-agent.ts

@@ -4254,6 +4254,14 @@ export function createProductionAgentHandler(
       `[agent-chat] resolved engine=${engine.name} model=${model} requestEngine=${requestEngine ?? "(none)"}`,
     );
 
+    // DIAGNOSTIC-ONLY: the worker reaches post_model_ok but never aw_env — the
+    // only exit between them is this anthropic key check. Capture the exact
+    // resolution state so we know WHY effectiveApiKey is falsy in the worker
+    // (owner not resolved from the HMAC/thread? owner has no stored key? deploy
+    // fallback blocked?) vs the foreground which resolves it fine.
+    await awaitedWorkerMark(
+      `apikey_state:engine=${engine.name},owner=${ownerEmail ? "Y" : "N"},userKey=${userApiKey ? "Y" : "N"},effKey=${effectiveApiKey ? "Y" : "N"},block=${shouldBlockDeployCredentialFallback()}`,
+    );
     // Check for API key before starting a run (only for anthropic engine)
     if (engine.name === "anthropic" && !effectiveApiKey) {
       setResponseHeader(event, "Content-Type", "text/event-stream");