eve 0.84.0 → 0.85.0

package/docs/patterns/fork-conversations-into-new-threads.md

@@ -0,0 +1,159 @@
+---
+title: "Fork Conversations into a New Thread"
+description: "Copy a conversation into a new thread from a tool, so each conversation continues on its own."
+---
+
+Forking copies a conversation into a new session in a new thread, such as a side thread in the same
+channel or a thread in someone's direct messages. The new session starts with the conversation so
+far. After the fork, each conversation continues on its own: a later message in one never reaches
+the other.
+
+A fork needs a target that always starts a new session. A Slack target with only a `channelId`
+starts a new thread in any channel the app is in, or in a DM. Many other built-in channels reuse one
+session per chat, so sending the transcript there adds it to the person's existing conversation
+instead of forking.
+
+## How it works
+
+Build the fork as a [tool](../tools) so the model decides when to call it. The tool does
+three things:
+
+1. **Identify the destination.** Start a new thread in the current channel, read from
+   `ctx.session.auth.current`, open a new direct conversation with the caller, or send a new
+   message elsewhere.
+2. **Decide what context to seed the new session with.** Turn `ctx.messages`, the conversation the
+   model saw, into the text messages the new session should have access to.
+3. **Start the forked session.** Call `ctx.to(channel, target).send(...)` with a first message and
+   the selected messages as `history`, the same call a route makes for a
+   [cross-channel hand-off](../channels/custom#cross-channel-hand-off). The channel's `receive` hook
+   maps the target to a new thread and session, and the message runs the fork's first turn.
+
+## Fork into a new Slack thread
+
+This tool lets someone in a Slack thread say "split this off into its own thread":
+
+```ts title="agent/tools/fork_thread.ts"
+import { isChannel } from "eve/channels";
+import { defineTool, type ToolContext } from "eve/tools";
+import { z } from "zod";
+import slack from "../channels/slack";
+
+export default defineTool({
+  description: "Continue this conversation in a new thread in the current Slack channel.",
+  inputSchema: z.object({}),
+  async execute(_input, ctx) {
+    if (!isChannel(ctx.channel, slack) || ctx.channel.metadata.channelId === null)
+      return { forked: false, reason: "This conversation is not in Slack." };
+    const { channelId } = ctx.channel.metadata;
+    const auth = ctx.session.auth.current;
+
+    const history = toHistory(ctx.messages);
+    const delivery = await ctx.to(slack, { channelId }).send("Continue this conversation here.", {
+      auth,
+      history,
+      idempotencyKey: `${ctx.session.id}:${ctx.callId}`,
+    });
+    return { forked: true, sessionId: delivery.sessionId };
+  },
+});
+
+function toHistory(messages: ToolContext["messages"]) {
+  return messages.flatMap((message) => {
+    if (message.role !== "user" && message.role !== "assistant") return [];
+    const text =
+      typeof message.content === "string"
+        ? message.content
+        : message.content.flatMap((part) => (part.type === "text" ? [part.text] : [])).join("");
+    return text === "" ? [] : [{ role: message.role, text }];
+  });
+}
+```
+
+`ctx.channel` is the channel serving the calling session, and `isChannel` narrows its `metadata`
+to the Slack channel's, which includes the conversation's `channelId`. A call from anywhere else,
+such as a schedule or another channel, gets `forked: false`.
+
+A Slack target with only a `channelId` posts the agent's first reply as a new top-level message,
+which becomes the fork's thread. Every call starts a new thread and session. To fork into a
+different channel, pass that channel's id instead; the app must be a member of it.
+
+People continue the fork under the channel's usual rules. By default, a reply in a channel thread
+reaches the agent only when it mentions the app. See
+[Continue conversations without repeated mentions](../channels/slack#continue-conversations-without-repeated-mentions)
+to answer every reply in an active thread.
+
+### Fork into direct messages
+
+To move the conversation into the caller's DMs instead, open a direct conversation with their
+Slack user id and use its channel id as the target:
+
+```ts title="agent/tools/fork_to_dm.ts"
+import { callSlackApi } from "eve/channels/slack";
+
+// In execute(), replace the channelId lookup:
+const auth = ctx.session.auth.current;
+const userId = auth?.attributes.user_id;
+if (!isChannel(ctx.channel, slack) || typeof userId !== "string")
+  return { forked: false, reason: "No Slack user to message." };
+const channelId = await openDirectMessage(userId);
+
+async function openDirectMessage(userId: string) {
+  const response = await callSlackApi({
+    botToken: process.env.SLACK_BOT_TOKEN,
+    operation: "conversations.open",
+    body: { users: userId },
+  });
+  if (!response.ok) throw new Error(`conversations.open failed: ${String(response.error)}`);
+  return (response.channel as { id: string }).id;
+}
+```
+
+The caller's `user_id` comes from `auth.current`, not `ctx.channel.metadata.triggeringUserId`,
+which is whoever started the thread.
+
+`conversations.open` needs the `im:write` scope. The example reads `SLACK_BOT_TOKEN`. If your
+channel uses Vercel Connect, pass the connector's `botToken` resolver to `callSlackApi` instead.
+
+In the DM, the agent's first reply becomes a thread root, and replies in that thread continue the
+fork. A new top-level DM starts a separate session. The built-in Slack DM handler answers without
+a mention, and needs the `message.im` event and the `im:history` scope; see
+[Message hooks](../channels/slack#message-hooks).
+
+## What the new session sees
+
+The fork's first model call sees the copied messages as earlier user and assistant turns, followed
+by the message. `toHistory` keeps the text of user messages and assistant replies, including the
+message that asked for the fork. It leaves out tool calls, files, and reasoning. `ctx.messages`
+also carries eve's context messages, such as request context and recalled memory, and a tool can't
+tell them apart from the conversation yet, so the fork sees them too. The fork's agent can repeat
+anything in the copied history, so only fork into a channel whose members may see that
+conversation, including a DM's. See [Start from prior history](../channels/eve#start-from-prior-history) for how history
+joins a session.
+
+After the fork, the original conversation and the fork are separate sessions:
+
+- A message in the original thread reaches only its session.
+- A message in the fork's thread reaches only the fork's session.
+- Both keep the conversation from before the fork.
+
+The fork runs the root agent with the auth you pass, here the caller's. Only a tool on the root
+agent can fork: `ctx.to()` throws in a subagent, a root copy, or a remote agent call, since the
+fork would outlive the delegation and act for the caller.
+
+## Retries and repeated forks
+
+Each call starts a new thread. A tool call that retries runs the tool again with the same
+`ctx.callId`, so Slack maps the retry to the same thread and session, which gets the message once.
+The key also chooses the Slack thread, so it has to be unique across every session that forks
+into this channel, not only across retries. `ctx.callId` is unique only within one session, which
+is why the key includes `ctx.session.id`.
+To stop the model from forking the same conversation twice, say so in the tool's
+`description`, or record each fork in your app and check for one before sending.
+
+In a [workflow tool](../tools/workflows), call `ctx.to()` in a `"use step"` helper that receives
+`ctx`, as you would `ctx.getSandbox()`.
+
+## Fork from an earlier point
+
+To leave out the latest turns, slice `ctx.messages` before converting it. `ctx.messages` reflects
+history projection and compaction, so a long conversation arrives as the model last saw it.

package/docs/patterns/meta.json

@@ -4,6 +4,7 @@
   "pages": [
     "dynamic-scheduling",
     "durable-cross-channel-notifications",
+    "fork-conversations-into-new-threads",
     "multi-tenant-auth",
     "multi-tenant-approvals",
     "voice-notes",

package/docs/reference/cli.md

@@ -47,7 +47,7 @@ Creates a new agent app or adds an agent to an existing app. Always installs dep
 | `eve init` or `eve init .` in an existing project                                                          | Adds `agent/` plus missing `eve`, `ai`, and `zod` dependencies. Requires `package.json` and no existing `agent/` files |
 | `eve init path/to/app`                                                                                     | Adds an agent to the existing package at `path/to/app`                                                                 |
 
-Existing packages do not need a target-selection prompt: run `eve init` from the project directory or `eve init path/to/app`. New projects in non-interactive environments need a new directory name, such as `eve init my-agent`.
+Existing packages do not need a target-selection prompt: run `eve init` from the project directory or `eve init path/to/app`. New projects in non-interactive environments need a new directory name, such as `eve init my-agent`. A new project path can be nested, such as `eve init apps/my-agent`; eve creates missing parent directories.
 
 After scaffolding in an interactive human terminal, eve opens the TUI directly. Pass `-n` or `--non-interactive` to return after scaffolding instead. It still installs dependencies and follows the normal Git setup behavior. Noninteractive and coding-agent invocations return without starting an interactive session. Fresh projects use the parent workspace's package manager when there is one; otherwise they use the manager that launched `eve init`.
 

package/docs/sandbox/custom-providers.mdx

@@ -110,7 +110,7 @@ export default defineSandbox(() => environment.open({ egress: "deny-all" }));
 
 A `SandboxConnection` is the byte-level link to one sandbox. Each method has a fixed contract:
 
-- `spawn({ command, workingDirectory, env, signal })` runs `command` as a Bash login-shell script (`bash -lc`) in `workingDirectory`, with the sandbox's environment plus `env`. `env` holds only the per-call variables. Aborting kills the process tree. It resolves to a process with `stdout` and `stderr` byte streams, `wait()`, and `kill()`.
+- `spawn({ command, workingDirectory, env, signal })` runs `command` as a Bash login-shell script (`bash -lc`) in `workingDirectory`, with the sandbox's environment plus `env`. `env` holds only the per-call variables. Aborting kills the process tree. It resolves to a process with `stdout` and `stderr` byte streams, `wait()`, and `kill()`. When the call passes `stdin: true`, the process must also have a writable `stdin` stream; without one, eve kills the process and rejects the call.
 - `readFile({ path, signal })` resolves to the file's bytes or a byte stream, or to `null` only when the path does not exist. A directory or an unreadable path rejects.
 - `writeFiles({ files, signal })` writes every file, creating missing parent directories and overwriting existing files. It is the only write primitive.
 - `removePath({ path, force, recursive, signal })` removes a file or directory. `force` ignores a missing path, and `recursive` removes a non-empty directory.

package/docs/sandbox/index.mdx

@@ -26,7 +26,7 @@ export default defineTool({
 });
 ```
 
-Relative paths resolve from the workspace root, and `sandbox.resolvePath(".")` returns its absolute path. `run()` returns `{ exitCode, stdout, stderr }`; a nonzero exit code does not throw automatically. Use `spawn()` for a long-running process.
+Relative paths resolve from the workspace root, and `sandbox.resolvePath(".")` returns its absolute path. `run()` returns `{ exitCode, stdout, stderr }`; a nonzero exit code does not throw automatically. Use `spawn()` for a long-running process. Pass `stdin: true` to get a writable `stdin` stream on the process, for example to talk to a stdio server; closing it sends EOF. The Vercel and Docker sandboxes support it.
 
 Built-in environments set `AI_AGENT=eve` on every `run()` and `spawn()` call, including the `bash` tool and `prepare`, so agent-aware CLIs such as `vercel` skip interactive prompts. To use a different value, set `AI_AGENT` in the environment's `env` option or pass it in the `env` of one `run()` or `spawn()` call.
 

package/docs/schedules.mdx

@@ -81,7 +81,7 @@ export default defineSchedule({
 
 Every run delivers the agent's reply to the channel. To skip a run when there is nothing to report, check that condition in the handler before calling `send`. When only the agent can tell, add the opt-in [`no_reply`](/docs/concepts/built-in-tools#no_reply) tool and ask the agent to call it when there is nothing to report; the run then posts nothing.
 
-- `to(channel, target).send(message, { auth })`: starts a session on another channel. It has the same contract as a route handler's `ctx.to(...)` handle.
+- `to(channel, target).send(message, { auth, ...options })`: starts a session on another channel. It has the same contract and [options](./channels/custom#cross-channel-hand-off) as a route handler's `ctx.to(...)` handle.
 - `waitUntil(promise)`: extends the cron task's lifetime so the parked session and any in-flight fetches settle before the task ends. Wrap the `send` call in it.
 - `appAuth`: the app principal (`{ authenticator: "app", principalId: "eve:app", principalType: "runtime" }`). Pass it as `to(...).send(..., { auth: appAuth })` for work the agent does on its own behalf.
 

package/docs/tools/overview.mdx

@@ -254,6 +254,8 @@ examples.
 - `ctx.messages`: the model input for the step that requested this call, the same messages a [dynamic capability's](/docs/guides/dynamic-capabilities) `ctx.messages()` returns before that call.
 - `ctx.abortSignal`: aborts when the active turn is cancelled. Pass it to cancellation-aware work; sandbox sessions from `ctx.getSandbox()` are already bound to it.
 - `ctx.getSandbox()`: the live [sandbox](/docs/sandbox) handle.
+- `ctx.channel`: the channel serving the session, as [hooks](/docs/guides/hooks) and [dynamic resolvers](/docs/guides/dynamic-capabilities) read it: `kind`, `continuationToken`, and `metadata`, what the channel's `metadata(state)` hook projects, such as a Slack thread's `channelId` and `threadTs`.
+- `ctx.to(channel, target)`: starts or continues a session on one of the agent's channels. See [Start channel sessions](#start-channel-sessions-ctxto).
 
 Running in the app runtime is what lets a tool import shared code from `lib/`, read `process.env`, and take part in eve’s durable pause/resume model.
 
@@ -261,6 +263,38 @@ eve never runs authored tools during discovery. The model sees descriptors first
 
 Use operation-specific idempotency keys for external writes such as charges or emails. Approval records consent; it does not deduplicate an operation. See [Crash recovery](/docs/concepts/execution-model-and-durability#resuming-after-a-crash).
 
+### Start channel sessions: `ctx.to`
+
+`ctx.to(channel, target).send(message, options)` starts a session on one of the agent's channels, or continues the one at that target, through the channel's `receive` hook. It's the same call as a route handler's [cross-channel hand-off](/docs/channels/custom#cross-channel-hand-off), with the same [options](/docs/channels/custom#cross-channel-hand-off), and returns the delivery, whose `sessionId` names the session. Use it when the model decides that work should continue somewhere people can follow it, such as a new Slack thread:
+
+```ts title="agent/tools/escalate.ts"
+import { defineTool } from "eve/tools";
+import { z } from "zod";
+import slack from "../channels/slack";
+
+export default defineTool({
+  description: "Hand this investigation to the on-call channel in Slack.",
+  inputSchema: z.object({ summary: z.string() }),
+  async execute({ summary }, ctx) {
+    const delivery = await ctx
+      .to(slack, { channelId: "C0123ABC" })
+      .send("Take over this investigation.", {
+        auth: ctx.session.auth.current,
+        history: [{ role: "user", text: summary }],
+        idempotencyKey: `${ctx.session.id}:${ctx.callId}`,
+      });
+    return { sessionId: delivery.sessionId };
+  },
+});
+```
+
+- The session belongs to the channel. People on that channel continue it, it has no parent, and it keeps running after the tool returns.
+- It runs the root agent with the `auth` you pass. Pass `ctx.session.auth.current` to start it as the caller.
+- A tool call that retries runs the tool again. Pass `` idempotencyKey: `${ctx.session.id}:${ctx.callId}` ``, and the session at the target gets the message once. The destination session dedupes keys from every sender, and `ctx.callId` alone is unique only within the calling session, so include the session id. Built-in channels map a retry to the same session, including a Slack target with only a `channelId`. A platform post made before the session exists, such as an `initialMessage`, repeats.
+- `ctx.to()` throws in a delegated session: a subagent, a root copy, or a remote agent call. A session it started would outlive the delegation and act for the caller, so return the result and send from a tool on the root agent.
+
+See [Fork conversations into a new thread](/docs/patterns/fork-conversations-into-new-threads) for a tool that copies the current conversation into a new Slack thread.
+
 ## When a tool throws
 
 If an authored tool's `execute` function throws, eve records the call as `call.settled` with `outcome: "failed"` and gives the error to the model as a tool error. The model can respond, choose another action, or call the tool again. eve does not automatically call the tool again based on the exception type, an upstream HTTP status, or a `retryable` property.

package/docs/tools/workflows.mdx

@@ -85,14 +85,14 @@ or days later, the run resumes, deploys, and returns. The model sees one tool re
   `start`, `getRun`, and `resumeHook` from `workflow/api` belong in steps. Your app does not install
   the SDK; for types, new projects list `eve/workflow-modules` in the tsconfig `types`.
 - In an `execute` or `task` body, `ctx` is a `WorkflowToolContext` with `session`, `callId`,
-  `toolName`, `abortSignal`, `agent`, `agents`, and `ask`. A `serve` body gets a
-  `WorkflowServeContext` with `session`, `toolName`,
+  `toolName`, `abortSignal`, `channel`, `agent`, `agents`, and `ask`. A `serve` body gets a
+  `WorkflowServeContext` with `session`, `toolName`, `channel`,
   `agent`, `agents`, `ask`, and `reply`; each call it receives carries its own `callId` and
   `abortSignal`.
   A `"use step"` helper that receives `ctx` directly gets a restricted `WorkflowStepToolContext` with
-  `session`, `callId`, `toolName`, `abortSignal`, `getSandbox`, `getToken`, and `requireAuth`. Read `ctx.agents`, call
-  `ctx.agent()`, and call `ctx.ask()` in the workflow body; pass only the serializable values the step needs.
-  Call `getSandbox`, `getToken`, and `requireAuth` in a step: the workflow body throws when it calls them.
+  `session`, `callId`, `toolName`, `abortSignal`, `channel`, `getSandbox`, `getToken`, `requireAuth`, and `to`. Read `ctx.agents`, and call
+  `ctx.agent()` and `ctx.ask()` in the workflow body; pass only the serializable values the step needs.
+  Call `getSandbox`, `getToken`, `requireAuth`, and `to` in a step: the workflow body throws when it calls them.
 - The tool's input must be a JSON object. Workflow bodies are for static tools under `agent/tools/`,
   not tools a `defineDynamic` function returns.
 
@@ -613,6 +613,10 @@ const reviewer = ctx.agent("agent", {
 });
 ```
 
+Without `modelContextWindowTokens`, eve reads the model's context window from the AI Gateway model
+catalog recorded when the agent was built. Set it for a model that catalog doesn't list; otherwise
+the first `send` rejects.
+
 The selection must contain an AI Gateway model id. A live AI SDK `LanguageModel` cannot cross the
 durable workflow boundary. A remote agent rejects the option because its deployment owns its model
 configuration.
@@ -778,6 +782,48 @@ When an authored tool accepts a JSON Schema supplied by the model, represent tha
 
 This pattern controls specialist selection, not whether the parent model delegates at all. Route before the parent model runs if every incoming request must go through Jev.
 
+## Start channel sessions: `ctx.to`
+
+A workflow tool reaches the agent's channels with [`ctx.to(channel, target)`](/docs/tools#start-channel-sessions-ctxto), as an ordinary tool does. Call it in a `"use step"` helper that receives `ctx`, like `ctx.getSandbox()`; the workflow body throws when it calls it:
+
+```ts title="agent/tools/open_incident_channel.ts"
+import { defineWorkflowTool, type WorkflowStepToolContext } from "eve/tools";
+import { z } from "zod";
+import slack from "../channels/slack";
+import { createIncidentChannel } from "../lib/incidents";
+
+export default defineWorkflowTool({
+  description: "Open a Slack channel for an incident and continue the investigation there.",
+  inputSchema: z.object({ title: z.string(), summary: z.string() }),
+  async task({ title, summary }, ctx) {
+    "use workflow";
+    const channelId = await createChannel(title);
+    return await openIncident(ctx, channelId, summary);
+  },
+});
+
+async function createChannel(title: string) {
+  "use step";
+  return await createIncidentChannel(title);
+}
+
+async function openIncident(ctx: WorkflowStepToolContext, channelId: string, summary: string) {
+  "use step";
+  const delivery = await ctx
+    .to(slack, { channelId })
+    .send("Continue the investigation in this channel.", {
+      auth: ctx.session.auth.current,
+      history: [{ role: "user", text: summary }],
+      idempotencyKey: `${ctx.session.id}:${ctx.callId}:incident`,
+    });
+  return { channelId, sessionId: delivery.sessionId };
+}
+```
+
+A step that fails retries, so pass an `idempotencyKey` the retry repeats. The destination session dedupes keys from every sender, and `ctx.callId` is unique only within the calling session and is the same for every step of the call, so include `ctx.session.id` and add a label for each send. Create the channel in its own step: a retried send step then reuses the recorded `channelId` instead of creating another channel.
+
+`ctx.channel` holds the `kind`, `continuationToken`, and `metadata` of the channel serving the calling session, in the workflow body and in steps, as in [ordinary tools](/docs/tools#the-ctx-parameter).
+
 ## Report progress: `yield`
 
 A workflow body may be an async generator whose yields report progress. After processing a yield,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eve",
-  "version": "0.84.0",
+  "version": "0.85.0",
   "private": false,
   "description": "Filesystem-first framework for durable backend AI agents that run anywhere.",
   "keywords": [
@@ -618,7 +618,7 @@
     "@vercel/oidc": "3.8.0",
     "@vercel/otel": "2.1.3",
     "@vercel/queue": "0.5.1",
-    "@vercel/sandbox": "3.3.0",
+    "@vercel/sandbox": "3.9.0",
     "@vercel/schedules": "0.0.0-alpha.11",
     "@vercel/sdk": "1.28.8",
     "@workflow/core": "5.2.3",

package/dist/src/compiled/_chunks/node/token-Bedbhv5z.js

@@ -1 +0,0 @@
-import{t as e}from"./rolldown-runtime-tZXQYakl.js";import{r as t,t as n}from"./token-util-DpJNusVS.js";var r=e(((e,r)=>{var i=Object.defineProperty,a=Object.getOwnPropertyDescriptor,o=Object.getOwnPropertyNames,s=Object.prototype.hasOwnProperty,c=(e,t)=>{for(var n in t)i(e,n,{get:t[n],enumerable:!0})},l=(e,t,n,r)=>{if(t&&typeof t==`object`||typeof t==`function`)for(let c of o(t))!s.call(e,c)&&c!==n&&i(e,c,{get:()=>t[c],enumerable:!(r=a(t,c))||r.enumerable});return e},u=e=>l(i({},`__esModule`,{value:!0}),e),d={};c(d,{refreshToken:()=>m}),r.exports=u(d);var f=t(),p=n();async function m(e){let t=e?.project,n=e?.team;if(!t&&!n){let e=(0,p.findProjectInfo)();t=e.projectId,n=e.teamId}else if(!t||!n){let e=(0,p.findProjectInfo)();t??=e.projectId,n??=e.teamId}if(!t)throw new f.VercelOidcTokenError("Failed to refresh OIDC token: No project specified. Try re-linking your project with `vc link`");let r=(0,p.loadToken)(t);if(!r||(0,p.isExpired)((0,p.getTokenPayload)(r.token),e?.expirationBufferMs)){let i=await(0,p.getVercelToken)({expirationBufferMs:e?.expirationBufferMs});if(r=await(0,p.getVercelOidcToken)(i,t,n),!r)throw new f.VercelOidcTokenError(`Failed to refresh OIDC token`);(0,p.saveToken)(r,t)}process.env.VERCEL_OIDC_TOKEN=r.token}0&&(r.exports={refreshToken:m})}));export default r();export{};

package/dist/src/compiled/_chunks/node/token-util-DpJNusVS.js

@@ -1 +0,0 @@
-import{i as e,t}from"./rolldown-runtime-tZXQYakl.js";var n=t(((e,t)=>{var n=Object.defineProperty,r=Object.getOwnPropertyDescriptor,i=Object.getOwnPropertyNames,a=Object.prototype.hasOwnProperty,o=(e,t)=>{for(var r in t)n(e,r,{get:t[r],enumerable:!0})},s=(e,t,o,s)=>{if(t&&typeof t==`object`||typeof t==`function`)for(let c of i(t))!a.call(e,c)&&c!==o&&n(e,c,{get:()=>t[c],enumerable:!(s=r(t,c))||s.enumerable});return e},c=e=>s(n({},`__esModule`,{value:!0}),e),l={};o(l,{VercelOidcTokenError:()=>u}),t.exports=c(l);var u=class extends Error{constructor(e,t){super(e),this.name=`VercelOidcTokenError`,this.cause=t}toString(){return this.cause?`${this.name}: ${this.message}: ${this.cause}`:`${this.name}: ${this.message}`}};0&&(t.exports={VercelOidcTokenError:u})})),r=t(((e,t)=>{var n=Object.defineProperty,r=Object.getOwnPropertyDescriptor,i=Object.getOwnPropertyNames,a=Object.prototype.hasOwnProperty,o=(e,t)=>{for(var r in t)n(e,r,{get:t[r],enumerable:!0})},s=(e,t,o,s)=>{if(t&&typeof t==`object`||typeof t==`function`)for(let c of i(t))!a.call(e,c)&&c!==o&&n(e,c,{get:()=>t[c],enumerable:!(s=r(t,c))||s.enumerable});return e},c=e=>s(n({},`__esModule`,{value:!0}),e),l={};o(l,{AccessTokenMissingError:()=>u,RefreshAccessTokenFailedError:()=>d}),t.exports=c(l);var u=class extends Error{constructor(){super(`No authentication found. Please log in with the Vercel CLI (vercel login).`),this.name=`AccessTokenMissingError`}},d=class extends Error{constructor(e){super(`Failed to refresh authentication token.`,{cause:e}),this.name=`RefreshAccessTokenFailedError`}};0&&(t.exports={AccessTokenMissingError:u,RefreshAccessTokenFailedError:d})})),i=t(((t,r)=>{var i=Object.create,a=Object.defineProperty,o=Object.getOwnPropertyDescriptor,s=Object.getOwnPropertyNames,c=Object.getPrototypeOf,l=Object.prototype.hasOwnProperty,u=(e,t)=>{for(var n in t)a(e,n,{get:t[n],enumerable:!0})},d=(e,t,n,r)=>{if(t&&typeof t==`object`||typeof t==`function`)for(let i of s(t))!l.call(e,i)&&i!==n&&a(e,i,{get:()=>t[i],enumerable:!(r=o(t,i))||r.enumerable});return e},f=(e,t,n)=>(n=e==null?{}:i(c(e)),d(t||!e||!e.__esModule?a(n,`default`,{value:e,enumerable:!0}):n,e)),p=e=>d(a({},`__esModule`,{value:!0}),e),m={};u(m,{findRootDir:()=>y,getUserDataDir:()=>b}),r.exports=p(m);var h=f(e(`path`)),g=f(e(`fs`)),_=f(e(`os`)),v=n();function y(){try{let e=process.cwd();for(;e!==h.default.dirname(e);){let t=h.default.join(e,`.vercel`);if(g.default.existsSync(t))return e;e=h.default.dirname(e)}}catch{throw new v.VercelOidcTokenError(`Token refresh only supported in node server environments`)}return null}function b(){if(process.env.XDG_DATA_HOME)return process.env.XDG_DATA_HOME;switch(_.default.platform()){case`darwin`:return h.default.join(_.default.homedir(),`Library/Application Support`);case`linux`:return h.default.join(_.default.homedir(),`.local/share`);case`win32`:return process.env.LOCALAPPDATA?process.env.LOCALAPPDATA:null;default:return null}}0&&(r.exports={findRootDir:y,getUserDataDir:b})})),a=t(((t,n)=>{var r=Object.create,i=Object.defineProperty,a=Object.getOwnPropertyDescriptor,o=Object.getOwnPropertyNames,c=Object.getPrototypeOf,l=Object.prototype.hasOwnProperty,u=(e,t)=>{for(var n in t)i(e,n,{get:t[n],enumerable:!0})},d=(e,t,n,r)=>{if(t&&typeof t==`object`||typeof t==`function`)for(let s of o(t))!l.call(e,s)&&s!==n&&i(e,s,{get:()=>t[s],enumerable:!(r=a(t,s))||r.enumerable});return e},f=(e,t,n)=>(n=e==null?{}:r(c(e)),d(t||!e||!e.__esModule?i(n,`default`,{value:e,enumerable:!0}):n,e)),p=e=>d(i({},`__esModule`,{value:!0}),e),m={};u(m,{isValidAccessToken:()=>x,readAuthConfig:()=>y,writeAuthConfig:()=>b}),n.exports=p(m);var h=f(e(`fs`)),g=f(e(`path`)),_=s();function v(){let e=(0,_.getVercelDataDir)();if(!e)throw Error(`Unable to find Vercel CLI data directory. Your platform: ${process.platform}. Supported: darwin, linux, win32.`);return g.join(e,`auth.json`)}function y(){try{let e=v();if(!h.existsSync(e))return null;let t=h.readFileSync(e,`utf8`);return t?JSON.parse(t):null}catch{return null}}function b(e){let t=v(),n=g.dirname(t);h.existsSync(n)||h.mkdirSync(n,{mode:504,recursive:!0}),h.writeFileSync(t,JSON.stringify(e,null,2),{mode:384})}function x(e,t=0){if(!e.token)return!1;if(typeof e.expiresAt!=`number`)return!0;let n=Math.floor(Date.now()/1e3),r=t/1e3;return e.expiresAt>=n+r}0&&(n.exports={isValidAccessToken:x,readAuthConfig:y,writeAuthConfig:b})})),o=t(((t,n)=>{var r=Object.defineProperty,i=Object.getOwnPropertyDescriptor,a=Object.getOwnPropertyNames,o=Object.prototype.hasOwnProperty,s=(e,t)=>{for(var n in t)r(e,n,{get:t[n],enumerable:!0})},c=(e,t,n,s)=>{if(t&&typeof t==`object`||typeof t==`function`)for(let c of a(t))!o.call(e,c)&&c!==n&&r(e,c,{get:()=>t[c],enumerable:!(s=i(t,c))||s.enumerable});return e},l=e=>c(r({},`__esModule`,{value:!0}),e),u={};s(u,{processTokenResponse:()=>g,refreshTokenRequest:()=>h}),n.exports=l(u);var d=e(`os`);let f=`@vercel/oidc node-${process.version} ${(0,d.platform)()} (${(0,d.arch)()}) ${(0,d.hostname)()}`,p=null;async function m(){if(p)return p;let e=await fetch(`https://vercel.com/.well-known/openid-configuration`,{headers:{"user-agent":f}});if(!e.ok)throw Error(`Failed to discover OAuth endpoints`);let t=await e.json();if(!t||typeof t.token_endpoint!=`string`)throw Error(`Invalid OAuth discovery response`);let n=t.token_endpoint;return p=n,n}async function h(e){let t=await m();return await fetch(t,{method:`POST`,headers:{"Content-Type":`application/x-www-form-urlencoded`,"user-agent":f},body:new URLSearchParams({client_id:`cl_HYyOPBNtFMfHhaUn9L4QPfTZz6TP47bp`,grant_type:`refresh_token`,...e})})}async function g(e){let t=await e.json();if(!e.ok){let e=typeof t==`object`&&t&&`error`in t?String(t.error):`Token refresh failed`;return[Error(e)]}return typeof t!=`object`||!t?[Error(`Invalid token response`)]:typeof t.access_token==`string`?t.token_type===`Bearer`?typeof t.expires_in==`number`?[null,t]:[Error(`Missing expires_in in response`)]:[Error(`Invalid token_type in response`)]:[Error(`Missing access_token in response`)]}0&&(n.exports={processTokenResponse:g,refreshTokenRequest:h})})),s=t(((t,s)=>{var c=Object.create,l=Object.defineProperty,u=Object.getOwnPropertyDescriptor,d=Object.getOwnPropertyNames,f=Object.getPrototypeOf,p=Object.prototype.hasOwnProperty,m=(e,t)=>{for(var n in t)l(e,n,{get:t[n],enumerable:!0})},h=(e,t,n,r)=>{if(t&&typeof t==`object`||typeof t==`function`)for(let i of d(t))!p.call(e,i)&&i!==n&&l(e,i,{get:()=>t[i],enumerable:!(r=u(t,i))||r.enumerable});return e},g=(e,t,n)=>(n=e==null?{}:c(f(e)),h(t||!e||!e.__esModule?l(n,`default`,{value:e,enumerable:!0}):n,e)),_=e=>h(l({},`__esModule`,{value:!0}),e),v={};m(v,{assertVercelOidcTokenResponse:()=>k,findProjectInfo:()=>A,getTokenPayload:()=>N,getVercelDataDir:()=>E,getVercelOidcToken:()=>O,getVercelToken:()=>D,isExpired:()=>P,loadToken:()=>M,saveToken:()=>j}),s.exports=_(v);var y=g(e(`path`)),b=g(e(`fs`)),x=n(),S=i(),C=a(),w=o(),T=r();function E(){let e=(0,S.getUserDataDir)();return e?y.join(e,`com.vercel.cli`):null}async function D(e){let t=(0,C.readAuthConfig)();if(!t?.token)throw new T.AccessTokenMissingError;if((0,C.isValidAccessToken)(t,e?.expirationBufferMs))return t.token;if(!t.refreshToken)throw(0,C.writeAuthConfig)({}),new T.RefreshAccessTokenFailedError(`No refresh token available`);try{let e=await(0,w.refreshTokenRequest)({refresh_token:t.refreshToken}),[n,r]=await(0,w.processTokenResponse)(e);if(n||!r)throw(0,C.writeAuthConfig)({}),new T.RefreshAccessTokenFailedError(n);let i={token:r.access_token,expiresAt:Math.floor(Date.now()/1e3)+r.expires_in};return r.refresh_token&&(i.refreshToken=r.refresh_token),(0,C.writeAuthConfig)(i),i.token}catch(e){throw(0,C.writeAuthConfig)({}),e instanceof T.AccessTokenMissingError||e instanceof T.RefreshAccessTokenFailedError?e:new T.RefreshAccessTokenFailedError(e)}}async function O(e,t,n){let r=`https://api.vercel.com/v1/projects/${t}/token?source=vercel-oidc-refresh${n?`&teamId=${n}`:``}`,i=await fetch(r,{method:`POST`,headers:{Authorization:`Bearer ${e}`}});if(!i.ok)throw new x.VercelOidcTokenError(`Failed to refresh OIDC token: ${i.statusText}`);let a=await i.json();return k(a),a}function k(e){if(!e||typeof e!=`object`)throw TypeError("Vercel OIDC token is malformed. Expected an object. Please run `vc env pull` and try again");if(!(`token`in e)||typeof e.token!=`string`)throw TypeError("Vercel OIDC token is malformed. Expected a string-valued token property. Please run `vc env pull` and try again")}function A(){let e=(0,S.findRootDir)();if(!e)throw new x.VercelOidcTokenError("Unable to find project root directory. Have you linked your project with `vc link?`");let t=y.join(e,`.vercel`,`project.json`);if(!b.existsSync(t))throw new x.VercelOidcTokenError("project.json not found, have you linked your project with `vc link?`");let n=JSON.parse(b.readFileSync(t,`utf8`));if(typeof n.projectId!=`string`&&typeof n.orgId!=`string`)throw TypeError("Expected a string-valued projectId property. Try running `vc link` to re-link your project.");return{projectId:n.projectId,teamId:n.orgId}}function j(e,t){let n=(0,S.getUserDataDir)();if(!n)throw new x.VercelOidcTokenError(`Unable to find user data directory. Please reach out to Vercel support.`);let r=y.join(n,`com.vercel.token`,`${t}.json`),i=JSON.stringify(e);b.mkdirSync(y.dirname(r),{mode:504,recursive:!0}),b.writeFileSync(r,i),b.chmodSync(r,432)}function M(e){let t=(0,S.getUserDataDir)();if(!t)throw new x.VercelOidcTokenError(`Unable to find user data directory. Please reach out to Vercel support.`);let n=y.join(t,`com.vercel.token`,`${e}.json`);if(!b.existsSync(n))return null;let r=JSON.parse(b.readFileSync(n,`utf8`));return k(r),r}function N(e){let t=e.split(`.`);if(t.length!==3)throw new x.VercelOidcTokenError("Invalid token. Please run `vc env pull` and try again");let n=t[1].replace(/-/g,`+`).replace(/_/g,`/`),r=n.padEnd(n.length+(4-n.length%4)%4,`=`);return JSON.parse(Buffer.from(r,`base64`).toString(`utf8`))}function P(e,t=0){return e.exp*1e3<Date.now()+t}0&&(s.exports={assertVercelOidcTokenResponse:k,findProjectInfo:A,getTokenPayload:N,getVercelDataDir:E,getVercelOidcToken:O,getVercelToken:D,isExpired:P,loadToken:M,saveToken:j})}));export{r as n,n as r,s as t};

package/dist/src/compiled/_chunks/node/token-util-DwHQ2a3c.js

@@ -1 +0,0 @@
-import{t as e}from"./token-util-DpJNusVS.js";export default e();export{};

package/dist/src/compiled/_chunks/node/version-C__MqbLM.js

@@ -1 +0,0 @@
-const e=`3.3.0`;export{e as t};

package/dist/src/public/channels/slack/approval-cards.d.ts

@@ -1,25 +0,0 @@
-/**
- * eve's default Slack rendering for human-input requests: posting approval
- * and question controls, and retiring an approval's messages once it resolves.
- */
-import type { RefusedAnswer, RequestBatch, RequestSettlement } from "#channel/interaction-prompts.js";
-import type { SlackApprovalChannelResolver, SlackChannelInternalEvents, SlackEventContext } from "#public/channels/slack/slackChannel.js";
-/**
- * Default `interaction.opened` handler — renders each pending HITL
- * request as Slack `block_actions`. Buttons by default; radio for
- * ≤6-option select requests; static_select for >6-option select
- * requests. Batches split into multiple posts when they would exceed
- * Slack's 50-block message cap.
- */
-export declare function defaultInteractionsHandler(approvalChannel?: SlackApprovalChannelResolver): (data: RequestBatch, ctx: Parameters<NonNullable<SlackChannelInternalEvents["interaction.opened"]>>[1]) => Promise<void>;
-/**
- * A responder an approval's policy or check refused hears why privately. A pending answer gets
- * no notice: an ephemeral cannot be removed once the approval settles, and the card itself
- * reports the outcome moments later.
- */
-export declare function notifyRefusedResponder(refused: RefusedAnswer, channel: SlackEventContext): Promise<void>;
-/**
- * Retires an approval's card: with the person whose press decided it, or as no longer needed
- * when it ended any other way (the user replied instead, or it was withdrawn).
- */
-export declare function settleApproval(resolution: RequestSettlement, channel: SlackEventContext): Promise<void>;

package/dist/src/public/channels/slack/approval-cards.js

@@ -1,2 +0,0 @@
-import{createLogger,logError}from"#internal/logging.js";import{slackUserIdForPrincipal,slackUserIdFromAuthContext}from"#public/channels/slack/auth.js";import{SLACK_MAX_BLOCKS_PER_MESSAGE,truncateMessageText}from"#public/channels/slack/limits.js";import{buildAnsweredBlocks,decodeHitlActionId,renderInteractionPostParts}from"#public/channels/slack/hitl.js";import{answeredBlocksFromActionBlock}from"#public/channels/slack/interaction-cards.js";import{deliverPrivateInteraction}from"#public/channels/slack/private-approval-delivery.js";const log=createLogger(`slack.defaults`);function defaultInteractionsHandler(e){return async(t,n)=>{let{channel:r}=n,i=[],a=[];for(let r of t.requests)((e===void 0?`thread`:await e(r,n))===`direct-message`?i:a).push(r);await postPublicInteractions(a,r);for(let e of i){let t=slackUserIdFromAuthContext(n.session.auth.current)??r.state.triggeringUserId;if(!t){log.warn(`direct-message input request not delivered because no reviewer was resolved`,{requestId:e.interactionId,sessionId:n.session.id});continue}let i=await deliverPrivateInteraction({previewMessageTs:r.state.triggeringMessageTs??r.slack.threadTs,request:e,reviewer:t,slack:r.slack});recordApprovalCards(r.state,[e],i);try{let n=await r.thread.post(`Waiting on ${e.request.kind===`approval`?`approval`:`a response`} from <@${t}>…`);n.id&&recordApprovalCards(r.state,[e],{...i,announcementTs:n.id})}catch(t){logError(log,`failed to announce private input request`,t,{requestId:e.interactionId,sessionId:n.session.id})}}}}async function postPublicInteractions(e,t){let n=new Map;for(let r of buildInteractionPosts(e)){let e=await t.thread.post({blocks:r.blocks,text:r.text});if(r.kind===`details`){if(e.id)for(let t of r.requests)n.set(t.interactionId,e.id);continue}for(let i of r.requests){let a=n.get(i.interactionId);recordApprovalCards(t.state,[i],{detailsMessageTs:a,messageBlocks:r.blocks,messageTs:e.id})}}}function recordApprovalCards(e,t,n){if(!n.messageTs)return;let r={...e.pendingApprovalCards};for(let e of t)e.request.kind===`approval`&&(r[e.interactionId]=n);e.pendingApprovalCards=r}async function settleApprovalCard(e,t,n){let r=e.state.pendingApprovalCards??{},i=r[t];if(i===void 0)return;let a={...r};delete a[t],e.state.pendingApprovalCards=a;let o=i.messageChannelId??e.state.channelId;if(o===null)return;let s=i.messageBlocks.flatMap(e=>blockContainsRequestAction(e,t)?answeredBlocksFromActionBlock({answerLabel:n.label,block:e,userId:n.userId})??buildAnsweredBlocks({answerLabel:n.label,promptBlocks:[]}):[e]);for(let[e,t]of Object.entries(a))t.messageTs===i.messageTs&&(a[e]={...t,messageBlocks:s});await settleRequest(e,`chat.update`,t,{blocks:s,channel:o,text:n.text,ts:i.messageTs});let c=i.detailsMessageTs;c!==void 0&&!Object.values(a).some(e=>e.detailsMessageTs===c)&&await settleRequest(e,`chat.delete`,t,{channel:o,ts:c}),i.announcementTs!==void 0&&e.state.channelId!==null&&await settleRequest(e,`chat.update`,t,{channel:e.state.channelId,text:n.announcement,ts:i.announcementTs})}async function settleRequest(e,t,n,r){try{let i=await e.slack.request(t,r);i.ok!==!0&&log.warn(`failed to retire approval message`,{error:i.error,operation:t,requestId:n})}catch(e){logError(log,`failed to retire approval message`,e,{operation:t,requestId:n})}}function buildInteractionPosts(e){let t=[],n=[];for(let r of e){let e=renderInteractionPostParts(r);e.details&&t.push({...e.details,request:r}),n.push({...e.controls,request:r})}return[...groupInteractionPostParts(t).map(e=>({...e,kind:`details`})),...groupInteractionPostParts(n).map(e=>({...e,kind:`controls`}))]}function groupInteractionPostParts(e){let t=[];for(let n of e){let e=t.at(-1);e&&e.blocks.length+n.blocks.length<=SLACK_MAX_BLOCKS_PER_MESSAGE?(e.blocks.push(...n.blocks),e.fallbacks.push(n.text),e.requests.push(n.request)):t.push({blocks:[...n.blocks],fallbacks:[n.text],requests:[n.request]})}return t.map(e=>({blocks:e.blocks,requests:e.requests,text:truncateMessageText(e.fallbacks.join(`
-`))}))}function blockContainsRequestAction(e,t){if(typeof e!=`object`||!e)return!1;let n=e;return[n.actions,n.elements].some(e=>Array.isArray(e)&&e.some(e=>{if(typeof e!=`object`||!e)return!1;let n=e.action_id;return typeof n==`string`&&decodeHitlActionId(n)?.requestId===t}))}async function notifyRefusedResponder(e,t){let n=slackUserIdForPrincipal(t.state,e.responder?.id);n!==void 0&&await t.thread.postEphemeral(n,e.reason??`We couldn’t verify your response. Please try again.`)}async function settleApproval(e,t){if(e.kind!==`approval`)return;if(e.outcome!==`accepted`&&e.outcome!==`declined`){await settleApprovalCard(t,e.interactionId,{announcement:`This approval is no longer needed.`,label:`No longer needed`,text:`No longer needed`});return}let n=e.outcome===`accepted`,r=slackUserIdForPrincipal(t.state,e.responder?.id),i=r===void 0?``:` by <@${r}>`,a=n?`Approve`:`Cancel`;await settleApprovalCard(t,e.interactionId,{announcement:`${n?`Approved`:`Cancelled`}${i}.`,label:a,text:`Answered: ${a}`,userId:r})}export{defaultInteractionsHandler,notifyRefusedResponder,settleApproval};

package/dist/src/runtime/agent/model-catalog.d.ts

@@ -1,10 +0,0 @@
-export interface RuntimeModelMetadata {
-    readonly contextWindowTokens: number;
-    readonly maxOutputTokens?: number;
-    readonly resolvedModelId: string;
-}
-export interface RuntimeModelCatalog {
-    getByGatewayId(modelId: string): Promise<RuntimeModelMetadata | null>;
-    getByProviderModelId(provider: string, providerModelId: string): Promise<RuntimeModelMetadata | null>;
-}
-export declare function createRuntimeModelCatalog(fetchCatalog?: typeof globalThis.fetch): RuntimeModelCatalog;

package/dist/src/runtime/agent/model-catalog.js

@@ -1 +0,0 @@
-import{AI_GATEWAY_MODELS_CATALOG_URL,vercelGatewayFetch}from"#internal/gateway.js";import{findCatalogModelByProviderModelId,findCatalogModelBySlug,modelCatalogLimitsFromProvider,modelCatalogResponseSchema}from"#internal/model-catalog.js";function createRuntimeModelCatalog(e=vercelGatewayFetch){let t=null,loadCatalog=async()=>(t===null&&(t=e(AI_GATEWAY_MODELS_CATALOG_URL).then(async e=>{if(!e.ok)throw Error(`AI Gateway model catalog request failed with HTTP ${e.status} ${e.statusText}.`);return parseCatalogResponse(await e.json())}).catch(e=>{throw t=null,e})),await t);return{async getByGatewayId(e){let t=await loadCatalog(),n=findCatalogModelBySlug(t.models,e);if(n===void 0)return null;for(let e of n.providers){let t=modelCatalogLimitsFromProvider(e);if(t!==null)return{...t,resolvedModelId:n.slug}}return null},async getByProviderModelId(e,t){let n=await loadCatalog(),r=findCatalogModelByProviderModelId({models:n.models,provider:e,providerAliases:n.providerAliases,providerModelId:t});if(r===null)return null;let i=modelCatalogLimitsFromProvider(r.provider);return i===null?null:{...i,resolvedModelId:r.model.slug}}}}function parseCatalogResponse(e){let t=modelCatalogResponseSchema.safeParse(e);if(!t.success)throw Error(`AI Gateway model catalog response did not match the expected schema.`);return t.data}export{createRuntimeModelCatalog};