@agent-native/core 0.19.0 → 0.19.3

package/docs/content/drop-in-agent.md

@@ -38,6 +38,7 @@ export default function Root() {
         "Draft a reply to the latest email",
         "Show me yesterday's signup numbers",
       ]}
+      dynamicSuggestions
       defaultSidebarWidth={420}
       position="right"
     >
@@ -57,6 +58,7 @@ That's it. The user now has a toggleable agent on every page — with chat histo
 - **`children`** — your app. Rendered in the main area; the sidebar overlays from the chosen side.
 - **`emptyStateText`** — greeting shown when the chat has no messages. Default: `"How can I help you?"`.
 - **`suggestions`** — starter prompts rendered as clickable chips when empty.
+- **`dynamicSuggestions`** — context-aware prompt chips merged with `suggestions`. Enabled by default; pass `false` to show only static suggestions, or `{ max, includeStatic, getSuggestions }` to customize.
 - **`defaultSidebarWidth`** — initial pixel width (mount-only; user resize and saved value override). Default: `380`.
 - **`position`** — `"left"` or `"right"`. Default: `"right"`.
 - **`defaultOpen`** — whether the sidebar starts open (desktop only). Default: `false`.
@@ -146,7 +148,7 @@ Type-safe arguments come from the zod schema in your `defineAction()`. See [Acti
 
 ## Selection + cursor awareness {#selection}
 
-The agent can see what the user has selected — text, cells, slides, contacts — via the `navigation` and `selection` keys in application state. If you'd like Cmd-I (or similar) to send a selected range into the chat as context, see [Context Awareness](/docs/context-awareness).
+The agent can see what the user has selected — text, cells, slides, contacts — via the `navigation` and `selection` keys in application state. The empty chat also uses those keys to offer dynamic suggestions such as "Summarize this selection" or "Improve this slide" when the current screen makes them relevant. If you'd like Cmd-I (or similar) to send a selected range into the chat as context, see [Context Awareness](/docs/context-awareness).
 
 ## Putting it all together {#putting-it-together}
 

package/docs/content/external-agents.md

@@ -1,23 +1,42 @@
 ---
-title: "External Agents"
-description: "Connect your own Claude Code, Cowork, or Codex to a hosted agent-native app in one command — then round-trip artifacts back into the running UI with deep links."
+title: "External Agents: Claude Code, Codex, Cursor, Cowork"
+description: "Connect your own Claude Code, Codex, Cursor, or Claude Cowork to a hosted agent-native app — then round-trip artifacts back into the running UI with deep links."
+search: "Claude Code Codex Cursor Claude Cowork agent-native connect MCP local agent tools external agents"
 ---
 
 # External Agents
 
-An agent-native app is reachable by any external coding agent — Claude Code (desktop & CLI), Claude Cowork, Codex — over [MCP](/docs/mcp-protocol). External agents are great at producing artifacts (a draft, an event, a dashboard) but they live in a terminal or another app. Without a bridge, the user gets a wall of JSON and has to go find the thing.
+An agent-native app is reachable by any external coding agent — Claude Code (desktop & CLI), Codex, Cursor, Claude Cowork — over [MCP](/docs/mcp-protocol). External agents are great at producing artifacts (a draft, an event, a dashboard) but they live in a terminal or another app. Without a bridge, the user gets a wall of JSON and has to go find the thing.
 
 The external-agent bridge closes the loop. First you connect your own agent to a **hosted** app — one command, no token copying. Then the agent does the work over MCP and hands the user a single **"Open in <app> →"** link that opens 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](/docs/context-awareness)) — there is no second navigation mechanism.
 
-## Connect in one command {#connect}
+## Connect Claude Code, Codex, Cursor, and Cowork {#connect}
 
-The first-party hosted apps live at `mail.agent-native.com`, `calendar.agent-native.com`, `analytics.agent-native.com`, and so on. To wire your own Claude Code (and Codex / Cowork if detected) to one of them:
+The first-party hosted apps live at `mail.agent-native.com`, `calendar.agent-native.com`, `analytics.agent-native.com`, and so on. This flow connects supported local agent clients on your machine — Claude Code, Claude Code CLI, Codex, and Claude Cowork — to a hosted agent-native app over MCP. Cursor can use the same MCP endpoint via the no-CLI/manual config path below.
+
+If you have the Agent-Native CLI installed, run:
+
+```bash
+agent-native connect https://mail.agent-native.com
+```
+
+Or run the same command through npm without installing anything globally:
 
 ```bash
 npx @agent-native/core connect https://mail.agent-native.com
 ```
 
-This opens your browser at the app. You are already logged in, so you just click **Authorize** once. The command detects every installed agent client and writes the MCP config for each — no token to copy, no local server to run. Connect every first-party hosted app at once with:
+This opens your browser at the app. You are already logged in, so you just click **Authorize** once. The command detects every installed agent client and writes the right MCP config for each:
+
+| Local client                  | Config written by `connect`                                 |
+| ----------------------------- | ----------------------------------------------------------- |
+| Claude Code / Claude Code CLI | `.mcp.json` or `~/.claude.json`, depending on `--scope`     |
+| Codex                         | `~/.codex/config.toml` under `[mcp_servers.<app>]`          |
+| Claude Cowork                 | `~/.cowork/mcp.json` using the Claude Code MCP server shape |
+
+There is no token to copy and no local server to run. Restart the agent client after connecting so it picks up the new MCP server.
+
+Connect every first-party hosted app at once with:
 
 ```bash
 npx @agent-native/core connect --all
@@ -44,6 +63,8 @@ If you'd rather not run a command, open the app in your browser and use its **Co
 
 Restart the agent client after connecting so it picks up the new MCP server.
 
+Use this manual block for MCP clients that are not yet written by `agent-native connect`, including Cursor.
+
 ## What you can do once connected {#what-you-can-do}
 
 Once your agent is connected, the app's full action surface is available as MCP tools, plus the `ask-agent` meta-tool that runs the full agent loop (the same entry point [A2A](/docs/a2a-protocol) uses). Ask your agent to do real work and it hands back a link straight into the running app:

package/docs/content/frames.md

@@ -12,7 +12,7 @@ Agent-native apps run with an AI agent alongside the app UI. Locally, the agent
 - Ships with `@agent-native/core` — no separate package needed
 - Agent panel embedded directly in your app with chat and optional CLI terminal
 - Supports multiple AI coding CLIs — switch between them from the settings panel
-- Toggle between production mode (app tools only) and development mode (full filesystem, shell, and database access)
+- Toggle between production mode (app tools only) and development mode (shared `bash`/`read`/`edit`/`write` coding tools plus database access)
 - Great for local development, self-hosted production, and OSS
 
 ## Supported CLIs {#supported-clis}

package/docs/content/mcp-clients.md

@@ -7,6 +7,8 @@ description: "Connect your agent-native app to local MCP servers (claude-in-chro
 
 Agent-native apps can also act as MCP **clients** — connecting to locally installed MCP servers and exposing their tools to the agent chat. This is the symmetric counterpart to the [MCP Protocol](./mcp-protocol.md) (which makes your app an MCP server).
 
+Looking for the other direction — connecting Claude Code, Codex, Cursor, or Claude Cowork to an agent-native app? Use [External Agents](/docs/external-agents).
+
 With one config file, every agent-native app in your workspace gains access to tools provided by MCP servers on your machine: `claude-in-chrome` for browser automation, `@modelcontextprotocol/server-filesystem` for reading files, `@playwright/mcp` for browser testing, and anything else that speaks MCP.
 
 You can also [connect remote (HTTP) MCP servers at runtime](#remote-via-ui) — individual users or whole organizations — without editing a config file.

package/docs/content/mcp-protocol.md

@@ -7,6 +7,8 @@ description: "Expose your agent-native app as a remote MCP server so Claude Code
 
 Every agent-native app automatically exposes a remote MCP (Model Context Protocol) server. This lets external AI tools like Claude Code, Cursor, and Windsurf discover and call your app's actions directly — no extra code needed.
 
+If your goal is to connect Claude Code, Codex, Cursor, or Claude Cowork to a hosted agent-native app, start with [External Agents](/docs/external-agents). It documents the one-command `agent-native connect https://mail.agent-native.com` flow, token minting, local client config writes, manual MCP config for clients like Cursor, and deep links back into the UI. This page is the lower-level MCP server reference.
+
 ## Overview {#overview}
 
 MCP is the standard protocol for connecting AI tools to external capabilities. When you deploy an agent-native app, it auto-mounts an MCP endpoint alongside the existing A2A endpoint. Any MCP-compatible client can connect and use your app's tools.
@@ -34,9 +36,9 @@ Both protocols are auto-mounted. Use whichever fits your use case:
 
 You can also use the `ask-agent` MCP tool to get the best of both worlds — call it from Claude Code and let your app's agent reason through complex tasks.
 
-## Connecting from Claude Code {#claude-code}
+## Manual MCP client config {#claude-code}
 
-Add your app as a remote MCP server in Claude Code's config:
+For the recommended one-command setup, use [External Agents](/docs/external-agents). If you are hand-writing MCP config, add your app as a remote MCP server in Claude Code's config:
 
 ```jsonc
 // ~/.claude/mcp_servers.json

package/docs/content/migration-workbench.md

@@ -59,6 +59,11 @@ code> /migrate ./my-next-app --out ../migrated-app
 code> /audit --url https://example.com
 ```
 
+Agent-Native Code uses the same minimal coding tools as the sidebar development
+agent: `bash` for discovery/search/tests/builds, `read` for line-numbered file
+reads, `edit` for exact replacements, and `write` for new files or full
+rewrites.
+
 The same goals can run directly from the command line:
 
 ```bash

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-native/core",
-  "version": "0.19.0",
+  "version": "0.19.3",
   "type": "module",
   "description": "Framework for agent-native application development — where AI agents and UI share state via files",
   "license": "MIT",