eve 0.79.2 → 0.80.0

package/docs/connections/mcp.mdx

@@ -205,6 +205,111 @@ An MCP tool call returns the tool's `structuredContent` when the server sends it
 
 When a remote tool returns more data than the model needs, narrow the result at the MCP server. Prefer a purpose-built search or summary tool, or return a stable handle that another call can use to fetch a smaller slice. If you do not control the server and an equivalent upstream API is available, replace only that operation with an authored tool that stores the full payload outside model context and projects the needed fields through `toModelOutput`. Block the original MCP operation through [`tools.block`](#tool-filters) so the model does not see duplicate tools.
 
+## Events (experimental)
+
+An MCP connection can watch the server's events and run your code when one arrives. Vercel Connect holds the upstream subscription and forwards each event to your agent; eve runs your callback.
+
+Requirements:
+
+- A statically authored MCP connection with a static `connect()` auth provider. Dynamic connections and auth resolvers are not supported.
+- `@vercel/connect@2.5.2` or later.
+- An MCP server that supports events over Streamable HTTP.
+
+### Handle events
+
+Add `experimental_events` to the connection. In this example, a user asks the agent to "watch the support inbox and draft replies to new bug reports". The model subscribes to Bird's `email_mailbox.message_received` event for that mailbox. Each new email then starts a turn in the same conversation, with instructions to triage it:
+
+```ts title="agent/connections/bird.ts"
+import { connect } from "@vercel/connect/eve";
+import { defineMcpClientConnection } from "eve/connections";
+
+export default defineMcpClientConnection({
+  url: "https://mcp.bird.com/",
+  description: "Bird: email, SMS, and contacts. Can watch a mailbox for new mail.",
+  auth: connect("bird/bird"),
+  experimental_events: {
+    async onEvent({ event, origin, auth, attachSession }) {
+      if (event.name !== "email_mailbox.message_received") return;
+      await attachSession(origin.sessionId).send(
+        [
+          "A new email arrived in the mailbox you are watching:",
+          JSON.stringify(event.data),
+          "If it is a bug report, look up the sender's earlier threads, draft a reply " +
+            "that says what we know and what happens next, and ask me before sending it. " +
+            "Otherwise, summarize it in one line.",
+        ].join("\n\n"),
+        { auth, turnPolicy: "queue" },
+      );
+    },
+  },
+});
+```
+
+The model does the work with the connection's own tools: it reads the thread, drafts the reply, and waits for the user's approval in the conversation. `turnPolicy: "queue"` lets a burst of emails run one turn after another instead of interrupting the user.
+
+`onEvent` is required. Defining it does not subscribe to anything: the model subscribes at runtime.
+
+Callbacks run outside any conversation, as the user who subscribed (`auth`). Nothing enters a session unless you call `attachSession(sessionId).send(...)`, and `attachSession` never creates a session.
+
+Each delivery runs in its own durable workflow, so callbacks can run concurrently, out of order, and more than once. Use `deliveryId` to deduplicate side effects:
+
+```ts
+async onEvent({ event, deliveryId }) {
+  await fetch("https://crm.example/notes", {
+    method: "POST",
+    headers: { "Idempotency-Key": deliveryId },
+    body: JSON.stringify(event.data),
+  });
+},
+```
+
+### Handle missed events and ended subscriptions
+
+```ts
+experimental_events: {
+  async onEvent({ event }) {
+    // ...
+  },
+  async onGap({ origin, auth, attachSession }) {
+    // The server could not deliver every event. Re-read the source.
+    await attachSession(origin.sessionId).send(
+      "Some Bird events were missed. Re-check the mailbox.",
+      { auth },
+    );
+  },
+  async onTerminated({ origin, auth, error, attachSession }) {
+    // The upstream subscription ended. The watch ends when this returns.
+    await attachSession(origin.sessionId).send(
+      `The Bird watch ended: ${error.message}`,
+      { auth },
+    );
+  },
+},
+```
+
+### What the model can call
+
+`eve__search` lists three kinds of actions for the connection:
+
+| Action                    | Input                  | Result                                  |
+| ------------------------- | ---------------------- | --------------------------------------- |
+| `events_subscribe_<hash>` | `{ arguments, ttlMs }` | `{ id, status, expiresAt, ... }`        |
+| `events_get_subscription` | `{ id }`               | The subscription, or unknown once ended |
+| `events_unsubscribe`      | `{ id }`               | `{ id, status: "stopping" }`            |
+
+There is one subscribe action per event the server offers; its description names the event. `ttlMs` is required: an integer from `120000` (2 minutes) to `31536000000` (365 days), or `null` to watch until stopped. `expiresAt` is the resulting deadline, or `null`.
+
+- **Pending.** If Connect has not confirmed in time, subscribe returns the `id` with `status: "pending"`. Call get with that `id` later.
+- **Repeats.** Subscribing again to the same event with the same arguments from the same session returns the existing watch. Another session gets its own watch.
+- **Stopping.** Get and stop accept the `id` from any of the creator's sessions. After stop, eve keeps retrying Connect's unsubscribe until cleanup completes; until then get still reports the watch and stop can be called again.
+- **Lifetime.** A watch outlives the session that created it. It ends on stop, at `expiresAt`, or when the upstream subscription terminates.
+
+`tools.allow` and `tools.block` apply to these actions. An allow list hides any event action it does not name, so copy the exact `events_subscribe_<hash>` names from `eve__search`. `toolCall.providedArguments` does not apply to event actions.
+
+### Receiver
+
+eve mounts `POST /eve/v1/hooks/:connectionName`, under any configured agent or public prefix. It accepts only Connect's delivery token and only deliveries for a live watch's subscription; it answers `410` once the watch has ended. The callback's identity always comes from the saved watch, never from the event payload.
+
 ## Troubleshooting
 
 | Symptom                                    | Check                                                                                                                                     |

package/docs/guides/instrumentation/otel.mdx

@@ -38,6 +38,16 @@ does not affect lifecycle instrumentation created with `defineInstrumentation()`
 See [Audience](../channels/overview#audience) for how channels classify the
 conversation passed to this policy.
 
+The session's resolved capture decision also selects its default
+[Workflow run-data retention](/docs/agent-config#run-data-retention). Allowing
+both inputs and outputs uses the World's default; dropping the trace or excluding
+either direction requests deletion of durable payloads and streams when the run
+ends. This makes completed private and unknown-audience transcripts unreadable
+under the default policy outside development. Set
+`experimental.workflow.retention: "default"` on the agent to retain completed
+sessions independently of tracing. Destination `exportPolicy` filters do not
+change Workflow retention, and Workflow deletion does not delete exported traces.
+
 ## Instrument Node.js dependencies
 
 Pass OpenTelemetry instrumentation instances to `otel({ instrumentations })`.

package/docs/sandbox/vercel.mdx

@@ -104,6 +104,52 @@ const sandbox = await ctx.getSandbox(environment);
 const sandboxName = sandbox.name;
 ```
 
+## Mount a Drive
+
+A [Vercel Sandbox Drive](https://vercel.com/docs/sandbox/concepts/drives) stores files independently of a sandbox. Create or retrieve the Drive before calling `open()`, then pass it in `mounts` under an absolute path:
+
+```ts
+import { defineSandbox } from "eve/sandbox";
+import { Drive, VercelSandbox } from "eve/sandbox/vercel";
+
+const REGION = "iad1";
+
+export const environment = VercelSandbox.environment({ region: REGION });
+
+export default defineSandbox(async () => {
+  const drive = await Drive.getOrCreate({
+    name: "agent-workspace",
+    region: REGION,
+  });
+
+  return environment.open({
+    mounts: {
+      "/data": drive,
+    },
+  });
+});
+```
+
+This example mounts the Drive read-write at `/data`. Files written there remain on the Drive after the sandbox stops. Keep Drive mounts separate from eve's managed `/workspace` directory.
+
+Set the same region on the environment and the Drive. The environment region places the prepared snapshot and each session sandbox together with the Drive.
+
+A Drive supports one active read-write mount. Because each eve session gets its own sandbox, the fixed `agent-workspace` name works only when one eve session uses the Drive at a time. If sessions can overlap, derive an opaque, stable Drive name per owner or tenant. The [Vercel guide to using Drives with eve](https://vercel.com/kb/guide/vercel-drives-eve-agent) shows how to derive a Drive name from the session initiator.
+
+To share a point-in-time view across concurrent sandboxes, mount a read-only snapshot instead:
+
+```ts
+return environment.open({
+  mounts: {
+    "/data": drive.snapshot(),
+  },
+});
+```
+
+Before mounting `drive.snapshot()`, seed a new Drive by mounting it read-write and writing at least one file. An uninitialized Drive cannot be mounted as a snapshot.
+
+Vercel allows up to four non-overlapping, absolute Drive mount paths per sandbox. See the Vercel documentation for [Drive lifecycle, limits, and pricing](https://vercel.com/docs/sandbox/concepts/drives).
+
 ## Live sandbox options
 
 `open()` also accepts Vercel compute resources, timeout, and Drive mounts. Configure project credentials and custom fetch behavior on the environment, not in `open()`, because resume does not reconstruct start-only options.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eve",
-  "version": "0.79.2",
+  "version": "0.80.0",
   "private": false,
   "description": "Filesystem-first framework for durable backend AI agents that run anywhere.",
   "keywords": [
@@ -569,9 +569,9 @@
     "@ai-sdk/provider": "^4.0.26",
     "@ai-sdk/provider-utils": "^5.0.58",
     "@cfworker/json-schema": "4.1.1",
-    "@chat-adapter/slack": "4.41.0",
-    "@chat-adapter/state-memory": "4.41.0",
-    "@chat-adapter/twilio": "4.41.0",
+    "@chat-adapter/slack": "4.42.0",
+    "@chat-adapter/state-memory": "4.42.0",
+    "@chat-adapter/twilio": "4.42.0",
     "@clack/core": "1.3.1",
     "@eve/catalog": "0.0.1",
     "@eve/tracing": "0.0.0",
@@ -592,7 +592,7 @@
     "@types/react": "19.2.15",
     "@types/react-test-renderer": "19.1.0",
     "@vercel/blob": "2.8.0",
-    "@vercel/connect": "2.3.3",
+    "@vercel/connect": "2.5.2",
     "@vercel/detect-agent": "1.2.3",
     "@vercel/oidc": "3.8.0",
     "@vercel/otel": "2.1.3",
@@ -607,7 +607,7 @@
     "@workflow/world-local": "5.1.0",
     "@workflow/world-vercel": "5.2.0",
     "ai": "^7.0.137",
-    "chat": "4.41.0",
+    "chat": "4.42.0",
     "chokidar": "5.0.0",
     "commander": "14.0.3",
     "dd-trace": "6.13.0",
@@ -640,7 +640,7 @@
     "@opentelemetry/api": "^1.0.0",
     "ai": "^7.0.137",
     "braintrust": "^3.0.0",
-    "chat": "^4.41.0",
+    "chat": "^4.42.0",
     "dd-trace": "^6.13.0",
     "just-bash": "^3.1.0",
     "microsandbox": "^0.5.0"

package/dist/src/compiled/_chunks/node/chunk-6QHBXN7B-gl4n6nmi.js

@@ -1,12 +0,0 @@
-var e=/[<>|]/,t=/[\^|>]/,n=/^[A-Z0-9_]+$/,r=/(?<![<\w])@([A-Z][A-Z0-9_]+)/g,i=3e3,a=/^[ \t]+/,o=/^(?:&gt;|&lt;|#{1,6}(?=[ \t\n]|$)|[-+*](?=[ \t\n]|$)|`{3,}|~{3,}|(?:[-*_][ \t]*){3,}(?=\n|$))/,s=/^(\d{1,9})([.)])(?=[ \t\n]|$)/;function c(e){return e.replace(/&/g,`&amp;`).replace(/</g,`&lt;`).replace(/>/g,`&gt;`)}function l(e){return e.replace(/&lt;/g,`<`).replace(/&gt;/g,`>`).replace(/&amp;/g,`&`)}function u(e,t={}){return O(e),{...t.emoji===void 0?{}:{emoji:t.emoji},text:e,type:`plain_text`}}function d(e,t={}){return O(e),{text:e,type:`mrkdwn`,...t.verbatim===void 0?{}:{verbatim:t.verbatim}}}function f(e){return k(e,`userId`),`<@${e}>`}function p(e){return k(e,`channelId`),`<#${e}>`}function m(e){return k(e,`userGroupId`),`<!subteam^${e}>`}function h(e){return`<!${e}>`}function g(e,t){return A(e,`url`),t?`<${e}|${c(t)}>`:`<${e}>`}function _(e,t,n,r={}){j(t,`token`);let i=e instanceof Date?Math.floor(e.getTime()/1e3):e;if(!Number.isInteger(i))throw TypeError(`timestamp must be an integer unix timestamp or Date`);return`<!date^${i}^${t}${r.link?`^${M(r.link)}`:``}|${c(n)}>`}function v(e){return l(e.includes("```")?x(e):b(e))}function y(e){let t=e.replace(/<@([A-Z0-9_]+)\|([^<>]+)>/g,`@$2`);return t=t.replace(/<@([A-Z0-9_]+)>/g,`@$1`),t=t.replace(/<#([A-Z0-9_]+)\|([^<>]+)>/g,`#$2 ($1)`),t=t.replace(/<#([A-Z0-9_]+)>/g,`#$1`),t=t.replace(/<(?!https?:\/\/)([^<>|]+)\|(https?:\/\/[^|<>]+)>/g,`<$2|$1>`),t=t.replace(/<(https?:\/\/[^|<>]+)\|([^<>]+)>/g,`[$2]($1)`),t=t.replace(/<(https?:\/\/[^<>]+)>/g,`$1`),t}function b(e){let t=y(e);return t=t.replace(/(?<![_*\\])\*([^*\n]+)\*(?![_*])/g,`**$1**`),t=t.replace(/(?<!~)~([^~\n]+)~(?!~)/g,`~~$1~~`),t}function x(e){let t=``,n=0,r=0,i=!1,a=r=>{let a=e.slice(n,r);i&&=(a=T(a),!1),t+=b(a)};for(;r<e.length;){let o=e[r];if(o===`<`){let t=S(e,r);r=t===-1?r+1:t;continue}if(o!=="`"){r+=1;continue}if(!e.startsWith("```",r)){let t=C(e,r);r=t===-1?r+1:t;continue}let s=r+3,c=e.indexOf("```",s);if(c===-1||w(e,r)){r=s;continue}a(r),t.length>0&&!t.endsWith(`
-`)&&(t+=`
-`);let l=e.slice(s,c);t+="```",l.startsWith(`
-`)||(t+=`
-`),t+=y(l),l.endsWith(`
-`)||(t+=`
-`),t+="```",r=c+3,n=r,r<e.length&&e[r]!==`
-`&&(t+=`
-`,i=!0)}return a(e.length),t}function S(e,t){let n=t+1;for(;n<e.length&&e[n]!==`>`&&e[n]!==`
-`&&e[n]!==`\r`;)n+=1;return e[n]===`>`?n+1:-1}function C(e,t){let n=e.indexOf("`",t+1);if(n===-1)return-1;let r=e.indexOf(`
-`,t+1);return r!==-1&&r<n?-1:n+1}function w(e,t){let n=e.lastIndexOf(`
-`,t-1)+1;return e.slice(n,t).trimStart().startsWith(`&gt;`)}function T(e){let t=a.exec(e)?.[0]??``,n=t.length>0?` `:``,r=e.slice(t.length);return o.test(r)?`${n}\\${r}`:n+r.replace(s,`$1\\$2`)}function E(e){return e.replace(/\*\*(.+?)\*\*/g,`*$1*`)}function D(e){return e.replace(r,`<@$1>`)}function O(e){if(e.length<1||e.length>i)throw TypeError(`text must be between 1 and ${i} characters`)}function k(e,t){if(!n.test(e))throw TypeError(`${t} must be a Slack ID`)}function A(t,n){if(e.test(t))throw TypeError(`${n} cannot contain Slack control characters`)}function j(e,n){if(t.test(e))throw TypeError(`${n} cannot contain Slack date control characters`)}function M(e){return j(e,`link`),e}export{_ as a,f as c,E as d,v as f,p as i,m as l,u as n,g as o,l as p,c as r,h as s,d as t,D as u};