experimental-ash 0.18.0 → 0.18.2

package/CHANGELOG.md

@@ -1,5 +1,46 @@
 # experimental-ash
 
+## 0.18.2
+
+### Patch Changes
+
+- fd90ad7: fix(ash): ensure `SessionUseFn` returns a `SandboxSession` for consistency with `BootstrapUseFn`
+- cd3d65d: Fix Slack sessions that start without a `threadTs` (programmatic
+  `args.receive(slack, ...)`, schedule fires, etc.). Before this fix
+  each agent reply landed as a separate top-level channel message,
+  typing indicators silently no-opped, and follow-up `@mention`
+  replies started fresh sessions. The channel now auto-anchors on the
+  first agent post: the post's `ts` becomes the thread root, every
+  subsequent post and typing indicator threads under it, and the
+  parked session is re-keyed to `slack:<channelId>:<anchored-ts>` so a
+  follow-up mention resumes the same Ash session.
+- a4b3837: rename slack channel initialPost to initialMessage
+
+## 0.18.1
+
+### Patch Changes
+
+- 0d710b6: Fix `ResolveAgentError: Missing compiled module namespace for schedule
+source ...` when a Nitro cron fires a TypeScript schedule that declares
+  an `async run({ ... })` handler.
+
+  The compiler's runtime module map (`.ash/compile/module-map.mjs`) lists
+  every module-backed authored source the runtime needs to load lazily.
+  It already collected channels, connections, tools, hooks, the sandbox,
+  the agent config, and the model — but it silently dropped schedules.
+
+  Markdown schedules (and TypeScript schedules whose only body is a
+  `markdown` string) execute via the pre-compiled `markdown` captured in
+  the manifest, so they never tripped the gap. Schedules with a `run`
+  handler, on the other hand, must load their default export at dispatch
+  time — and that load went straight to `ResolveAgentError` because the
+  module map had no entry for `schedules/<name>.ts`.
+
+  Module-sourced schedules with `hasRun: true` are now included in the
+  compiled module map. Markdown schedules and `markdown`-only module
+  schedules are still omitted (their body lives in the manifest and the
+  dispatcher never loads the source).
+
 ## 0.18.0
 
 ### Minor Changes
@@ -63,9 +104,9 @@
   continuation-token format and initial state; `auth` flows through to
   `session.initiatorAuth`.
 
-  `slackChannel().receive` accepts an optional `initialPost` so callers
+  `slackChannel().receive` accepts an optional `initialMessage` so callers
   can post an anchor card before the agent runs; the agent's first turn
-  threads under that card. `threadTs` and `initialPost` are mutually
+  threads under that card. `threadTs` and `initialMessage` are mutually
   exclusive.
 
   The schedule dispatcher's receive invocation now shares its

package/dist/docs/public/channels/README.md

@@ -297,8 +297,20 @@ Semantics:
 - The first argument is the target channel module's default export -- import it directly
   from `agent/channels/<name>.ts`. Identity is matched by reference.
 
-Slack's `receive` accepts an optional `initialPost` so the target channel can post a card
-before the agent runs; subsequent agent turns thread under that card.
+### Slack thread anchoring
+
+When a Slack session starts without a `threadTs` (programmatic `args.receive(slack, ...)`,
+schedule fires, etc.), the channel **auto-anchors on the first agent post**: the message
+becomes the thread root, and every subsequent post, typing indicator, and inbound
+`@mention` reply in that thread resumes the same Ash session. Schedule digests, webhook
+hand-offs, and other session-from-nothing flows produce clean Slack threads with no extra
+wiring — the channel passes the new channel-local token to
+`ctx.session.setContinuationToken(...)`, and the runtime re-keys the parked session to
+`slack:<channelId>:<anchored-ts>` so follow-up mentions land back in the same workflow.
+
+Pass `initialMessage` when you want a structured anchor card to land _before_ the agent
+runs — useful for "Investigation Thread for INC-42"-style banners that should precede
+the model's first reply:
 
 ```ts
 import { Card, CardText } from "experimental-ash/channels/slack";
@@ -307,7 +319,7 @@ await args.receive(slack, {
   message: "Begin investigation",
   args: {
     channelId: "C0123ABC",
-    initialPost: {
+    initialMessage: {
       card: Card({ children: [CardText("Investigation Thread for INC-42")] }),
       fallbackText: "Investigation Thread for INC-42",
     },
@@ -316,13 +328,67 @@ await args.receive(slack, {
 });
 ```
 
-`threadTs` and `initialPost` are mutually exclusive: pass `threadTs` to join an existing
-thread, or `initialPost` to anchor a new one.
+`threadTs` and `initialMessage` are mutually exclusive: pass `threadTs` to join an existing
+thread, or `initialMessage` to anchor a new one. With neither, the first agent post anchors
+the thread automatically.
+
+## Continuation Tokens
+
+Each call to `send(message, { auth, continuationToken, state? })` from a channel route
+addresses a session by its **channel-local raw token**. The framework prepends the
+channel name (the file stem under `agent/channels/`) before handing the token to the
+runtime, so a Slack route that passes `"C0123ABC:1800000000.001234"` ends up addressing
+session `"slack:C0123ABC:1800000000.001234"`.
+
+Authored channels typically ship a small helper for building the token:
+
+```ts
+import { slackContinuationToken } from "experimental-ash/channels/slack";
+import { twilioContinuationToken } from "experimental-ash/channels/twilio";
+
+slackContinuationToken("C0123ABC", "1800000000.001234"); // "C0123ABC:1800000000.001234"
+twilioContinuationToken("+15551234567", "+15557654321"); // "+15551234567:+15557654321"
+```
+
+Custom channels just write a function that joins their identity fields. The framework
+does not derive anything for you — the channel owns its token format.
+
+### Re-keying mid-session
+
+When the identity that should address a session isn't known until the first agent post
+(Slack's auto-anchor: the post's `ts` becomes the thread root), the channel re-keys the
+parked session by calling `ctx.session.setContinuationToken(...)` from a handler. Pass
+the **channel-local raw token**; the runtime preserves the current channel namespace:
+
+```ts
+import { defineChannel } from "experimental-ash/channels";
+
+defineChannel<{ ref: string | null }>({
+  state: { ref: null },
+  context(state, session) {
+    return {
+      state,
+      registerAnchor(ref: string) {
+        state.ref = ref;
+        session.setContinuationToken(ref);
+      },
+    };
+  },
+  events: {
+    "message.completed"(_event, ctx) {
+      if (!ctx.state.ref) ctx.registerAnchor(mintRef());
+    },
+  },
+  routes: [
+    /* ... */
+  ],
+});
+```
 
-The card's `ts` becomes the session's continuation token, so any later `@mention` reply
-inside that thread resumes the same session instead of starting a new one. Without
-`initialPost`, programmatically-started Slack sessions have no thread to anchor under and
-follow-up mentions land in a fresh session.
+The workflow runtime disposes the current park hook at the next step boundary and
+registers a new one at the new token. Inbound deliveries already addressed to the old
+token are dropped — coordinate with your senders so follow-up traffic uses the new
+token.
 
 ## File Uploads
 

package/dist/docs/public/schedules.md

@@ -46,9 +46,18 @@ export default defineSchedule({
 - `waitUntil(promise)` — extends the cron task's lifetime past handler return so in-flight work settles before the Nitro task completes.
 - `appAuth` — pre-built APP auth context (`{ authenticator: "app", principalId: "ash:app", principalType: "runtime" }`). Pass to `receive(..., { auth: appAuth })` for schedules that run on behalf of the agent itself.
 
-#### Announce-then-deliver
+#### Slack thread anchoring
 
-A handler that hands off to Slack can post an anchor card before the agent runs so the thread shows "what this is about" up front; the agent's reply then lands threaded under that card. Same `initialPost` field [Slack's `receive`](./channels/README.md#cross-channel-hand-off) accepts from a route handler:
+A schedule that hands off to Slack does not need a pre-existing thread. The channel
+[auto-anchors](./channels/README.md#slack-thread-anchoring) on the first agent post:
+that message becomes the thread root, the channel calls
+`ctx.session.setContinuationToken(...)` with the channel-local anchor token, and the
+runtime re-keys the parked session under the namespaced Slack token. The rest of the
+turn (plus any future `@mention` reply) threads under it. A digest that sparks a
+question can be answered in-thread without spinning up a new session.
+
+Pass `initialMessage` when you want a structured banner card to land _before_ the agent
+runs — useful for "Daily Deploy Digest"-style headers:
 
 ```ts
 // agent/schedules/deploy-digest.ts
@@ -65,7 +74,7 @@ export default defineSchedule({
         message: "Summarize today's production deploys.",
         args: {
           channelId: "C0123ABC",
-          initialPost: {
+          initialMessage: {
             card: Card({ children: [CardText("Daily Deploy Digest")] }),
             fallbackText: "Daily Deploy Digest",
           },
@@ -77,7 +86,7 @@ export default defineSchedule({
 });
 ```
 
-`threadTs` and `initialPost` are mutually exclusive on Slack receive args. The anchor card's `ts` becomes the session's continuation token, so any later `@mention` reply in that thread resumes the same session — a digest that sparks a question can be answered in-thread without spinning up a new session.
+`threadTs` and `initialMessage` are mutually exclusive on Slack receive args.
 
 ### Markdown (`markdown`)
 

package/dist/src/channel/adapter-context.d.ts

@@ -3,5 +3,9 @@ import type { ChannelAdapter, ChannelAdapterContext } from "#channel/adapter.js"
 /**
  * Builds the {@link ChannelAdapterContext} the runtime hands to an
  * adapter's `deliver` hook, event handlers, and attachment resolver.
+ *
+ * Populates `session` with a live {@link SessionHandle} backed by the
+ * supplied accessor so handlers can read identity / auth and call
+ * `setContinuationToken(...)` to re-key the parked session.
  */
 export declare function buildAdapterContext<TCtx extends ChannelAdapterContext<any> = ChannelAdapterContext>(adapter: ChannelAdapter<TCtx>, accessor: ContextAccessor): TCtx;

package/dist/src/channel/adapter-context.js

@@ -1,6 +1,11 @@
+import { buildSessionHandle } from "#channel/session.js";
 /**
  * Builds the {@link ChannelAdapterContext} the runtime hands to an
  * adapter's `deliver` hook, event handlers, and attachment resolver.
+ *
+ * Populates `session` with a live {@link SessionHandle} backed by the
+ * supplied accessor so handlers can read identity / auth and call
+ * `setContinuationToken(...)` to re-key the parked session.
  */
 export function buildAdapterContext(adapter, accessor) {
     // `adapter.state` is stored loosely (`Record<string, unknown>`)
@@ -11,6 +16,7 @@ export function buildAdapterContext(adapter, accessor) {
     const baseCtx = {
         ctx: accessor,
         state: adapter.state ?? {},
+        session: buildSessionHandle(accessor),
     };
     return adapter.createAdapterContext
         ? adapter.createAdapterContext(baseCtx)

package/dist/src/channel/adapter.d.ts

@@ -2,6 +2,7 @@ import type { ContextAccessor } from "#context/key.js";
 import type { ContextProvider } from "#context/provider.js";
 import type { StepInput } from "#harness/types.js";
 import type { HandleMessageStreamEvent } from "#protocol/message.js";
+import type { SessionHandle } from "#channel/session.js";
 import type { DeliverPayload } from "#channel/types.js";
 /**
  * Context available to every adapter handler (`deliver` and event handlers).
@@ -11,6 +12,11 @@ import type { DeliverPayload } from "#channel/types.js";
  *
  * `ctx` provides read/write access to durable context keys (the same
  * {@link ContextAccessor} that tools and providers use).
+ *
+ * `session` is a live handle to the current session — id, auth,
+ * continuation token, plus an imperative {@link SessionHandle.setContinuationToken}
+ * for channels that need to re-key the session mid-turn (e.g. Slack's
+ * auto-anchor on first post).
  */
 export interface ChannelAdapterContext<TState = Record<string, unknown>> {
     /**
@@ -23,6 +29,10 @@ export interface ChannelAdapterContext<TState = Record<string, unknown>> {
      * to read during the turn.
      */
     readonly ctx: ContextAccessor;
+    /**
+     * Live handle to the current session.
+     */
+    readonly session: SessionHandle;
 }
 /**
  * Extracts the state type from a {@link ChannelAdapterContext} generic.
@@ -121,16 +131,6 @@ export type ChannelAdapter<TCtx extends ChannelAdapterContext<any> = ChannelAdap
      * construction time.
      */
     readonly fetchFile?: (url: string) => Promise<Buffer | FetchFileResult | null>;
-    /**
-     * Derives the continuation token from adapter state.
-     *
-     * The runtime calls this at park time when no explicit
-     * `continuationToken` was provided on {@link RunInput}. Returns
-     * `undefined` when the adapter's state does not yet contain enough
-     * information to form a token (e.g., a Slack adapter whose first
-     * post has not yet created the thread).
-     */
-    getContinuationToken?(): string | undefined;
 } & ChannelEventHandlers<TCtx>;
 /**
  * Produces the default {@link StepInput} when no custom adapter `deliver`

package/dist/src/channel/cross-channel-receive.d.ts

@@ -1,6 +1,6 @@
 import type { UserContent } from "ai";
 import type { ChannelAdapter } from "#channel/adapter.js";
-import type { CompiledChannel } from "#channel/compiled-channel.js";
+import { type CompiledChannel } from "#channel/compiled-channel.js";
 import type { InferReceiveArgs } from "#channel/receive-args.js";
 import type { Session } from "#channel/session.js";
 import type { Runtime, SessionAuthContext } from "#channel/types.js";

package/dist/src/channel/cross-channel-receive.js

@@ -1,3 +1,4 @@
+import { isCompiledChannel } from "#channel/compiled-channel.js";
 import { createSendFn } from "#channel/send.js";
 /**
  * Builds the `args.receive` closure used by every route handler. The
@@ -44,7 +45,46 @@ function resolveTargetByReference(ref, channels) {
             return channel;
         }
     }
+    const structurallyMatchedTarget = resolveTargetByRouteFingerprint(ref, channels);
+    if (structurallyMatchedTarget !== null) {
+        return structurallyMatchedTarget;
+    }
     throw new Error("args.receive(): the channel passed as the first argument is not registered " +
         "in this agent's channels/. Import the channel module's default export from " +
         "agent/channels/<name>.ts and pass that value.");
 }
+function resolveTargetByRouteFingerprint(ref, channels) {
+    if (!isCompiledChannel(ref)) {
+        return null;
+    }
+    const refFingerprint = createRouteFingerprint(ref);
+    if (refFingerprint === null) {
+        return null;
+    }
+    const matches = new Map();
+    for (const channel of channels) {
+        const definition = channel.definition;
+        if (definition === undefined || createRouteFingerprint(definition) !== refFingerprint) {
+            continue;
+        }
+        matches.set(channel.name, channel);
+    }
+    if (matches.size === 1) {
+        return [...matches.values()][0];
+    }
+    if (matches.size > 1) {
+        throw new Error("args.receive(): the channel passed as the first argument matches multiple " +
+            "registered channels by route shape. Import a channel with a unique route set " +
+            "from agent/channels/<name>.ts before passing it to args.receive().");
+    }
+    return null;
+}
+function createRouteFingerprint(channel) {
+    if (channel.routes.length === 0) {
+        return null;
+    }
+    const routes = channel.routes
+        .map((route) => `${route.method.toUpperCase()} ${route.path}`)
+        .sort();
+    return routes.join("\n");
+}

package/dist/src/channel/routes.d.ts

@@ -23,6 +23,13 @@ export interface SendPayload {
     readonly inputResponses?: readonly InputResponse[];
 }
 export type SendFn<TState = undefined> = (input: string | UserContent | SendPayload, options: SendOptions<TState>) => Promise<Session>;
+/**
+ * Options for {@link SendFn}. The channel owns its continuation-token
+ * format — pass the channel-local raw token (the framework prepends
+ * the channel name). Stateful channels also seed initial adapter
+ * state via {@link state}, which becomes the new session's `state`
+ * on first `runtime.run()` and is ignored on subsequent `deliver`s.
+ */
 export type SendOptions<TState = undefined> = TState extends undefined ? {
     auth: SessionAuthContext | null;
     continuationToken: string;

package/dist/src/channel/send.js

@@ -7,9 +7,9 @@ const log = createLogger("channel.send");
 export function createSendFn(runtime, adapter, channelName) {
     return async (input, options) => {
         const auth = options.auth;
+        const state = options.state;
         const rawToken = options.continuationToken;
         const continuationToken = `${channelName}:${rawToken}`;
-        const state = options.state;
         const { message: rawMessage, inputResponses } = normalizeSendInput(input);
         const message = serializeUrlFilePartsInMessage(rawMessage);
         try {

package/dist/src/channel/session.d.ts

@@ -1,3 +1,4 @@
+import type { ContextAccessor } from "#context/key.js";
 import type { HandleMessageStreamEvent } from "#protocol/message.js";
 import type { Runtime, SessionAuthContext } from "#channel/types.js";
 export interface Session {
@@ -7,12 +8,57 @@ export interface Session {
         startIndex?: number;
     }): Promise<ReadableStream<HandleMessageStreamEvent>>;
 }
+/**
+ * Live handle to the current session, exposed on `ctx.session` to
+ * `deliver` and event handlers. The framework hydrates the read-only
+ * fields from the active context at step start; mutations made through
+ * {@link SessionHandle.setContinuationToken} flow back through the
+ * context so the runtime can re-key the parked workflow hook at the
+ * next step boundary.
+ */
 export interface SessionHandle {
     readonly id: string;
+    /**
+     * Runtime-scoped continuation token (`<channelName>:<channel-local-token>`).
+     */
     readonly continuationToken: string;
     readonly auth: SessionAuthContext | null;
     readonly initiatorAuth: SessionAuthContext | null;
-    setContinuationToken(token: string): void;
+    /**
+     * Re-key the session under a new continuation token.
+     *
+     * Use this when the channel's resume address depends on data
+     * produced during the turn (e.g. Slack auto-anchoring its first
+     * post adopts the post's `ts` as the thread root). Pass the
+     * channel-local raw token, matching the token shape accepted by
+     * route `send()`; the session handle preserves the current channel
+     * namespace before writing to runtime context.
+     *
+     * Effects:
+     *
+     * - Updates `ContinuationTokenKey` in the active context to the
+     *   runtime-scoped token (`<channelName>:<rawToken>`).
+     * - Causes the workflow runtime to dispose its current park hook
+     *   and register a new one at the new token at the next step
+     *   boundary, so follow-up `deliver` calls keyed under the new
+     *   token resume the same session.
+     * - Idempotent — calling with the current token is a no-op.
+     *
+     * The session must already have a namespaced placeholder
+     * continuation token so the handle can preserve the channel name.
+     */
+    setContinuationToken(rawToken: string): void;
 }
 export declare function createSession(id: string, continuationToken: string, runtime: Runtime): Session;
 export declare function createGetSessionFn(runtime: Runtime): (sessionId: string) => Session;
+/**
+ * Builds a live {@link SessionHandle} backed by the active context
+ * accessor. Read-only fields resolve through getters so they reflect
+ * any updates made by other handlers within the same step (e.g. the
+ * `deliver` hook seeding `AuthKey` before an event handler reads
+ * `session.auth`).
+ *
+ * Used by {@link buildAdapterContext} to populate `ctx.session` on
+ * every adapter handler invocation.
+ */
+export declare function buildSessionHandle(accessor: ContextAccessor): SessionHandle;

package/dist/src/channel/session.js

@@ -1,3 +1,4 @@
+import { AuthKey, ContinuationTokenKey, InitiatorAuthKey, SessionIdKey, } from "#context/seed-keys.js";
 export function createSession(id, continuationToken, runtime) {
     return {
         id,
@@ -10,3 +11,48 @@ export function createSession(id, continuationToken, runtime) {
 export function createGetSessionFn(runtime) {
     return (sessionId) => createSession(sessionId, "", runtime);
 }
+/**
+ * Builds a live {@link SessionHandle} backed by the active context
+ * accessor. Read-only fields resolve through getters so they reflect
+ * any updates made by other handlers within the same step (e.g. the
+ * `deliver` hook seeding `AuthKey` before an event handler reads
+ * `session.auth`).
+ *
+ * Used by {@link buildAdapterContext} to populate `ctx.session` on
+ * every adapter handler invocation.
+ */
+export function buildSessionHandle(accessor) {
+    return {
+        get id() {
+            return accessor.get(SessionIdKey) ?? "";
+        },
+        get continuationToken() {
+            return accessor.get(ContinuationTokenKey) ?? "";
+        },
+        get auth() {
+            return accessor.get(AuthKey) ?? null;
+        },
+        get initiatorAuth() {
+            return accessor.get(InitiatorAuthKey) ?? null;
+        },
+        setContinuationToken(rawToken) {
+            const currentToken = accessor.get(ContinuationTokenKey) ?? "";
+            const token = namespaceContinuationToken(currentToken, rawToken);
+            // Idempotent: a redundant write would push the workflow body
+            // through a hook dispose / recreate cycle for no reason. The
+            // call must remain cheap so channels can call it from
+            // hot-path event handlers without measuring first.
+            if (currentToken === token)
+                return;
+            accessor.set(ContinuationTokenKey, token);
+        },
+    };
+}
+function namespaceContinuationToken(currentToken, rawToken) {
+    const separatorIndex = currentToken.indexOf(":");
+    if (separatorIndex <= 0) {
+        throw new Error("Cannot set session continuation token without an existing namespaced " +
+            "continuation token. Start the session with a placeholder continuationToken.");
+    }
+    return `${currentToken.slice(0, separatorIndex + 1)}${rawToken}`;
+}

package/dist/src/channel/types.d.ts

@@ -160,11 +160,12 @@ export interface RunInput {
      */
     readonly capabilities?: SessionCapabilities;
     /**
-     * Session continuation token for delivery and hook creation. When
-     * omitted, the runtime falls back to the adapter's
-     * `getContinuationToken()` at park time. This supports
-     * schedule-initiated sessions where the token depends on data
-     * produced during the first turn (e.g., the Slack thread `ts`).
+     * Session continuation token for delivery and hook creation. Channels
+     * can re-key the session during the first turn by calling
+     * `ctx.session.setContinuationToken(...)` (e.g. Slack auto-anchoring
+     * its first post adopts the post's `ts` as the thread root), so an
+     * initial placeholder token is acceptable when full identity isn't
+     * known until the channel emits its first message.
      */
     readonly continuationToken?: string;
     /**

package/dist/src/chunks/client-CKsU8Li3.js

@@ -0,0 +1,4 @@
+import{i as e,t}from"./chunk-8L7ocgPr.js";import{_ as n,f as r,g as i,l as a,p as o,v as s}from"./types-MZUhN0Zy.js";import{n as c,r as l,t as u}from"./token-util-CHjOk3A7.js";var d=class extends Error{status;body;constructor(e,t){super(t||`Server returned ${e}.`),this.name=`ClientError`,this.status=e,this.body=t}};function f(e){if(e instanceof DOMException)return e.name===`AbortError`;if(!(e instanceof Error))return!1;let t=`code`in e&&typeof e.code==`string`?e.code:void 0;return e.name===`AbortError`||e.message===`terminated`||t===`UND_ERR_SOCKET`||/abort|cancel|disconnect|premature close|socket|terminated/i.test(e.message)}async function*p(e){let t=e.getReader(),n=new TextDecoder,r=``;try{for(;;){let e=await t.read();if(e.done){r+=n.decode();break}e.value&&(r+=n.decode(e.value,{stream:!0}));let i=r.indexOf(`
+`);for(;i!==-1;){let e=r.slice(0,i).trim();r=r.slice(i+1),e.length>0&&(yield JSON.parse(e)),i=r.indexOf(`
+`)}}let e=r.trim();e.length>0&&(yield JSON.parse(e))}finally{t.releaseLock()}}function m(e,t,n){let r=t.startsWith(`/`)?t:`/${t}`,i=_(n);if(h(e)){let t=new URL(e);return t.pathname=`${g(t.pathname)}${r}`,t.search=i,t.hash=``,t.toString()}return`${g(e)}${r}${i}`}function h(e){return/^[a-z][a-z\d+\-.]*:/i.test(e)}function g(e){return e===`/`?``:e.endsWith(`/`)?e.slice(0,-1):e}function _(e){return!e||Object.keys(e).length===0?``:`?${new URLSearchParams(e).toString()}`}async function*v(e){let t=e.startIndex,n=e.maxReconnectAttempts;for(;;){let r=m(e.host,s(e.sessionId),t>0?{startIndex:String(t)}:void 0),i=await e.resolveHeaders(),a=await fetch(r,{headers:i,signal:e.signal??null});if(!a.ok){let e=await a.text();throw new d(a.status,e)}if(!a.body)throw new d(a.status,`Response body is null.`);let o=!1;try{for await(let e of p(a.body))t+=1,yield e}catch(e){if(!f(e))throw e;o=!0}if(!o||n<=0)return;--n}}var y=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,{SYMBOL_FOR_REQ_CONTEXT:()=>u,getContext:()=>d}),t.exports=c(l);let u=Symbol.for(`@vercel/request-context`);function d(){return globalThis[u]?.get?.()??{}}})),b=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},u=e=>c(r({},`__esModule`,{value:!0}),e),d={};s(d,{getVercelOidcToken:()=>m,getVercelOidcTokenSync:()=>h}),n.exports=u(d);var f=y(),p=l();async function m(t){let n=``,r;try{n=h()}catch(e){r=e}try{let[{getTokenPayload:r,isExpired:i},{refreshToken:a}]=await Promise.all([await import(`./token-util-CHjOk3A7.js`).then(t=>e(t.t())),await import(`./token-DtoyQZy2.js`).then(t=>e(t.default))]);(!n||i(r(n),t?.expirationBufferMs))&&(await a(t),n=h())}catch(e){let t=r instanceof Error?r.message:``;throw e instanceof Error&&(t=`${t}
+${e.message}`),t?new p.VercelOidcTokenError(t):e}return n}function h(){let e=(0,f.getContext)().headers?.[`x-vercel-oidc-token`]??process.env.VERCEL_OIDC_TOKEN;if(!e)throw Error(`The 'x-vercel-oidc-token' header is missing from the request. Do you have the OIDC option enabled in the Vercel project settings?`);return e}})),x=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},l=e=>s(n({},`__esModule`,{value:!0}),e),d={};o(d,{AccessTokenMissingError:()=>m.AccessTokenMissingError,RefreshAccessTokenFailedError:()=>m.RefreshAccessTokenFailedError,getContext:()=>p.getContext,getVercelOidcToken:()=>f.getVercelOidcToken,getVercelOidcTokenSync:()=>f.getVercelOidcTokenSync,getVercelToken:()=>h.getVercelToken}),t.exports=l(d);var f=b(),p=y(),m=c(),h=u()})),S=x();const C=`${i}/`,w=new Set([`localhost`,`127.0.0.1`,`0.0.0.0`,`::1`,`[::1]`]);function T(e){return w.has(e.hostname)}const E=`x-vercel-protection-bypass`,D=`x-vercel-trusted-oidc-idp-token`;function O(e){return e.pathname.endsWith(`/ash/v1`)||e.pathname.includes(C)}async function k(e){let t=A(e),n=await M(t,e.resourceUrl);return n!==null&&j(t,n),t}function A(e){let t=new Headers(F(e.headers)),n=process.env.VERCEL_AUTOMATION_BYPASS_SECRET?.trim();return n&&O(e.resourceUrl)&&t.set(E,n),t}function j(e,t){e.has(`authorization`)||e.set(`authorization`,`Bearer ${t}`),e.set(D,t)}async function M(e,t){return N(t)?e.get(`x-vercel-oidc-token`)?.trim()||await P():null}function N(e){return!(!O(e)||T(e))}async function P(){let e=process.env.VERCEL_OIDC_TOKEN?.trim();try{let e=(await(0,S.getVercelOidcToken)()).trim();if(e.length>0)return e}catch{return e??null}return e??null}function F(e){if(e!==void 0)return e instanceof Headers?e:Array.isArray(e)?e.map(([e,t])=>[e,t]):e}function I(){return{streamIndex:0}}function L(e){let t=B(e.events),n=e.session.streamIndex+e.events.length;return t?.type===`session.waiting`?{continuationToken:e.continuationToken??e.session.continuationToken,sessionId:e.sessionId,streamIndex:n}:I()}function R(e){let t;for(let n of e)V(n)&&(t=n.data.message??void 0);return t}function z(e){let t=B(e);return t?.type===`session.waiting`?`waiting`:t?.type===`session.failed`?`failed`:`completed`}function B(e){for(let t=e.length-1;t>=0;t--){let n=e[t];if(n!==void 0&&a(n))return n}}function V(e){return e.type===`message.completed`&&e.data.finishReason!==`tool-calls`}var H=class{continuationToken;sessionId;#e=!1;#t;constructor(e){this.continuationToken=e.continuationToken,this.sessionId=e.sessionId,this.#t=e.createStream}async result(){let e=[];for await(let t of this)e.push(t);return{events:e,message:R(e),sessionId:this.sessionId,status:z(e)}}[Symbol.asyncIterator](){if(this.#e)throw Error(`MessageResponse has already been consumed.`);return this.#e=!0,this.#t()}},U=class{#e;#t;constructor(e,t){this.#e=e,this.#t=t}get state(){return this.#t}async sendMessage(e,t){return this.send({message:e},t)}async send(e,t){let n=this.#t,{continuationToken:r,sessionId:i}=await this.#n(e,n,t);return new H({continuationToken:r,createStream:()=>this.#r(i,r,n,t),sessionId:i})}openStream(e){let t=this.#t.sessionId;if(!t)throw Error(`Session has no session ID. Send a message first.`);return v({host:this.#e.host,maxReconnectAttempts:this.#e.maxReconnectAttempts,resolveHeaders:()=>this.#e.resolveHeaders(),sessionId:t,signal:e?.signal,startIndex:e?.startIndex??this.#t.streamIndex})}async#n(e,t,i){let a=t.sessionId?n(t.sessionId):r,o=m(this.#e.host,a),s=await this.#e.resolveHeaders(i?.headers);s.set(`content-type`,`application/json`);let c=W({input:e,session:t});if(c===null)throw Error(`Session.send requires a non-empty message, inputResponses, or both.`);let l=await fetch(o,{body:JSON.stringify(c),headers:s,method:`POST`,signal:i?.signal??null});if(!l.ok){let e=await l.text();throw new d(l.status,e)}let u=await l.json(),f=(typeof u.sessionId==`string`?u.sessionId:void 0)??l.headers.get(`x-ash-session-id`)?.trim()??t.sessionId;if(!f)throw Error(`Message route did not return a session id.`);return{continuationToken:typeof u.continuationToken==`string`?u.continuationToken:void 0,sessionId:f}}async*#r(e,t,n,r){let i=[];try{let t=n.sessionId===e?n.streamIndex:0,o=this.#e.maxReconnectAttempts;for(;;){let n=await this.#i(e,t,r?.signal),s=!1;try{for await(let e of p(n))if(i.push(e),t+=1,yield e,a(e)){s=!0;break}}catch(e){if(!f(e))throw e}if(s||o<=0)break;--o}}finally{this.#t=L({continuationToken:t,events:i,sessionId:e,session:n})}}async#i(e,t,n){let r=m(this.#e.host,s(e),t>0?{startIndex:String(t)}:void 0),i=await this.#e.resolveHeaders(),a=await fetch(r,{headers:i,signal:n??null});if(!a.ok){let e=await a.text();throw new d(a.status,e)}if(!a.body)throw new d(a.status,`Response body is null.`);return a.body}};function W(e){let t={};return e.input.message!==void 0&&(t.message=e.input.message),e.input.inputResponses!==void 0&&e.input.inputResponses.length>0&&(t.inputResponses=e.input.inputResponses),e.session.continuationToken!==void 0&&(t.continuationToken=e.session.continuationToken),Object.keys(t).length===0||e.session.continuationToken===void 0&&t.message===void 0||`continuationToken`in t&&Object.keys(t).length===1?null:t}var G=class{#e;#t;#n;#r;constructor(e){this.#n=e.host,this.#e=e.auth,this.#t=e.headers,this.#r=e.maxReconnectAttempts??3}async health(){let e=m(this.#n,o),t=await this.#i(),n=await fetch(e,{headers:t});if(!n.ok){let e=await n.text();throw new d(n.status,e)}return await n.json()}session(e){let t;return t=typeof e==`string`?{continuationToken:e,streamIndex:0}:e||I(),new U({host:this.#n,maxReconnectAttempts:this.#r,resolveHeaders:e=>this.#i(e)},t)}async#i(e){let t=new Headers,n=await q(this.#t);for(let[e,r]of Object.entries(n))t.set(e,r);if(e)for(let[n,r]of Object.entries(e))t.set(n,r);let r=await this.#a();return r&&t.set(`authorization`,r),t}async#a(){let e=this.#e;if(e){if(`bearer`in e){let t=(await K(e.bearer)).trim();return t.length===0?void 0:`Bearer ${t}`}if(`basic`in e){let t=await K(e.basic.password);return`Basic ${J(e.basic.username,t)}`}}}};async function K(e){return typeof e==`function`?e():e}async function q(e){return e===void 0?{}:typeof e==`function`?await e():e}function J(e,t){let n=new TextEncoder().encode(`${e}:${t}`),r=Array.from(n,e=>String.fromCodePoint(e)).join(``);return btoa(r)}export{x as a,k as i,E as n,v as o,D as r,d as s,G as t};