eve 0.68.0 → 0.70.0

package/dist/src/public/channels/slack/renderers.d.ts

@@ -0,0 +1,76 @@
+import type { TaskCardView } from "#channel/task-card.js";
+import type { SessionContext } from "#public/definitions/callback-context.js";
+import type { UnstampedMessageStreamEvent } from "#protocol/message.js";
+import type { BlockKitBlock } from "#public/channels/slack/blocks.js";
+import type { SlackMessage } from "#public/channels/slack/inbound.js";
+import type { SlackAuthorizationEventContext, SlackChannelInternalEvents, SlackContext, SlackEventContext } from "#public/channels/slack/slackChannel.js";
+type EventData<T extends UnstampedMessageStreamEvent["type"]> = Extract<UnstampedMessageStreamEvent, {
+    type: T;
+}> extends {
+    data: infer D;
+} ? D : undefined;
+/** The session events a Slack renderer can handle, in no particular order. */
+declare const SLACK_RENDERED_EVENTS: readonly ["action.partial", "action.result", "actions.requested", "approval.candidate", "approval.settled", "authorization.completed", "authorization.required", "input.requested", "input.resolved", "message.appended", "message.completed", "reasoning.appended", "reasoning.completed", "session.completed", "session.failed", "session.waiting", "step.started", "task.settled", "task.started", "turn.cancelled", "turn.completed", "turn.failed", "turn.started", "turn.waiting"];
+export type SlackRenderedEvent = (typeof SLACK_RENDERED_EVENTS)[number];
+type SlackSessionEvent = Exclude<SlackRenderedEvent, "authorization.required" | "session.failed">;
+/**
+ * Runs the rest of the chain, ending with eve's default. Pass changed data to
+ * hand it on instead of the event; the rest of the chain runs at most once.
+ * Await it, so the rest of the chain finishes before the event does.
+ */
+export type SlackRenderNext<T extends SlackRenderedEvent> = (data?: EventData<T>) => Promise<void>;
+/** Renders one session event, before, after, around, or instead of the rest of the chain. */
+export type SlackRenderHandler<T extends SlackSessionEvent> = (data: EventData<T>, channel: SlackEventContext, ctx: SessionContext, next: SlackRenderNext<T>) => void | Promise<void>;
+/**
+ * Session event handlers of one {@link SlackRenderer}. `authorization.required`
+ * receives the private delivery surface, because the challenge is a
+ * credential; its `next` reaches eve's default, which posts the public,
+ * link-free status. `session.failed` has no session context.
+ */
+export type SlackRendererEvents = {
+    readonly [T in SlackSessionEvent]?: SlackRenderHandler<T>;
+} & {
+    readonly "authorization.required"?: (data: EventData<"authorization.required">, channel: SlackAuthorizationEventContext, ctx: SessionContext, next: SlackRenderNext<"authorization.required">) => void | Promise<void>;
+    readonly "session.failed"?: (data: EventData<"session.failed">, channel: SlackEventContext, next: SlackRenderNext<"session.failed">) => void | Promise<void>;
+};
+/** The message eve posts for a turn's tasks: Block Kit blocks and notification text. */
+export interface SlackTaskCard {
+    readonly blocks: readonly BlockKitBlock[];
+    readonly text: string;
+}
+/**
+ * One link in a Slack channel's rendering chain. Every part is optional and
+ * wraps the renderers after it, ending with eve's default renderer.
+ */
+export interface SlackRenderer {
+    /**
+     * Acknowledges a mention or DM as soon as it arrives, while the message hook
+     * is still deciding, and another channel message once `onMessage`
+     * dispatches it. eve's default sets the `Thinking...` status. If the hook
+     * drops the message, eve clears the thread status.
+     */
+    readonly received?: (message: SlackMessage, channel: SlackContext, next: () => Promise<void>) => void | Promise<void>;
+    /** Handlers for session events, such as posting replies and questions. */
+    readonly events?: SlackRendererEvents;
+    /**
+     * Returns the message for a turn's task card, or `null` for none. Runs for
+     * every turn that calls a tool; the view carries the turn's tasks and its
+     * other tool calls with their input. Pure and synchronous: eve posts the
+     * card, updates it as the turn changes, and handles Slack's rate limits.
+     * `next` returns eve's default card, which is `null` for a turn without tasks.
+     */
+    readonly taskCard?: (view: TaskCardView, next: (view: TaskCardView) => SlackTaskCard | null) => SlackTaskCard | null;
+}
+/** Types a Slack renderer. */
+export declare function defineSlackRenderer(renderer: SlackRenderer): SlackRenderer;
+/**
+ * A complete chain, whose handlers take no `next`: eve's default renderer,
+ * which is the innermost link, and the composed chain a channel runs.
+ */
+export interface SlackRenderChain {
+    readonly events: SlackChannelInternalEvents;
+    readonly received: (message: SlackMessage, channel: SlackContext) => Promise<void>;
+    readonly taskCard: (view: TaskCardView) => SlackTaskCard | null;
+}
+export declare function composeSlackRenderers(renderers: readonly SlackRenderer[], defaults: SlackRenderChain): SlackRenderChain;
+export {};

package/dist/src/public/channels/slack/renderers.js

@@ -0,0 +1 @@
+const SLACK_RENDERED_EVENTS=[`action.partial`,`action.result`,`actions.requested`,`approval.candidate`,`approval.settled`,`authorization.completed`,`authorization.required`,`input.requested`,`input.resolved`,`message.appended`,`message.completed`,`reasoning.appended`,`reasoning.completed`,`session.completed`,`session.failed`,`session.waiting`,`step.started`,`task.settled`,`task.started`,`turn.cancelled`,`turn.completed`,`turn.failed`,`turn.started`,`turn.waiting`];function defineSlackRenderer(e){return e}function composeSlackRenderers(e,t){return{events:composeEvents(e,t.events),received:(n,r)=>composeReceived(e,t,n,r,0),taskCard:n=>composeTaskCard(e,t,n,0)}}function composeEvents(e,t){let n={};for(let r of SLACK_RENDERED_EVENTS){let i=t[r],a=e.flatMap(e=>{let t=e.events?.[r];return t===void 0?[]:[t]});(a.length!==0||i!==void 0)&&(n[r]=r===`session.failed`?(e,t)=>runChain(a,e,(e,n,r)=>e(n,t,r),e=>i?.(e,t)):(e,t,n)=>runChain(a,e,(e,i,a)=>e(i,userChannel(r,t),n,a),e=>i?.(e,t,n)))}return n}async function runChain(e,t,n,r){let run=async(t,i)=>{if(t===e.length){await r(i);return}let a;await n(e[t],i,e=>a??=run(t+1,e===void 0?i:e))};await run(0,t)}function userChannel(e,t){return e===`authorization.required`?{postDirectMessage:(e,n)=>t.thread.postDirectMessage(e,n),postEphemeral:(e,n)=>t.thread.postEphemeral(e,n),state:t.state}:t}async function composeReceived(e,t,n,r,i){if(i===e.length){await t.received(n,r);return}let a=e[i].received;if(a===void 0){await composeReceived(e,t,n,r,i+1);return}let o;await a(n,r,()=>(o??=composeReceived(e,t,n,r,i+1),o))}function composeTaskCard(e,t,n,r){if(r===e.length)return t.taskCard(n);let i=e[r].taskCard;return i===void 0?composeTaskCard(e,t,n,r+1):i(n,n=>composeTaskCard(e,t,n,r+1))}export{composeSlackRenderers,defineSlackRenderer};

package/dist/src/public/channels/slack/reply-delivery.d.ts

@@ -0,0 +1,72 @@
+import type { DeliverPayload } from "#channel/types.js";
+import type { SlackChannelInternalEvents, SlackChannelState, SlackContext } from "#public/channels/slack/slackChannel.js";
+type MessageCompletedHandler = NonNullable<SlackChannelInternalEvents["message.completed"]>;
+/**
+ * A completed reply for {@link postCompletedSlackReply}: Markdown alone, or
+ * Markdown with the Block Kit blocks to try first. `markdown` is the full
+ * reply eve falls back to; `text` is the notification text for the blocks,
+ * defaulting to `markdown`.
+ */
+export type SlackCompletedReply = string | {
+    readonly markdown: string;
+    readonly blocks?: readonly unknown[];
+    readonly text?: string;
+};
+/**
+ * Posts a completed reply to the bound Slack thread with eve's delivery
+ * fallbacks, using only the content you pass. eve's default renderer posts
+ * its replies through it; an authored renderer opts in by calling it instead
+ * of `channel.thread.post`.
+ *
+ * eve tries, in order:
+ *
+ * 1. Your `blocks`, when given, with `text` as the notification text.
+ * 2. `markdown` as one native Markdown message, when it fits in
+ *    {@link SLACK_MARKDOWN_TEXT_MAX_LENGTH} characters. eve moves on from
+ *    the blocks only when Slack refuses them as too large or malformed
+ *    (`msg_too_long`, `msg_blocks_too_long`, `msg_blocks_too_many`,
+ *    `invalid_blocks`, or `invalid_blocks_format`).
+ * 3. `markdown` uploaded unchanged as an `eve-response.md` snippet with a
+ *    short note, when it is longer or Slack refuses the Markdown message.
+ *    This requires the `files:write` bot scope. In a session without a
+ *    thread yet, the note posts first and anchors the thread.
+ *
+ * Any other error, and a failed upload, is thrown so your renderer sees it.
+ * eve logs each fallback it takes with Slack's error code, never the reply.
+ *
+ * @example
+ * ```ts
+ * import { postCompletedSlackReply } from "eve/channels/slack";
+ *
+ * await postCompletedSlackReply(channel, {
+ *   blocks: [{ type: "markdown", text: reply }, sourcesBlock],
+ *   markdown: reply,
+ * });
+ * ```
+ */
+export declare function postCompletedSlackReply(channel: SlackContext, reply: SlackCompletedReply): Promise<void>;
+/**
+ * {@link postCompletedSlackReply} with fields for its fallback log, such as
+ * the turn id eve's default renderer knows.
+ */
+export declare function deliverCompletedSlackReply(channel: SlackContext, reply: SlackCompletedReply, logFields: {
+    readonly turnId?: string;
+}): Promise<void>;
+/**
+ * Wraps a channel's composed `message.completed` chain, authored renderers
+ * included, so a final reply that fails is never lost without a trace.
+ *
+ * When the chain throws on a final reply, eve logs the error at error level,
+ * posts a content-free notice with its error id, and tells the model on the
+ * next delivery that its reply was not seen. eve never sends the reply from
+ * here: the chain owns the content, including any change a renderer made
+ * before `next`, and {@link postCompletedSlackReply} owns the fallbacks.
+ * Steps that end in tool calls and empty replies pass through.
+ */
+export declare function withFinalReplyDelivery(render: MessageCompletedHandler | undefined): MessageCompletedHandler;
+/**
+ * Tells the model, ahead of the next message, that its previous reply never
+ * reached Slack, so it does not assume the user read that reply.
+ */
+export declare function withUndeliveredReplyNote<T extends DeliverPayload>(state: SlackChannelState, payload: T): T;
+export {};

package/dist/src/public/channels/slack/reply-delivery.js

@@ -0,0 +1 @@
+import{createLogger,logError}from"#internal/logging.js";import{SLACK_MARKDOWN_TEXT_MAX_LENGTH,truncateMessageText}from"#public/channels/slack/limits.js";const log=createLogger(`slack.reply`),LONG_RESPONSE_NOTICE=`Here's a snippet with the full response.`,FALLBACK_LOG=`Slack refused the final reply; delivering it with a fallback`,REFUSED_PAYLOAD_ERRORS=new Set([`invalid_blocks`,`invalid_blocks_format`,`msg_blocks_too_long`,`msg_blocks_too_many`,`msg_too_long`]);async function postCompletedSlackReply(e,t){await deliverCompletedSlackReply(e,t,{})}async function deliverCompletedSlackReply(e,t,n){let{blocks:r,markdown:i,text:a}=typeof t==`string`?{markdown:t}:t,o;if(r!==void 0)try{await e.thread.post({blocks:r,text:a??truncateMessageText(i)});return}catch(e){if(o=refusedPayloadError(e),o===void 0)throw e}if(i.length<=SLACK_MARKDOWN_TEXT_MAX_LENGTH){o!==void 0&&log.warn(FALLBACK_LOG,{fallback:`inline`,slackError:o,...n});try{await e.thread.post(i);return}catch(e){if(o=refusedPayloadError(e),o===void 0)throw e}}o!==void 0&&log.warn(FALLBACK_LOG,{fallback:`snippet`,slackError:o,...n}),await uploadReplySnippet(e,i)}async function uploadReplySnippet(e,t){let n={data:new Blob([t],{type:`text/markdown`}),filename:`eve-response.md`,mimeType:`text/markdown`},r=e.slack.threadTs.length>0;if(!r&&(!(await e.thread.post(LONG_RESPONSE_NOTICE)).id||e.slack.threadTs.length===0))throw Error(`Slack did not return a thread timestamp for the long response notice.`);await e.slack.uploadFiles([n],{initialComment:r?LONG_RESPONSE_NOTICE:void 0,snippetType:`markdown`})}function refusedPayloadError(e){let t=e;for(let e=0;e<5&&typeof t==`object`&&t;e++){let e=t,n=e.response?.error??e.data?.error;if(typeof n==`string`&&REFUSED_PAYLOAD_ERRORS.has(n))return n;t=e.cause}}function withFinalReplyDelivery(e){return async(t,n,r)=>{if(t.finishReason===`tool-calls`||!t.message){await e?.(t,n,r);return}try{await e?.(t,n,r)}catch(e){await reportUndeliveredReply(n,t.turnId,e)}}}async function reportUndeliveredReply(e,t,n){let r=logError(log,`final reply was not delivered to Slack`,n,{turnId:t});e.state.undeliveredReplyErrorId=r;try{await e.thread.post(`I finished, but couldn't deliver my answer in Slack (error id \`${r}\`). Please ask me to resend it.`)}catch(e){logError(log,`undelivered reply notice failed`,e,{errorId:r,turnId:t})}}function withUndeliveredReplyNote(e,t){let n=e.undeliveredReplyErrorId;if(!n||t.message===void 0)return t;e.undeliveredReplyErrorId=null;let r=[`Your previous reply was not delivered to Slack (error id ${n}).`,`The user has not seen it. Do not assume they read it; send the answer again if they ask for it.`].join(` `);return{...t,context:[r,...t.context??[]]}}export{deliverCompletedSlackReply,postCompletedSlackReply,withFinalReplyDelivery,withUndeliveredReplyNote};

package/dist/src/public/channels/slack/session-operations.d.ts

@@ -34,4 +34,10 @@ export declare function bindSlackSessionOperations(input: {
     readonly resolveSession: ChannelResolveSession;
     readonly state: SlackChannelState;
 }): SlackSessionOperations;
+/**
+ * Stamps the verified Slack user behind an input response, so `deliver` can map
+ * a custom-auth responder's principal to them. The verified user wins over any
+ * caller-supplied value.
+ */
+export declare function withSlackResponder(state: Partial<SlackChannelState> | undefined, slackUserId: string | null | undefined): Partial<SlackChannelState> | undefined;
 export {};

package/dist/src/public/channels/slack/session-operations.js

@@ -1 +1 @@
-function bindSlackSessionOperations(e){let t=e.from(e.address),auth=t=>t===void 0?e.defaultAuth:t;return{async send(n,r={}){return await t.send(n,{...r,auth:auth(r.auth),state:e.state})},async respond(e,n={}){return await t.respond(e,{...n,auth:auth(n.auth)})},async cancel(e){return await t.cancel(e)},async compact(){return await t.compact()},async clear(){return await t.clear()},async reset(e){return await t.reset(e)},async resolveSession(){return await e.resolveSession(e.address)}}}export{bindSlackSessionOperations};
+function bindSlackSessionOperations(e){let t=e.from(e.address),auth=t=>t===void 0?e.defaultAuth:t;return{async send(n,r={}){return await t.send(n,{...r,auth:auth(r.auth),state:e.state})},async respond(n,r={}){return await t.respond(n,{...r,auth:auth(r.auth),state:withSlackResponder(r.state,e.state.triggeringUserId)})},async cancel(e){return await t.cancel(e)},async compact(){return await t.compact()},async clear(){return await t.clear()},async reset(e){return await t.reset(e)},async resolveSession(){return await e.resolveSession(e.address)}}}function withSlackResponder(e,t){return t?{...e,triggeringUserId:t}:e}export{bindSlackSessionOperations,withSlackResponder};

package/dist/src/public/channels/slack/sign-in-cancel.d.ts

@@ -0,0 +1,20 @@
+import type { ChannelFrom } from "#channel/channel-operations.js";
+import type { SlackChannelState } from "#public/channels/slack/slackChannel.js";
+/** `action_id` of the sign-in prompt's Cancel button; outside eve's `eve_input:` HITL prefix. */
+export declare const SIGN_IN_CANCEL_ACTION_ID = "eve_sign_in:cancel";
+/** The held turn a sign-in prompt's Cancel button cancels. */
+export interface SignInCancelTarget {
+    readonly channelId: string;
+    readonly threadTs: string;
+    readonly turnId: string;
+}
+/** Reads a Cancel click's target from a sign-in prompt's button value. */
+export declare function parseSignInCancelTarget(value: unknown): SignInCancelTarget | undefined;
+/**
+ * Handles a click on a sign-in prompt's Cancel button in the background.
+ * Returns false for any other interaction.
+ */
+export declare function dispatchSignInCancel(raw: Record<string, unknown>, ctx: {
+    readonly from: ChannelFrom<SlackChannelState>;
+    readonly waitUntil: (task: Promise<unknown>) => void;
+}): boolean;

package/dist/src/public/channels/slack/sign-in-cancel.js

@@ -0,0 +1 @@
+import{createLogger}from"#internal/logging.js";import{slackContinuationToken}from"#public/channels/slack/api.js";const log=createLogger(`slack.interactions`),SIGN_IN_CANCEL_ACTION_ID=`eve_sign_in:cancel`;function parseSignInCancelTarget(e){if(typeof e!=`string`)return;let t;try{t=JSON.parse(e)}catch{return}if(typeof t!=`object`||!t)return;let{channelId:n,threadTs:r,turnId:i}=t;if(typeof n==`string`&&typeof r==`string`&&typeof i==`string`)return{channelId:n,threadTs:r,turnId:i}}function dispatchSignInCancel(e,t){let n=readSignInCancel(e);return n!==void 0&&(t.waitUntil(cancelHeldSignIn(n,t)),!0)}function readSignInCancel(e){let t=parseSignInCancelTarget((Array.isArray(e.actions)?e.actions:[]).find(e=>isObjectRecord(e)&&e.action_id===`eve_sign_in:cancel`)?.value);if(t!==void 0)return{responseUrl:typeof e.response_url==`string`?e.response_url:void 0,target:t}}async function cancelHeldSignIn(e,t){let{channelId:n,threadTs:r,turnId:i}=e.target;try{await t.from(slackContinuationToken(n,r)).cancel({turnId:i})}catch(e){log.error(`sign-in cancel delivery failed`,{error:e});return}if(e.responseUrl!==void 0)try{await fetch(e.responseUrl,{body:JSON.stringify({delete_original:!0}),headers:{"content-type":`application/json`},method:`POST`})}catch(e){log.warn(`failed to remove the cancelled sign-in prompt`,{error:e})}}function isObjectRecord(e){return typeof e==`object`&&!!e&&!Array.isArray(e)}export{SIGN_IN_CANCEL_ACTION_ID,dispatchSignInCancel,parseSignInCancelTarget};

package/dist/src/public/channels/slack/slackChannel.d.ts

@@ -1,7 +1,7 @@
 import type { UserContent } from "ai";
 import type { ChannelResolveSession, ChannelSource } from "#channel/channel-operations.js";
 import type { Session } from "#channel/session.js";
-import type { SessionAuthContext, TaskDeliveryPolicy, TurnPolicy } from "#channel/types.js";
+import type { SessionAuthContext, TurnPolicy } from "#channel/types.js";
 import type { VercelConnectMetadata } from "#shared/vercel-connect-metadata.js";
 import type { CardElement } from "#compiled/chat/index.js";
 import type { SessionContext } from "#public/definitions/callback-context.js";
@@ -10,6 +10,8 @@ import type { UnstampedMessageStreamEvent } from "#protocol/message.js";
 import type { InputRequest, InputResponse, StrictInputResponses, ValidatedInputResponse } from "#shared/input.js";
 import { type SlackBotToken, type SlackHandle, type SlackThread, type SlackWorkspaceHandle } from "#public/channels/slack/api.js";
 import { type SlackTransportOptions } from "#public/channels/slack/transport.js";
+import { type SlackRenderedEvent, type SlackRenderer } from "#public/channels/slack/renderers.js";
+import { type SlackTaskCardState } from "#public/channels/slack/task-card.js";
 import { type SlackEvent, type SlackEventEnvelope, type SlackMessage } from "#public/channels/slack/inbound.js";
 import { type LoadThreadContextMessagesOptions } from "#public/channels/slack/thread.js";
 import { type SlackSessionOperations } from "#public/channels/slack/session-operations.js";
@@ -17,7 +19,6 @@ import { type UploadPolicyInput } from "#public/channels/upload-policy.js";
 import { type SlackWebhookVerifier } from "#public/channels/slack/verify.js";
 import { type Channel } from "#public/definitions/channel.js";
 import { type ChannelAudience } from "#shared/channel-audience.js";
-import { type SlackActivityRenderer } from "#public/channels/slack/activity.js";
 export type { SlackRespondOptions, SlackSendOptions, SlackSessionOperations, } from "#public/channels/slack/session-operations.js";
 type EventData<T extends UnstampedMessageStreamEvent["type"]> = Extract<UnstampedMessageStreamEvent, {
     type: T;
@@ -55,12 +56,8 @@ export interface SlackEventContext extends SlackChannelContext, ChannelContinuat
 export type { SlackApiResponse, SlackBotToken, SlackHandle, SlackThread, SlackWorkspaceHandle, } from "#public/channels/slack/api.js";
 export type { SlackWebhookVerifier } from "#public/channels/slack/verify.js";
 type SlackEventHandler<T extends UnstampedMessageStreamEvent["type"]> = (data: EventData<T>, channel: SlackEventContext, ctx: SessionContext) => void | Promise<void>;
-export type SlackInputRequestedEvent = EventData<"input.requested">;
-/** Bound access to eve's standard Slack input delivery. */
-export type SlackInputRequestedDefaultDeliver = (data: SlackInputRequestedEvent) => Promise<void>;
-export type SlackInputRequestedHandler = (data: SlackInputRequestedEvent, channel: SlackEventContext, ctx: SessionContext, defaultDeliver: SlackInputRequestedDefaultDeliver) => void | Promise<void>;
 /**
- * Delivery surface handed to `authorization.required` overrides. The
+ * Delivery surface handed to a renderer's `authorization.required` handler. The
  * connection challenge is a credential: anyone who completes the sign-in
  * binds their identity to this session's connection. So the only
  * delivery capabilities here are private ones, an ephemeral reply in the
@@ -81,18 +78,11 @@ export interface SlackAuthorizationEventContext {
      */
     readonly postDirectMessage: SlackThread["postDirectMessage"];
     /**
-     * Hydrated per-session channel state — read `triggeringUserId` to
-     * target the delivery.
+     * Hydrated per-session channel state. Resolve the recipient with
+     * `slackUsersByPrincipal[eventData.principalId]`.
      */
     readonly state: SlackChannelState;
 }
-/**
- * Signature of an `authorization.required` override. Unlike every other
- * event handler, it receives {@link SlackAuthorizationEventContext}
- * instead of the full {@link SlackEventContext} — see the context type
- * for why.
- */
-export type SlackAuthorizationRequiredHandler = (data: EventData<"authorization.required">, channel: SlackAuthorizationEventContext, ctx: SessionContext) => void | Promise<void>;
 type SlackSessionFailedHandler = (data: EventData<"session.failed">, channel: SlackEventContext) => void | Promise<void>;
 /**
  * JSON-serializable per-session state, stored verbatim across workflow
@@ -100,6 +90,10 @@ type SlackSessionFailedHandler = (data: EventData<"session.failed">, channel: Sl
  * `JSON.stringify` / `JSON.parse`.
  */
 export interface SlackPendingApprovalCard {
+    /** Thread post announcing a direct-message approval; updated with the outcome. */
+    readonly announcementTs?: string;
+    /** Separate tool-input details post; deleted once none of its approvals are pending. */
+    readonly detailsMessageTs?: string;
     /** Channel containing the approval card; differs from the session channel for DM delivery. */
     readonly messageChannelId?: string;
     readonly messageBlocks: readonly unknown[];
@@ -120,9 +114,8 @@ export interface SlackChannelState {
     installationTeamId?: string | null;
     /**
      * Slack user id of the actor that triggered the current session/turn.
-     * Captured on every inbound mention so default handlers (e.g.
-     * `authorization.required`) can target ephemeral feedback at the right
-     * user without re-parsing the mention payload.
+     * A later message can change it, so sign-in and approval handlers address
+     * recipients through `slackUsersByPrincipal` instead.
      */
     triggeringUserId?: string | null;
     /**
@@ -149,8 +142,28 @@ export interface SlackChannelState {
      */
     pendingAuthMessageTs?: Record<string, string>;
     pendingApprovalCards?: Record<string, SlackPendingApprovalCard>;
-    pendingApprovalCandidateUsers?: Record<string, string>;
-    approvalResponderUsers?: Record<string, string>;
+    /**
+     * Each recent turn's tool calls and the task card eve last wrote for it, by
+     * turn id. The default `turn.waiting` handler names the working tasks.
+     */
+    taskCards?: Record<string, SlackTaskCardState> | null;
+    /**
+     * The turn with a task that settled since its last model step. The default
+     * `step.started` handler shows `Reviewing results...` for the step that reads
+     * the results.
+     */
+    pendingTaskResultsTurnId?: string | null;
+    /**
+     * Principal id to Slack user id, recorded as each message or input response
+     * is delivered. Default handlers use it to address the principal named on
+     * `authorization.required` and approval events.
+     */
+    slackUsersByPrincipal?: Record<string, string>;
+    /**
+     * Error id of a final reply that never reached Slack. The next delivered
+     * message tells the model the reply was not seen, then clears it.
+     */
+    undeliveredReplyErrorId?: string | null;
 }
 /**
  * Per-session metadata attached to tracing spans, projected by the
@@ -225,8 +238,6 @@ export interface SlackInitialMessage {
  * Options for one turn requested by a generic Slack event handler.
  */
 export interface SlackEventSendOptions {
-    /** Updates the session policy; omission preserves it. */
-    readonly taskDeliveryPolicy?: TaskDeliveryPolicy;
     readonly auth: SessionAuthContext | null;
     readonly target: SlackReceiveTarget;
     /** Overrides the workflow run title without changing the message sent to the model. */
@@ -438,56 +449,16 @@ export type SlackInboundResult = SlackMentionResult;
 /** {@link SlackInboundResult}, or a promise resolving to one. */
 export type SlackInboundResultOrPromise = SlackMentionResultOrPromise;
 /**
- * Per-event Slack handlers keyed by harness stream-event type, passed to
- * `slackChannel({ events })`. Each key is optional; supplying one replaces
- * only that event's built-in default (see {@link defaultEvents}). Handlers
- * receive the event data, the {@link SlackEventContext}, and the session
- * {@link SessionContext}; `session.failed` receives only data and channel
- * context and exposes the ID as `data.sessionId`.
+ * eve's full-context Slack event handlers: the innermost link of every
+ * channel's renderer chain. The default `authorization.required` handler keeps
+ * the full {@link SlackEventContext} because it owns the public link-free
+ * status, which authored renderers, limited to private delivery, can't post.
  */
-export interface SlackChannelEvents {
-    readonly "approval.candidate"?: SlackEventHandler<"approval.candidate">;
-    readonly "approval.settled"?: SlackEventHandler<"approval.settled">;
-    readonly "turn.started"?: SlackEventHandler<"turn.started">;
-    readonly "actions.requested"?: SlackEventHandler<"actions.requested">;
-    readonly "action.partial"?: SlackEventHandler<"action.partial">;
-    readonly "action.result"?: SlackEventHandler<"action.result">;
-    readonly "message.completed"?: SlackEventHandler<"message.completed">;
-    readonly "message.appended"?: SlackEventHandler<"message.appended">;
-    readonly "reasoning.appended"?: SlackEventHandler<"reasoning.appended">;
-    readonly "reasoning.completed"?: SlackEventHandler<"reasoning.completed">;
-    /**
-     * An override may pass selected requests to `defaultDeliver()` while
-     * rendering the rest itself. The default delivery honors `approvalChannel`.
-     */
-    readonly "input.requested"?: SlackInputRequestedHandler;
-    readonly "turn.failed"?: SlackEventHandler<"turn.failed">;
-    readonly "turn.completed"?: SlackEventHandler<"turn.completed">;
-    readonly "turn.cancelled"?: SlackEventHandler<"turn.cancelled">;
+export type SlackChannelInternalEvents = {
+    readonly [T in Exclude<SlackRenderedEvent, "session.failed">]?: SlackEventHandler<T>;
+} & {
     readonly "session.failed"?: SlackSessionFailedHandler;
-    readonly "session.completed"?: SlackEventHandler<"session.completed">;
-    readonly "session.waiting"?: SlackEventHandler<"session.waiting">;
-    /**
-     * Override receives {@link SlackAuthorizationEventContext}, a
-     * private-delivery context (ephemeral or DM), not the full
-     * {@link SlackEventContext}. The challenge is a credential, so a
-     * public post is not expressible here.
-     */
-    readonly "authorization.required"?: SlackAuthorizationRequiredHandler;
-    readonly "authorization.completed"?: SlackEventHandler<"authorization.completed">;
-}
-/**
- * Full-context variant of {@link SlackChannelEvents} consumed by the
- * channel internals. The framework's default `authorization.required`
- * handler keeps the full {@link SlackEventContext} because it owns the
- * public link-free status while user overrides remain private-only. The
- * factory adapts user overrides into this shape with
- * {@link constrainAuthorizationRequired}.
- */
-export interface SlackChannelInternalEvents extends Omit<SlackChannelEvents, "authorization.required" | "input.requested"> {
-    readonly "authorization.required"?: SlackEventHandler<"authorization.required">;
-    readonly "input.requested"?: SlackEventHandler<"input.requested">;
-}
+};
 export type SlackApprovalChannel = "direct-message" | "thread";
 /** Input request passed to a {@link SlackApprovalChannelResolver}. */
 export type SlackApprovalRequest = InputRequest;
@@ -504,10 +475,6 @@ export interface SlackChannelConfig {
      * without exposing the request. Defaults to `"thread"` when omitted.
      */
     readonly approvalChannel?: SlackApprovalChannelResolver;
-    /** Optional presentation-only activity rendered without starting parent turns. */
-    readonly activity?: {
-        readonly renderers: readonly SlackActivityRenderer[];
-    };
     /** Override the default webhook route path (`/eve/v1/slack`). */
     readonly route?: string;
     /** Policy for accepted messages that arrive while a turn is active. */
@@ -536,16 +503,13 @@ export interface SlackChannelConfig {
     /**
      * Invoked when a Slack `app_mention` event arrives (only `app_mention`;
      * other event types are ignored). Decides whether to dispatch and with
-     * what auth, and may run pre-dispatch side effects (e.g.
-     * `ctx.thread.startTyping("Thinking...")`) on the inbound webhook side
-     * before the runtime cold-starts.
+     * what auth. It renders nothing: the renderer chain's `received`
+     * acknowledges the mention while this hook runs.
      *
      * Return `{ auth }` to dispatch with that session auth context, or `null`
      * to drop the mention. May be sync or async; the result is awaited before
      * dispatching. Thrown errors are caught and logged and the mention is
-     * dropped; wrap best-effort side effects in `try/catch` to keep them
-     * non-fatal. Defaults to a workspace-scoped auth derivation that posts a
-     * `"Thinking..."` typing indicator; replacing this replaces both.
+     * dropped. Defaults to a workspace-scoped auth derivation.
      */
     onAppMention?(ctx: SlackInboundMessageContext, message: SlackMessage): SlackMentionResultOrPromise;
     /**
@@ -553,15 +517,13 @@ export interface SlackChannelConfig {
      * `channel_type: "im"`. Subtype messages (edits, deletes, joins, etc.)
      * and bot messages (`bot_id` set, including the bot's own replies) are
      * filtered out first, so handlers only see plain user-authored DMs.
-     * Decides whether to dispatch and with what auth, and may run
-     * pre-dispatch side effects on the inbound webhook side before cold-start.
+     * Decides whether to dispatch and with what auth. It renders nothing: the
+     * renderer chain's `received` acknowledges the message while this hook runs.
      *
      * Return `{ auth }` to dispatch with that session auth context, or `null`
      * to drop the message. May be sync or async; the result is awaited before
      * dispatching. Thrown errors are caught and logged and the message is
-     * dropped; wrap best-effort side effects in `try/catch` to keep them
-     * non-fatal. Defaults to a workspace-scoped auth derivation that posts a
-     * `"Thinking..."` typing indicator; replacing this replaces both.
+     * dropped. Defaults to a workspace-scoped auth derivation.
      * Requires the bot's Slack app to subscribe to `message.im` with the
      * `im:history` scope.
      */
@@ -629,7 +591,14 @@ export interface SlackChannelConfig {
      * authored handlers.
      */
     onInputResponse?(ctx: SlackInputResponseContext, submission: SlackInputResponseSubmission): SlackInputResponseResult | Promise<SlackInputResponseResult>;
-    readonly events?: SlackChannelEvents;
+    /**
+     * Renderers that wrap eve's default Slack rendering, outermost first. Omit
+     * it and eve renders with its default alone. Each renderer can acknowledge
+     * messages (`received`), render session events (`events`), and shape the
+     * task card (`taskCard`). A handler runs the rest of the chain, ending with
+     * eve's default, by calling `next`, and skips it by not calling it.
+     */
+    readonly renderers?: readonly SlackRenderer[];
 }
 /**
  * Concrete return type of {@link slackChannel}. Named so consumers can
@@ -639,21 +608,11 @@ export interface SlackChannelConfig {
 export interface SlackChannel extends Channel<SlackChannelState, SlackReceiveTarget, SlackInstrumentationMetadata> {
 }
 /**
- * Slack channel factory. Wires up the webhook route, mention dispatch,
- * interaction handling, and a baseline set of typing / error /
- * connection-auth event handlers. Defaults apply per field: pass
- * `onAppMention` to fully replace the default mention pipeline (auth
- * derivation plus `"Thinking..."` typing), or an `events[type]` handler to
- * replace only that one event. When `onEvent` is authored it becomes the
- * fallback ahead of unsupplied mention and DM defaults; otherwise unsupplied
- * fields keep their defaults.
+ * Slack channel factory. Wires up the webhook route, message dispatch,
+ * interaction handling, and eve's default rendering: the `Thinking...`
+ * acknowledgement, status lines, replies, questions, sign-ins, errors, and a
+ * live task card for each turn that starts tasks. Message hooks decide whether
+ * and how to dispatch; `renderers` wrap the default rendering without
+ * replacing it.
  */
 export declare function slackChannel(config?: SlackChannelConfig): SlackChannel;
-/**
- * Adapts a user-supplied `authorization.required` override to the full
- * internal event signature while handing it only the private-delivery
- * surface ({@link SlackAuthorizationEventContext}). Override code never
- * receives `thread.post` or the raw `slack.request` escape hatch, so the
- * challenge it renders cannot be addressed to the shared thread.
- */
-export declare function constrainAuthorizationRequired(handler: SlackAuthorizationRequiredHandler): NonNullable<SlackChannelInternalEvents["authorization.required"]>;

package/dist/src/public/channels/slack/slackChannel.js

@@ -1 +1 @@
-import{markEventHandled}from"./utils.js";import{createLogger,logError}from"#internal/logging.js";import{normalizeChannelAudience}from"#shared/channel-audience.js";import{setChannelActivityRenderers,setChannelBuildMetadata}from"#channel/compiled-channel.js";import{defaultDeliverResult}from"#channel/adapter.js";import{POST,defineChannel}from"#public/definitions/channel.js";import{mergeUploadPolicy}from"#public/channels/upload-policy.js";import{buildSlackBinding,buildSlackWorkspaceHandle,slackContinuationToken}from"#public/channels/slack/api.js";import{resolveSlackTransportOptions}from"#public/channels/slack/transport.js";import{buildSlackAuthContext,slackUserIdFromAuthContext}from"#public/channels/slack/auth.js";import{defaultEvents,defaultInputRequestedHandler,defaultOnAppMention,defaultOnDirectMessage,postCompletedSlackReply}from"#public/channels/slack/defaults.js";import{buildSlackActivityRenderers,hasSlackActivityStatus}from"#public/channels/slack/activity.js";import{loadThreadContextMessages}from"#public/channels/slack/thread.js";import{parseSlackWebhookBody}from"#compiled/@chat-adapter/slack/webhook.js";import{bindSlackSessionOperations}from"#public/channels/slack/session-operations.js";import{buildSlackTurnMessage,collectInboundFileParts,createSlackFetchFile}from"#public/channels/slack/attachments.js";import{parseMessageEvent,parseSlackEventEnvelope,slackEventBotUserId,slackEventInstallationTeamId,slackEventReceivingBotUserId,slackMessageFromWebhookPayload}from"#public/channels/slack/inbound.js";import{formatSlackInboundMessage,formatSlackThreadContext}from"#public/channels/slack/model-context.js";import{isPrivateSlackConversation}from"#public/channels/slack/privacy.js";import{SLACK_CHANNEL_DEFAULT_ROUTE}from"#public/channels/slack/constants.js";import{defineSlackAppManifest}from"#public/channels/slack/app-manifest.js";import{handleInteractionPost}from"#public/channels/slack/interactions.js";import{verifySlackRequest as verifySlackRequest$1}from"#public/channels/slack/verify.js";const log=createLogger(`slack.channel`),ignoreSlackActivityEvent=async()=>void 0,activityOwnedMessageCompleted=async(e,t)=>{t.state.pendingToolCallMessage=null,e.finishReason!==`tool-calls`&&e.message&&await postCompletedSlackReply(t,e.message)},clearSlackTurnState=async(e,t)=>{t.state.pendingToolCallMessage=null,t.state.lastReasoningTypingAtMs=null,t.state.lastReasoningTypingStatus=null};function rebuildSlackContext(e,t,n,r){let{thread:i,slack:a}=buildSlackBinding({api:n,botToken:r?.botToken,channelId:e.channelId??``,threadTs:e.threadTs??``,installationTeamId:e.installationTeamId??void 0,teamId:e.teamId??void 0,onThreadTsChanged(n){e.threadTs=n,e.channelId&&t.continuation?.alias(slackContinuationToken(e.channelId,n))}});return{thread:i,slack:a,state:e}}function slackChannel(e={}){let t=resolveSlackTransportOptions(e.api),n=mergeUploadPolicy(e.uploadPolicy),r=createSlackFetchFile({api:t,botToken:e.credentials?.botToken}),i=buildSlackActivityRenderers({api:t,botToken:e.credentials?.botToken,renderers:e.activity?.renderers??[]}),a=e.onInputResponse??defaultOnInputResponse,o=e.events?.[`authorization.required`],s=e.events?.[`approval.candidate`]??defaultEvents[`approval.candidate`],c=hasSlackActivityStatus(e.activity?.renderers),l=e.events?.[`turn.started`]??(c?clearSlackTurnState:defaultEvents[`turn.started`]),u=e.events?.[`reasoning.appended`]??(c?ignoreSlackActivityEvent:defaultEvents[`reasoning.appended`]),d=e.events?.[`actions.requested`]??(c?ignoreSlackActivityEvent:defaultEvents[`actions.requested`]),f=e.events?.[`message.completed`]??(c?activityOwnedMessageCompleted:defaultEvents[`message.completed`]),p=defaultInputRequestedHandler(e.approvalChannel),m=e.events?.[`input.requested`],h=m===void 0?p:async(e,t,n)=>m(e,t,n,async e=>{await p(e,t,n)}),g={...defaultEvents,...e.events,async"approval.candidate"(e,t,n){let r=t.state.approvalResponderUsers?.[e.responderPrincipalId];if(e.outcome===`pending`&&r!==void 0&&(t.state.pendingApprovalCandidateUsers={...t.state.pendingApprovalCandidateUsers,[e.candidateId]:r}),await s(e,t,n),e.outcome!==`pending`){let n={...t.state.pendingApprovalCandidateUsers};delete n[e.candidateId],t.state.pendingApprovalCandidateUsers=n}},async"turn.started"(e,t,n){let r=slackUserIdFromAuthContext(n.session.auth.current);r!==void 0&&(t.state.triggeringUserId=r),await l(e,t,n)},"reasoning.appended":u,"actions.requested":d,"message.completed":f,"input.requested":h,"authorization.required":o===void 0?defaultEvents[`authorization.required`]:constrainAuthorizationRequired(o)},_=new Set,v=defineChannel({kindHint:`slack`,turnPolicy:e.turnPolicy,state:{channelId:null,threadTs:null,teamId:null,installationTeamId:null,triggeringUserId:null,triggeringMessageTs:null,pendingToolCallMessage:null,lastReasoningTypingAtMs:null,lastReasoningTypingStatus:null,pendingAuthMessageTs:{},pendingApprovalCards:{},pendingApprovalCandidateUsers:{},approvalResponderUsers:{}},fetchFile:r,metadata(e){return{channelId:e.channelId,teamId:e.teamId,threadTs:e.threadTs,triggeringUserId:e.triggeringUserId??null}},audience:({state:e})=>e.audience??`unknown`,context(n,r){return rebuildSlackContext(n,r,t,e.credentials)},deliver(e,t){let n=e.pendingApprovalCards;typeof n==`object`&&n&&(t.state.pendingApprovalCards={...t.state.pendingApprovalCards,...n});let r=e.state?.approvalResponderUsers;return typeof r==`object`&&r&&(t.state.approvalResponderUsers={...t.state.approvalResponderUsers,...r}),defaultDeliverResult(e)},routes:[POST(e.route??SLACK_CHANNEL_DEFAULT_ROUTE,async(r,i)=>{let{waitUntil:o}=i,{from:s,resolveSession:c}=i,l=await verifyInbound(r,e.credentials);return l===null?new Response(`unauthorized`,{status:401}):shouldDropSlackHttpTimeoutRetry(r.headers)?new Response(`ok`):(r.headers.get(`content-type`)??``).includes(`application/x-www-form-urlencoded`)?handleInteractionPost(l,{from:s,resolveSession:c,waitUntil:o},{api:t,config:e,onInputResponse:a}):handleEventPost({api:t,body:l,from:s,resolveSession:c,waitUntil:o,config:e,uploadPolicy:n,handledEvents:_,headers:r.headers})})],receive(n,{from:r}){return receiveOnSlack(n,{from:r,api:t,credentials:e.credentials})},events:g});setChannelActivityRenderers(v,{destination(e){let t=e;return{channelId:t?.channelId??null,installationTeamId:t?.installationTeamId??null,teamId:t?.teamId??null,threadTs:t?.threadTs??null,triggeringUserId:t?.triggeringUserId??null}},renderers:i});let y=e.credentials,b=defineSlackAppManifest({botName:e.botName});return setChannelBuildMetadata(v,e=>({externalCredentials:y?.vercelConnect,manifest:b.build(e)})),v}function defaultOnInputResponse(e){return{auth:e.defaultAuth}}async function receiveOnSlack(e,t){let n=e.target,r=n.channelId;if(!r||typeof r!=`string`)throw Error(`slackChannel().receive requires target.channelId.`);let i=typeof n.threadTs==`string`?n.threadTs:``,a=typeof n.installationTeamId==`string`?n.installationTeamId:t.installationTeamId,o=n.initialMessage;if(o&&i.length>0)throw Error("slackChannel().receive: `threadTs` and `initialMessage` are mutually exclusive.");let s=i;if(o){let{thread:e}=buildSlackBinding({api:t.api,botToken:t.credentials?.botToken,channelId:r,threadTs:``,installationTeamId:a,teamId:t.teamId}),n={card:o.card};o.fallbackText!==void 0&&(n.fallbackText=o.fallbackText),s=(await e.post(n)).id}let c=s||crypto.randomUUID(),l=n.audience===void 0?void 0:normalizeChannelAudience(n.audience),u={channelId:r,installationTeamId:a??null,threadTs:s||null,teamId:t.teamId??null,triggeringUserId:t.triggeringUserId??null};return l!==void 0&&(u.audience=l),t.from(slackContinuationToken(r,c)).send(e.message,{auth:e.auth,state:u,title:e.title,taskDeliveryPolicy:e.taskDeliveryPolicy})}function constrainAuthorizationRequired(e){return(t,n,r)=>e(t,{postEphemeral:(e,t)=>n.thread.postEphemeral(e,t),postDirectMessage:(e,t)=>n.thread.postDirectMessage(e,t),state:n.state},r)}function shouldDropSlackHttpTimeoutRetry(e){return Number(e.get(`x-slack-retry-num`)??`0`)>=1&&e.get(`x-slack-retry-reason`)===`http_timeout`}async function handleEventPost(e){let{config:t}=e,n,r;try{n=parseSlackWebhookBody(e.body,{headers:e.headers}),r=parseSlackEventEnvelope(e.body)}catch(e){return log.warn(`inbound webhook body is not valid JSON`,{error:e}),new Response(`ok`)}if(n.kind===`url_verification`)return new Response(n.challenge,{status:200,headers:{"content-type":`text/plain`}});if(r===null)return new Response(`ok`);let i=typeof r.api_app_id==`string`?r.api_app_id:void 0,a=slackEventBotUserId(r),o=slackEventReceivingBotUserId(r),s=slackEventInstallationTeamId(r),dispatch=null,c=null;if(n.kind===`app_mention`||n.kind===`direct_message`){let r=n.kind,l=slackMessageFromWebhookPayload(n);if(l!==null&&!isSelfAuthoredSlackMessage({appId:i,botUserId:a},l)){let dispatchMessageWith=n=>()=>dispatchSlackMessage({api:e.api,appId:i,botUserId:a,receivingBotUserId:o,from:e.from,resolveSession:e.resolveSession,credentials:t.credentials,handler:n,installationTeamId:s,kind:r,message:l,threadContext:t.threadContext,uploadPolicy:e.uploadPolicy}),n=(r===`app_mention`?t.onAppMention:t.onDirectMessage)??t.onMessage;n===void 0?c=dispatchMessageWith(r===`app_mention`?defaultOnAppMention:defaultOnDirectMessage):dispatch=()=>dispatchSlackMessage({api:e.api,appId:i,botUserId:a,receivingBotUserId:o,from:e.from,resolveSession:e.resolveSession,credentials:t.credentials,handler:n,installationTeamId:s,kind:r,message:l,threadContext:t.threadContext,uploadPolicy:e.uploadPolicy})}}if(dispatch===null&&t.onMessage!==void 0){let n=parseMessageEvent(r);n!==null&&!isSelfAuthoredSlackMessage({appId:i,botUserId:a},n)&&(a===void 0||!n.text.includes(`<@${a}`))&&(dispatch=()=>dispatchSlackMessage({api:e.api,appId:i,botUserId:a,receivingBotUserId:o,from:e.from,resolveSession:e.resolveSession,credentials:t.credentials,handler:t.onMessage,installationTeamId:s,kind:`channel_message`,message:n,threadContext:t.threadContext,uploadPolicy:e.uploadPolicy}))}let l=t.onEvent;if(dispatch===null&&l!==void 0&&(dispatch=()=>dispatchSlackEvent({api:e.api,from:e.from,resolveSession:e.resolveSession,credentials:t.credentials,envelope:r,handler:l,installationTeamId:s})),dispatch??=c,dispatch===null)return new Response(`ok`);let u=r.event_id;if(u){if(e.handledEvents.has(u))return log.warn(`received a duplicate event`,{event_id:u,event_time:r.event_time,retry_num:n.retry?.num??`(null)`,retry_reason:n.retry?.reason??`(null)`}),new Response(`ok`);markEventHandled(u,e.handledEvents)}return e.waitUntil(dispatch()),new Response(`ok`)}function isSelfAuthoredSlackMessage(e,t){return e.botUserId!==void 0&&t.author?.userId===e.botUserId||e.appId!==void 0&&t.raw.app_id===e.appId}async function dispatchSlackMessage(e){let t=slackContinuationToken(e.message.channelId,e.message.threadTs),{thread:n,slack:r}=buildSlackBinding({api:e.api,appId:e.appId,botToken:e.credentials?.botToken,botUserId:e.botUserId,channelId:e.message.channelId,threadTs:e.message.threadTs,installationTeamId:e.installationTeamId,teamId:e.message.teamId}),i=e.message.author,a={channelId:e.message.channelId,installationTeamId:e.installationTeamId??null,teamId:e.message.teamId??null,threadTs:e.message.threadTs,triggeringMessageTs:e.message.ts,triggeringUserId:i?.userId??null},o=bindSlackSessionOperations({address:t,defaultAuth:i===void 0?null:buildSlackAuthContext({channelId:e.message.channelId,fullName:i.fullName,isBot:i.isBot,teamId:e.message.teamId,threadTs:e.message.threadTs,userId:i.userId,userName:i.userName}),from:e.from,resolveSession:e.resolveSession,state:a}),s,isDMOrPrivateChannel=()=>s??=isPrivateSlackConversation({channelId:e.message.channelId,raw:e.message.raw,request:r.request}),c=e.kind===`app_mention`||e.botUserId!==void 0&&e.message.text.includes(`<@${e.botUserId}`),l={...o,isBotMentioned:()=>c,isDMOrPrivateChannel,isSubscribed:async()=>await o.resolveSession()!==void 0,slack:r,thread:n},u;try{u=await e.handler(l,e.message)}catch(t){logError(log,`${e.kind} handler failed`,t,{channelId:e.message.channelId});return}if(u==null)return;let d=await isDMOrPrivateChannel();a.audience=e.kind===`direct_message`||d?`private`:`public`,await deliverSlackMessage({botUserId:e.receivingBotUserId,credentials:e.credentials,kind:e.kind,isPrivateConversation:d,isMentioned:c,message:e.message,result:u,sessionOperations:o,thread:n,threadContext:e.threadContext,uploadPolicy:e.uploadPolicy})}async function dispatchSlackEvent(e){let t=e.envelope.event.team_id,n=typeof t==`string`?t:typeof e.envelope.team_id==`string`?e.envelope.team_id:void 0,r=[],sourceFor=t=>e.from(slackContinuationToken(t.channelId,t.threadTs)),i={cancel:({target:e,turnId:t})=>sourceFor(e).cancel({turnId:t}),clear:({target:e})=>sourceFor(e).clear(),compact:({target:e})=>sourceFor(e).compact(),envelope:e.envelope,reset:({reason:e,target:t})=>sourceFor(t).reset({reason:e}),resolveSession:({target:t})=>e.resolveSession(slackContinuationToken(t.channelId,t.threadTs)),respond:(e,{auth:t,target:n})=>sourceFor(n).respond(e,{auth:t}),send:(t,{auth:r,target:i,title:a,taskDeliveryPolicy:o})=>receiveOnSlack({auth:r,message:t,target:i,title:a,taskDeliveryPolicy:o},{from:e.from,api:e.api,credentials:e.credentials,installationTeamId:e.installationTeamId,teamId:n,...typeof e.envelope.event.user==`string`?{triggeringUserId:e.envelope.event.user}:{}}),slack:buildSlackWorkspaceHandle({api:e.api,botToken:e.credentials?.botToken,installationTeamId:e.installationTeamId,teamId:n}),waitUntil(e){r.push(e)}};try{await e.handler(i,e.envelope.event)}catch(t){logError(log,`event handler failed`,t,{eventId:e.envelope.event_id,eventType:e.envelope.event.type})}await Promise.allSettled(r)}async function verifyInbound(e,t){try{return await verifySlackRequest$1(e,{signingSecret:t?.signingSecret??(t?.webhookVerifier?void 0:process.env.SLACK_SIGNING_SECRET),webhookVerifier:t?.webhookVerifier})}catch(e){return log.warn(`slack inbound verification failed`,{error:e}),null}}async function deliverSlackMessage(e){let{message:t,thread:n}=e;try{let r=e.threadContext===void 0?[]:await loadThreadContextMessages(n,t,e.threadContext),i=formatSlackThreadContext(r),a=await collectInboundFileParts({mention:t,thread:n,policy:e.uploadPolicy}),o={botUserId:e.botUserId,channelId:t.channelId,fullName:t.author?.fullName,isMentioned:e.isMentioned,teamId:t.teamId,threadTs:t.threadTs,userId:t.author?.userId??``,userName:t.author?.userName},s=formatSlackInboundMessage(o,t),c=buildSlackTurnMessage(i===void 0?s:`${i}\n\n${s}`,a),l=e.result.context??[],u=e.isPrivateConversation?`Private message`:e.result.title??t.markdown,d=l.length===0?{auth:e.result.auth,title:u}:{auth:e.result.auth,context:l,title:u};await e.sessionOperations.send(c,d)}catch(n){logError(log,`${e.kind} delivery failed`,n,{channelId:t.channelId})}}export{constrainAuthorizationRequired,slackChannel};
+import{markEventHandled}from"./utils.js";import{createLogger,logError}from"#internal/logging.js";import{normalizeChannelAudience}from"#shared/channel-audience.js";import{setChannelBuildMetadata}from"#channel/compiled-channel.js";import{defaultDeliverResult}from"#channel/adapter.js";import{POST,defineChannel}from"#public/definitions/channel.js";import{mergeUploadPolicy}from"#public/channels/upload-policy.js";import{resolveSlackTransportOptions}from"#public/channels/slack/transport.js";import{buildSlackAuthContext,slackUserIdFromAuthContext}from"#public/channels/slack/auth.js";import{buildSlackBinding,buildSlackWorkspaceHandle,slackContinuationToken}from"#public/channels/slack/api.js";import{defaultInputRequestedHandler}from"#public/channels/slack/approval-cards.js";import{withFinalReplyDelivery,withUndeliveredReplyNote}from"#public/channels/slack/reply-delivery.js";import{defaultEvents,defaultOnMessage,defaultReceived}from"#public/channels/slack/defaults.js";import{composeSlackRenderers}from"#public/channels/slack/renderers.js";import{loadThreadContextMessages}from"#public/channels/slack/thread.js";import{parseSlackWebhookBody}from"#compiled/@chat-adapter/slack/webhook.js";import{bindSlackSessionOperations,withSlackResponder}from"#public/channels/slack/session-operations.js";import{buildSlackTurnMessage,collectInboundFileParts,createSlackFetchFile}from"#public/channels/slack/attachments.js";import{renderDefaultSlackTaskCard,withTaskCards}from"#public/channels/slack/task-card.js";import{parseMessageEvent,parseSlackEventEnvelope,slackEventBotUserId,slackEventInstallationTeamId,slackEventReceivingBotUserId,slackMessageFromWebhookPayload}from"#public/channels/slack/inbound.js";import{formatSlackInboundMessage,formatSlackThreadContext}from"#public/channels/slack/model-context.js";import{isPrivateSlackConversation}from"#public/channels/slack/privacy.js";import{SLACK_CHANNEL_DEFAULT_ROUTE}from"#public/channels/slack/constants.js";import{defineSlackAppManifest}from"#public/channels/slack/app-manifest.js";import{handleInteractionPost}from"#public/channels/slack/interactions.js";import{verifySlackRequest as verifySlackRequest$1}from"#public/channels/slack/verify.js";const log=createLogger(`slack.channel`);function rebuildSlackContext(e,t,n,r){let{thread:i,slack:a}=buildSlackBinding({api:n,botToken:r?.botToken,channelId:e.channelId??``,threadTs:e.threadTs??``,installationTeamId:e.installationTeamId??void 0,teamId:e.teamId??void 0,onThreadTsChanged(n){e.threadTs=n,e.channelId&&t.continuation?.alias(slackContinuationToken(e.channelId,n))}});return{thread:i,slack:a,state:e}}function slackChannel(e={}){let t=resolveSlackTransportOptions(e.api),n=mergeUploadPolicy(e.uploadPolicy),r=createSlackFetchFile({api:t,botToken:e.credentials?.botToken}),i=e.onInputResponse??defaultOnInputResponse,a=composeSlackRenderers(e.renderers??[],{events:{...defaultEvents,"input.requested":defaultInputRequestedHandler(e.approvalChannel)},received:defaultReceived,taskCard:renderDefaultSlackTaskCard}),o=a.events[`turn.started`],s=withTaskCards({...a.events,"message.completed":withFinalReplyDelivery(a.events[`message.completed`]),async"turn.started"(e,t,n){let r=slackUserIdFromAuthContext(n.session.auth.current);r!==void 0&&(t.state.triggeringUserId=r),await o?.(e,t,n)}},a.taskCard),c=new Set,l=defineChannel({kindHint:`slack`,turnPolicy:e.turnPolicy,state:{channelId:null,threadTs:null,teamId:null,installationTeamId:null,triggeringUserId:null,triggeringMessageTs:null,pendingToolCallMessage:null,lastReasoningTypingAtMs:null,lastReasoningTypingStatus:null,pendingAuthMessageTs:{},pendingApprovalCards:{},slackUsersByPrincipal:{}},fetchFile:r,metadata(e){return{channelId:e.channelId,teamId:e.teamId,threadTs:e.threadTs,triggeringUserId:e.triggeringUserId??null}},audience:({state:e})=>e.audience??`unknown`,context(n,r){return rebuildSlackContext(n,r,t,e.credentials)},deliver(e,t){return recordSlackPrincipal(t.state,t.session.auth.current,e),defaultDeliverResult(withUndeliveredReplyNote(t.state,e))},routes:[POST(e.route??SLACK_CHANNEL_DEFAULT_ROUTE,async(r,o)=>{let{waitUntil:s}=o,{from:l,resolveSession:u}=o,d=await verifyInbound(r,e.credentials);return d===null?new Response(`unauthorized`,{status:401}):shouldDropSlackHttpTimeoutRetry(r.headers)?new Response(`ok`):(r.headers.get(`content-type`)??``).includes(`application/x-www-form-urlencoded`)?handleInteractionPost(d,{from:l,resolveSession:u,waitUntil:s},{api:t,config:e,onInputResponse:i}):handleEventPost({api:t,body:d,from:l,resolveSession:u,waitUntil:s,config:e,received:a.received,uploadPolicy:n,handledEvents:c,headers:r.headers})})],receive(n,{from:r}){return receiveOnSlack(n,{from:r,api:t,credentials:e.credentials})},events:s}),u=e.credentials,d=defineSlackAppManifest({botName:e.botName});return setChannelBuildMetadata(l,e=>({externalCredentials:u?.vercelConnect,manifest:d.build(e)})),l}function defaultOnInputResponse(e){return{auth:e.defaultAuth}}async function receiveOnSlack(e,t){let n=e.target,r=n.channelId;if(!r||typeof r!=`string`)throw Error(`slackChannel().receive requires target.channelId.`);let i=typeof n.threadTs==`string`?n.threadTs:``,a=typeof n.installationTeamId==`string`?n.installationTeamId:t.installationTeamId,o=n.initialMessage;if(o&&i.length>0)throw Error("slackChannel().receive: `threadTs` and `initialMessage` are mutually exclusive.");let s=i;if(o){let{thread:e}=buildSlackBinding({api:t.api,botToken:t.credentials?.botToken,channelId:r,threadTs:``,installationTeamId:a,teamId:t.teamId}),n={card:o.card};o.fallbackText!==void 0&&(n.fallbackText=o.fallbackText),s=(await e.post(n)).id}let c=s||crypto.randomUUID(),l=n.audience===void 0?void 0:normalizeChannelAudience(n.audience),u={channelId:r,installationTeamId:a??null,threadTs:s||null,teamId:t.teamId??null,triggeringUserId:t.triggeringUserId??null};return l!==void 0&&(u.audience=l),t.from(slackContinuationToken(r,c)).send(e.message,{auth:e.auth,state:u,title:e.title})}function shouldDropSlackHttpTimeoutRetry(e){return Number(e.get(`x-slack-retry-num`)??`0`)>=1&&e.get(`x-slack-retry-reason`)===`http_timeout`}async function handleEventPost(e){let{config:t}=e,n,r;try{n=parseSlackWebhookBody(e.body,{headers:e.headers}),r=parseSlackEventEnvelope(e.body)}catch(e){return log.warn(`inbound webhook body is not valid JSON`,{error:e}),new Response(`ok`)}if(n.kind===`url_verification`)return new Response(n.challenge,{status:200,headers:{"content-type":`text/plain`}});if(r===null)return new Response(`ok`);let i=typeof r.api_app_id==`string`?r.api_app_id:void 0,a=slackEventBotUserId(r),o=slackEventReceivingBotUserId(r),s=slackEventInstallationTeamId(r),dispatch=null,c=null,dispatchMessage=(n,r,c)=>()=>dispatchSlackMessage({api:e.api,appId:i,botUserId:a,receivingBotUserId:o,from:e.from,resolveSession:e.resolveSession,credentials:t.credentials,handler:c,installationTeamId:s,kind:n,message:r,received:e.received,threadContext:t.threadContext,uploadPolicy:e.uploadPolicy});if(n.kind===`app_mention`||n.kind===`direct_message`){let e=n.kind,r=slackMessageFromWebhookPayload(n,s);if(r!==null&&!isSelfAuthoredSlackMessage({appId:i,botUserId:a},r)){let n=(e===`app_mention`?t.onAppMention:t.onDirectMessage)??t.onMessage;n===void 0?c=dispatchMessage(e,r,defaultOnMessage):dispatch=dispatchMessage(e,r,n)}}let l=t.onMessage;if(dispatch===null&&l!==void 0){let e=parseMessageEvent(r);e!==null&&!isSelfAuthoredSlackMessage({appId:i,botUserId:a},e)&&(a===void 0||!e.text.includes(`<@${a}`))&&(dispatch=dispatchMessage(`channel_message`,e,l))}let u=t.onEvent;if(dispatch===null&&u!==void 0&&(dispatch=()=>dispatchSlackEvent({api:e.api,from:e.from,resolveSession:e.resolveSession,credentials:t.credentials,envelope:r,handler:u,installationTeamId:s})),dispatch??=c,dispatch===null)return new Response(`ok`);let d=r.event_id;if(d){if(e.handledEvents.has(d))return log.warn(`received a duplicate event`,{event_id:d,event_time:r.event_time,retry_num:n.retry?.num??`(null)`,retry_reason:n.retry?.reason??`(null)`}),new Response(`ok`);markEventHandled(d,e.handledEvents)}return e.waitUntil(dispatch()),new Response(`ok`)}function isSelfAuthoredSlackMessage(e,t){return e.botUserId!==void 0&&t.author?.userId===e.botUserId||e.appId!==void 0&&t.raw.app_id===e.appId}async function dispatchSlackMessage(e){let t=slackContinuationToken(e.message.channelId,e.message.threadTs),{thread:n,slack:r}=buildSlackBinding({api:e.api,appId:e.appId,botToken:e.credentials?.botToken,botUserId:e.botUserId,channelId:e.message.channelId,threadTs:e.message.threadTs,installationTeamId:e.installationTeamId,teamId:e.message.teamId}),i=e.message.author,a={channelId:e.message.channelId,installationTeamId:e.installationTeamId??null,teamId:e.message.teamId??null,threadTs:e.message.threadTs,triggeringMessageTs:e.message.ts,triggeringUserId:i?.userId??null},o=bindSlackSessionOperations({address:t,defaultAuth:i===void 0?null:buildSlackAuthContext({channelId:e.message.channelId,fullName:i.fullName,installationTeamId:e.installationTeamId,isBot:i.isBot,teamId:e.message.teamId,threadTs:e.message.threadTs,userId:i.userId,userName:i.userName}),from:e.from,resolveSession:e.resolveSession,state:a}),s,isDMOrPrivateChannel=()=>s??=isPrivateSlackConversation({channelId:e.message.channelId,raw:e.message.raw,request:r.request}),c=e.kind===`app_mention`||e.botUserId!==void 0&&e.message.text.includes(`<@${e.botUserId}`),l={...o,isBotMentioned:()=>c,isDMOrPrivateChannel,isSubscribed:async()=>await o.resolveSession()!==void 0,slack:r,thread:n},u=e.kind===`channel_message`?void 0:acknowledgeMessage(e.received,e.message,{slack:r,thread:n}),d;try{d=await e.handler(l,e.message)}catch(t){logError(log,`${e.kind} handler failed`,t,{channelId:e.message.channelId})}if(d==null){u!==void 0&&(await u,await n.startTyping());return}await(u??acknowledgeMessage(e.received,e.message,{slack:r,thread:n}));let f=await isDMOrPrivateChannel();a.audience=e.kind===`direct_message`||f?`private`:`public`,await deliverSlackMessage({botUserId:e.receivingBotUserId,credentials:e.credentials,kind:e.kind,isPrivateConversation:f,isMentioned:c,message:e.message,result:d,sessionOperations:o,thread:n,threadContext:e.threadContext,uploadPolicy:e.uploadPolicy})}async function acknowledgeMessage(e,t,n){try{await e(t,n)}catch(e){logError(log,`received renderer failed`,e,{channelId:t.channelId})}}async function dispatchSlackEvent(e){let t=e.envelope.event.team_id,n=typeof t==`string`?t:typeof e.envelope.team_id==`string`?e.envelope.team_id:void 0,r=[],sourceFor=t=>e.from(slackContinuationToken(t.channelId,t.threadTs)),i={cancel:({target:e,turnId:t})=>sourceFor(e).cancel({turnId:t}),clear:({target:e})=>sourceFor(e).clear(),compact:({target:e})=>sourceFor(e).compact(),envelope:e.envelope,reset:({reason:e,target:t})=>sourceFor(t).reset({reason:e}),resolveSession:({target:t})=>e.resolveSession(slackContinuationToken(t.channelId,t.threadTs)),respond:(t,{auth:n,target:r})=>sourceFor(r).respond(t,{auth:n,state:withSlackResponder(void 0,typeof e.envelope.event.user==`string`?e.envelope.event.user:void 0)}),send:(t,{auth:r,target:i,title:a})=>receiveOnSlack({auth:r,message:t,target:i,title:a},{from:e.from,api:e.api,credentials:e.credentials,installationTeamId:e.installationTeamId,teamId:n,...typeof e.envelope.event.user==`string`?{triggeringUserId:e.envelope.event.user}:{}}),slack:buildSlackWorkspaceHandle({api:e.api,botToken:e.credentials?.botToken,installationTeamId:e.installationTeamId,teamId:n}),waitUntil(e){r.push(e)}};try{await e.handler(i,e.envelope.event)}catch(t){logError(log,`event handler failed`,t,{eventId:e.envelope.event_id,eventType:e.envelope.event.type})}await Promise.allSettled(r)}async function verifyInbound(e,t){try{return await verifySlackRequest$1(e,{signingSecret:t?.signingSecret??(t?.webhookVerifier?void 0:process.env.SLACK_SIGNING_SECRET),webhookVerifier:t?.webhookVerifier})}catch(e){return log.warn(`slack inbound verification failed`,{error:e}),null}}async function deliverSlackMessage(e){let{message:t,thread:n}=e;try{let r=e.threadContext===void 0?[]:await loadThreadContextMessages(n,t,e.threadContext),i=formatSlackThreadContext(r),a=await collectInboundFileParts({mention:t,thread:n,policy:e.uploadPolicy}),o={botUserId:e.botUserId,channelId:t.channelId,fullName:t.author?.fullName,isMentioned:e.isMentioned,teamId:t.teamId,threadTs:t.threadTs,userId:t.author?.userId??``,userName:t.author?.userName},s=formatSlackInboundMessage(o,t),c=buildSlackTurnMessage(i===void 0?s:`${i}\n\n${s}`,a),l=e.result.context??[],u=e.isPrivateConversation?`Private message`:e.result.title??t.markdown,d=l.length===0?{auth:e.result.auth,title:u}:{auth:e.result.auth,context:l,title:u};await e.sessionOperations.send(c,d)}catch(n){logError(log,`${e.kind} delivery failed`,n,{channelId:t.channelId})}}function recordSlackPrincipal(e,t,n){if(t===null)return;let r=n.state?.triggeringUserId,i=slackUserIdFromAuthContext(t)??(typeof r==`string`?r:void 0);i!==void 0&&(e.slackUsersByPrincipal={...e.slackUsersByPrincipal,[t.principalId]:i})}export{slackChannel};

package/dist/src/public/channels/slack/task-card.d.ts

@@ -0,0 +1,24 @@
+import { type TaskCardTurn, type TaskCardView } from "#channel/task-card.js";
+import type { SlackTaskCard } from "#public/channels/slack/renderers.js";
+import type { SlackChannelInternalEvents } from "#public/channels/slack/slackChannel.js";
+/**
+ * eve's default task card: a `task_card` block for one task, or a `plan` block
+ * for several, and no card for a turn that started none. A settled task shows
+ * one line about how it ended and how long it took. A task the model cancelled
+ * with `task_cancel` shows as done, since it no longer needed the work; a
+ * failed task, or one stopped any other way, shows as an error.
+ */
+export declare function renderDefaultSlackTaskCard(view: TaskCardView): SlackTaskCard | null;
+/** A turn's tracked calls, and the card eve last wrote for it. */
+export interface SlackTaskCardState {
+    readonly turn: TaskCardTurn;
+    readonly ts?: string;
+    readonly fingerprint?: string;
+}
+/**
+ * Keeps each turn's task card current from the session's own events. It runs
+ * around the renderer chain, so the card never depends on which handlers a
+ * renderer keeps: eve tracks the turn's calls first, runs the chain's handler,
+ * then writes the card `taskCard` returns if it changed.
+ */
+export declare function withTaskCards(events: SlackChannelInternalEvents, taskCard: (view: TaskCardView) => SlackTaskCard | null): SlackChannelInternalEvents;

package/dist/src/public/channels/slack/task-card.js

@@ -0,0 +1 @@
+import{createHash}from"node:crypto";import{createLogger,logError}from"#internal/logging.js";import{normalizeChannelAudience}from"#shared/channel-audience.js";import{contextStorage}from"#context/container.js";import{ScheduleIdKey}from"#context/keys.js";import{displayName}from"#shared/display-name.js";import{AGENT_TOOL_NAME}from"#tools/framework/agent-contract.js";import{formatDuration}from"#shared/format-duration.js";import{truncateMessageText}from"#public/channels/slack/limits.js";import{closeSettledTasks,taskCardView,trackTaskCardEvent}from"#channel/task-card.js";const log=createLogger(`slack.task-card`);function renderDefaultSlackTaskCard(e){if(e.tasks.length===0)return null;let t=collapseEarlierRows(e.tasks).map(toSlackTask),n=planTitle(e),r=slackBlockId(e.turnId),i=t.length===1?[{block_id:r,type:`task_card`,...t[0]}]:[{block_id:r,type:`plan`,tasks:t,title:n}],a=e.tasks.map(e=>e.title).join(`, `);return{blocks:i,text:truncateMessageText(`${n}: ${a}`)}}function planTitle(e){let{tasks:t}=e;if(e.state===`blocked`){let e=t.find(e=>e.blockedOn!==void 0)?.blockedOn;return waitingText(e?.kind??`input`)}let n=t.length,names=e=>n>1?agentNames(e):void 0;if(e.state===`working`){let e=t.filter(e=>e.status===`working`),r=n-e.length;if(r===0){let e=names(t);return e===void 0?`Working on ${countTasks(n)}`:`Asking ${e}`}let i=`${String(r)} of ${countTasks(n)} done`,a=names(e);return a===void 0?i:`Waiting on ${a} · ${i}`}let r=t.filter(e=>e.status===`failed`).length,i=t.filter(isInterrupted).length,a=[];r>0&&a.push(`${String(r)} failed`),i>0&&a.push(`${String(i)} stopped`);let o=turnDuration(t),s=`Finished ${countTasks(n)}${o===void 0?``:` in ${o}`}`;return a.length===0?s:`${s}: ${a.join(`, `)}`}function agentNames(e){if(e.some(e=>e.kind!==`agent`||e.name===AGENT_TOOL_NAME))return;let t=[...new Set(e.map(e=>displayName(e.name)))];if(!(t.length===0||t.length>3))return t.length<=2?t.join(` and `):`${t.slice(0,-1).join(`, `)}, and ${t.at(-1)}`}function turnDuration(e){let t=e.flatMap(e=>e.settledAt===void 0?[]:[Date.parse(e.settledAt)]);if(t.length===0)return;let n=Math.min(...e.map(e=>Date.parse(e.startedAt)));return shownDuration(Math.max(...t)-n)}function taskDuration(e){if(e.settledAt!==void 0)return shownDuration(Date.parse(e.settledAt)-Date.parse(e.startedAt))}function shownDuration(e){return Number.isFinite(e)&&e>=1e3?formatDuration(e):void 0}function isInterrupted(e){return e.status===`cancelled`&&e.cancelReason!==`task_cancel`}function countTasks(e){return e===1?`1 task`:`${String(e)} tasks`}function collapseEarlierRows(e){if(e.length<=50)return e;let t=e.length-49,n=new Set(e.filter(e=>e.status!==`working`).slice(0,t).map(e=>e.id)),r=e.filter(e=>!n.has(e.id));if(n.size===0)return r.slice(-50);let i=e.some(e=>n.has(e.id)&&(e.status===`failed`||isInterrupted(e)));return[{id:`earlier`,kind:`tool`,name:`earlier`,startedAt:e[0].startedAt,status:i?`failed`:`completed`,taskId:`earlier`,title:`${countTasks(n.size)} finished earlier`},...r].slice(-50)}function toSlackTask(e){let t={status:slackStatus(e),task_id:slackTaskId(e.id),title:truncate(e.title,80)};e.blockedOn!==void 0&&(t.details=richText(blockerLine(e.blockedOn)));let n=outputLine(e);return n!==void 0&&(t.output=richText(n)),t}function slackStatus(e){switch(e.status){case`working`:case`blocked`:return`in_progress`;case`completed`:return`complete`;case`cancelled`:return isInterrupted(e)?`error`:`complete`;case`failed`:return`error`}}function outputLine(e){let t=taskDuration(e);switch(e.status){case`completed`:{if(t===void 0)return e.summary;let n=`Done in ${t}`;return e.summary===void 0?n:`${n}: ${e.summary}`}case`failed`:{let n=t===void 0?`Failed`:`Failed after ${t}`;return e.summary===void 0?n:`${n}: ${e.summary}`}case`cancelled`:return stoppedLine(e.cancelReason);default:return}}function stoppedLine(e){switch(e){case`task_cancel`:return`Stopped early since it was no longer needed`;case`turn_cancelled`:return`Stopped by request`;case`turn_ended`:return`Stopped when the turn ended`;case void 0:return`Stopped`}}function blockerLine(e){let t=waitingText(e.kind);return e.label===void 0?t:`${t}: ${e.label}`}function waitingText(e){switch(e){case`approval`:return`Waiting for approval`;case`authorization`:return`Waiting for sign-in`;case`input`:return`Waiting for a response`}}function richText(e){return{elements:[{elements:[{text:truncate(e,100),type:`text`}],type:`rich_text_section`}],type:`rich_text`}}function truncate(e,t){if(e.length<=t)return e;let n=e.slice(0,t-1),r=n.lastIndexOf(` `);return`${(r>t/2?n.slice(0,r):n).trimEnd()}…`}function slackTaskId(e){return e.replace(/[^a-zA-Z0-9_-]/g,`_`).slice(-200)}function slackBlockId(e){return`eve_task_card_${slackTaskId(e)}`}const TRACKED_EVENTS=[`actions.requested`,`action.result`,`task.started`,`task.settled`,`input.requested`,`input.resolved`,`authorization.required`,`authorization.completed`,`turn.completed`,`turn.failed`,`turn.cancelled`];function withTaskCards(e,t){let n={};for(let r of TRACKED_EVENTS){let i=e[r];n[r]=async(e,n,a)=>{let o={data:e,type:r};o.type===`task.started`&&await closeSettledCard(n,o.data,t);let s=trackTaskCardEvent(trackedTurns(n.state),o,new Date().toISOString());for(let[e,t]of Object.entries(s))rememberTurn(n.state,e,t);try{await i?.(e,n,a)}finally{for(let e of Object.keys(s))await writeTaskCard(n,e,t)}}}return{...e,...n}}async function closeSettledCard(e,t,n){let r=e.state.taskCards?.[t.turnId],i=r&&closeSettledTasks(r.turn,t.callId);i!==void 0&&(e.state.taskCards={...e.state.taskCards,[t.turnId]:{...r,turn:i.closed}},await writeTaskCard(e,t.turnId,n),e.state.taskCards={...e.state.taskCards,[t.turnId]:{turn:i.open}})}function trackedTurns(e){return Object.fromEntries(Object.entries(e.taskCards??{}).map(([e,t])=>[e,t.turn]))}function rememberTurn(e,t,n){let r={...e.taskCards,[t]:{...e.taskCards?.[t],turn:n}},i=Object.keys(r);for(let e of i.slice(0,Math.max(0,i.length-20)))delete r[e];e.taskCards=r}async function writeTaskCard(e,t,n){let r=e.state.taskCards?.[t];if(r===void 0)return;let i=normalizeChannelAudience(e.state.audience),a=taskCardView(t,r.turn,{audience:i}),{channelId:o,threadTs:s}=e.state,c=contextStorage.getStore()?.get(ScheduleIdKey)!==void 0,l=o&&s&&!c?{channelId:o,threadTs:s}:void 0,u=l===void 0?null:renderCard(n,a);if(l!==void 0&&u!==null){let n=createHash(`sha256`).update(JSON.stringify(u)).digest(`base64url`);if(n!==r.fingerprint){let i=await writeCardWithRetry(e.slack,{...l,card:u,ts:r.ts});if(i===void 0)return;e.state.taskCards={...e.state.taskCards,[t]:{fingerprint:n,ts:i,turn:r.turn}}}}a.state===`finished`&&forgetTurn(e.state,t)}function forgetTurn(e,t){let{[t]:n,...r}=e.taskCards??{};e.taskCards=r}function renderCard(e,t){try{return e(t)}catch(e){return logError(log,`task card renderer failed`,e,{turnId:t.turnId}),null}}async function writeCardWithRetry(e,t){for(let n of[1,2])try{return await writeCard(e,t)}catch(e){logError(log,`task card write failed`,e,{attempt:n}),n===1&&await new Promise(e=>setTimeout(e,1e3))}}async function writeCard(e,t){let n={blocks:t.card.blocks,channel:t.channelId,text:t.card.text};if(t.ts!==void 0){let r=await e.request(`chat.update`,{...n,ts:t.ts});if(r.ok===!0)return t.ts;if(r.error!==`message_not_found`)throw slackError(r.error)}let r=await e.request(`chat.postMessage`,{...n,thread_ts:t.threadTs,unfurl_links:!1,unfurl_media:!1});if(r.ok!==!0)throw slackError(r.error);if(typeof r.ts!=`string`||r.ts===``)throw Error(`Slack did not return a ts for the task card.`);return r.ts}function slackError(e){return Error(`Slack task card failed: ${e??`unknown_error`}`)}export{renderDefaultSlackTaskCard,withTaskCards};

package/dist/src/public/channels/teams/defaults.d.ts

@@ -9,7 +9,7 @@ export declare function defaultTeamsAuth(message: TeamsMessageActivity | TeamsIn
 export declare function defaultOnMessage(ctx: TeamsContext, message: TeamsMessageActivity): Promise<TeamsInboundResult>;
 /** Built-in Teams event handlers for typing, replies, HITL, auth cards, and terminal errors. */
 export declare const defaultEvents: TeamsChannelEvents;
-/** Capitalizes the first character of a connection name for Teams auth card display (e.g. "linear" -> "Linear"). */
+/** A connection name for the Teams auth card (`linear` → `Linear`). */
 export declare function formatConnectionDisplayName(connectionName: string): string;
 /** Builds final-state text for a completed connection authorization attempt. */
 export declare function buildAuthCompletedText(input: {