sygnal 6.3.0 → 6.4.0

package/dist/guide/mcp-apps.md

@@ -48,10 +48,19 @@ App.model = {
     STATE: (state) => ({ ...state, status: 'loading' }),
     MCP: (state) => ({ callTool: 'get_forecast', args: { city: state.city }, ok: 'RESULT' }),
   },
-  // tell the model what the user picked: it reads it on its next turn
+  // tell the model what the user picked: store it on the server, where the model reads it with a
+  // tool, then send it as model context too (see Model context below)
   PICK: {
     STATE: (state, date) => ({ ...state, selected: date }),
-    MCP: (state, date) => ({ updateModelContext: { city: state.city, selectedDay: state.days.find((d) => d.date === date) } }),
+    MCP: (state, date) => ({ callTool: 'select_day', args: { city: state.city, day: state.days.find((d) => d.date === date) }, ok: 'PICKED' }),
+  },
+  PICKED: {
+    MCP: (state) => ({
+      updateModelContext: {
+        content: `The user selected ${state.selected} in the ${state.city} forecast card.`,
+        structuredContent: { city: state.city, selectedDay: state.days.find((d) => d.date === state.selected) },
+      },
+    }),
   },
   // post a message to the conversation, as the user
   ASK: { MCP: (state) => ({ message: `What should I pack for ${state.city} on ${state.selected}?` }) },
@@ -92,7 +101,7 @@ The latest tool input, tool result, host context and `host` are replayed to a co
 | Value | Does |
 |---|---|
 | `{ callTool: 'name', args, ok, error }` | Calls a tool on the MCP server through the host. `ok` gets the `CallToolResult`; `error` gets `{ error, code?, result?, request }` (a JSON-RPC error, or a result with `isError: true`) |
-| `{ updateModelContext: value }` | Tells the model something, for its next turn: a string (one text block), content blocks, or an object (`structuredContent`) |
+| `{ updateModelContext: value }` | Tells the model something, for its next turn: a string (one text block), content blocks, an object (`structuredContent`), or `{ content, structuredContent }`. The host decides whether the model sees it: see [Model context](#model-context) |
 | `{ message: 'text' }` | Posts a message to the conversation as the user (a string or content blocks) |
 | `{ openLink: 'https://…' }` | Asks the host to open a link |
 | `{ displayMode: 'fullscreen' }` | Asks for `'inline'`, `'fullscreen'` or `'pip'`; `ok` gets `{ mode }`, the mode the host chose |
@@ -155,6 +164,45 @@ Export.model = {
 
 **Theme and size.** Follow `host-context-changed` for the host's `theme` (and its `styles.variables`, CSS custom properties the host suggests), so the view matches the conversation around it. Keep the view compact for `inline` mode; offer full screen with `{ displayMode: 'fullscreen' }` when `availableDisplayModes` includes it.
 
+### Model context
+
+A view has three ways to tell the model something, and hosts handle them differently:
+
+- `{ message }` posts a message to the conversation as the user. The model sees it and answers it, in every host that supports `message`. Use it when the user's click is a question (the starter's **Ask about this day**).
+- `{ updateModelContext }` gives the host context for the model's **next** turn, and the host decides what to do with it. The spec says a host *should* pass it on, not how. Cursor adds it to the next user message; claude.ai keeps it and lets the model fetch it with a built-in tool ("Reading widget context"), and so does Claude Desktop's Code tab (`read_widget_context`, which the host points the model to); Claude Desktop's chat (tested October 2026) accepts it, but its model has no way to read it.
+- **A tool on your server.** The view saves what the user did with a tool only the view may call, and the model reads it with an ordinary tool. This reaches the model in every host, because every host offers the server's tools.
+
+The starter does the last two. When the user picks a day, the view calls `select_day`, then sends the same selection as model context:
+
+```js
+// server/server.js
+let selection = null   // one per process: the stdio server runs one per host connection
+
+// only the view can call it: visibility ['app'] keeps it out of the model's tool list
+server.registerTool('select_day', {
+  description: 'Records the day the user selected in the forecast card.',
+  inputSchema: { city: z.string(), day: z.object({ date: z.string(), sky: z.string(), high: z.number(), low: z.number() }) },
+  _meta: { ui: { resourceUri: VIEW_URI, visibility: ['app'] } },
+}, async ({ city, day }) => {
+  selection = { city, day }
+  return { content: [{ type: 'text', text: `Selected ${day.date} in ${city}` }], structuredContent: selection }
+})
+
+// the model's way to read it; get_forecast's description says to call it
+server.registerTool('get_selected_day', {
+  description: 'The day the user selected in the forecast card shown by get_forecast, if any.',
+  inputSchema: {},
+}, async () => ({
+  content: [{ type: 'text', text: selection ? `The user selected ${selection.day.date} in ${selection.city}.` : 'The user has not selected a day.' }],
+}))
+```
+
+The stdio server runs once per host connection, so one variable holds one user's selection. A server many users share (Streamable HTTP behind a public URL) has to keep it per user or session.
+
+Send `updateModelContext` with a text `content`: hosts list the content types they take (`MCP.select('host')` gives `hostCapabilities.updateModelContext`, Claude's is `{ text: {}, image: {} }`), and one that doesn't list `structuredContent` may drop an update that only has it.
+
+A host may also keep a tool's view (the `ui://` resource) and the tool list for as long as the server stays connected: Claude Desktop fetches them once per connection. After rebuilding the view or changing a tool, reconnect the server (restart the host, or turn the server off and on) before trying it again.
+
 ## The view's own tools
 
 The model sees the server's tools. With `tools: agentTools`, the view also offers its components' [`agent` declarations](./agent.md) to the host as tools of its own, so the model can operate the view while it is shown: select a day, change units, open a detail. Calls go through the same [call rules](./agent.md#the-call-rules) as any agent's.
@@ -263,7 +311,14 @@ it('shows the result, refreshes, and tells the model what the user picked', asyn
 
   t.simulateEvent('.day', 'click', { data: { date: 'Tue' } })
   await t.waitForState((s) => s.selected === 'Tue')
-  expect(t.requests('MCP').at(-1)).toEqual({ updateModelContext: { city: 'Oslo', selectedDay: days[1] } })
+  expect(t.requests('MCP').at(-1)).toEqual({ callTool: 'select_day', args: { city: 'Oslo', day: days[1] }, ok: 'PICKED' })
+  await t.respond('MCP', { content: [], structuredContent: { city: 'Oslo', day: days[1] } }, 'PICKED')
+  expect(t.requests('MCP').at(-1)).toEqual({
+    updateModelContext: {
+      content: 'The user selected Tue in the Oslo forecast card.',
+      structuredContent: { city: 'Oslo', selectedDay: days[1] },
+    },
+  })
 })
 ```
 

package/dist/index.cjs.js

@@ -785,6 +785,8 @@ const DEV_CODE_SEVERITY = {
     SYG425: 'warn',
     // PLAN-9 (checks/next.ts): D471 a lowercase <collection> / <switchable> tag (deprecated in 6.3.0)
     SYG426: 'warn',
+    // checks/next.ts: CHILD.select(undefined), usually a missing export
+    SYG427: 'error',
     // PLAN-9 (checks/next.ts): D470 key identity, two children with one identity
     SYG453: 'warn',
     SYG612: 'error',
@@ -17460,10 +17462,14 @@ function toggle(field) {
     return (state) => ({ ...state, [field]: !state[field] });
 }
 // event(type, payload?) → EVENTS sink fn for the object form:
-// `ACTION: { EVENTS: event('TYPE', (state, data) => payload) }` (static payloads allowed)
+// `ACTION: { EVENTS: event('TYPE', (state, data) => payload) }` (static payloads allowed).
+// A payload function that returns ABORT sends nothing, as ABORT does from any other sink.
 function event(type, payload) {
     return typeof payload === 'function'
-        ? (state, data, next, props) => ({ type, data: payload(state, data, next, props) })
+        ? (state, data, next, props) => {
+            const d = payload(state, data, next, props);
+            return isAbort(d) ? ABORT : { type, data: d };
+        }
         : () => ({ type, data: payload });
 }
 // ── emit() ─────────────────────────────────────────────────────────
@@ -17501,7 +17507,7 @@ function trackWorker(worker, events) {
 function makeServiceWorkerDriver(scriptUrl, options = {}) {
     return function serviceWorkerDriver(sink$) {
         const events = new EventTarget();
-        if (typeof navigator !== 'undefined' && 'serviceWorker' in navigator) {
+        if (options.enabled !== false && typeof navigator !== 'undefined' && 'serviceWorker' in navigator) {
             navigator.serviceWorker
                 .register(scriptUrl, { scope: options.scope })
                 .then((reg) => {