@sentry/junior 0.82.0 → 0.84.0

package/dist/chat/config.d.ts

@@ -25,7 +25,7 @@ export interface ChatConfig {
     bot: BotConfig;
     functionMaxDurationSeconds: number;
     sql: {
-        databaseUrl?: string;
+        databaseUrl: string;
         driver: SqlDriver;
     };
     slack: {

package/dist/chat/conversations/store.d.ts

@@ -1,6 +1,6 @@
 import type { Destination } from "@sentry/junior-plugin-api";
 import type { StoredSlackRequester } from "@/chat/requester";
-export type ConversationSource = "api" | "internal" | "local" | "plugin" | "scheduler" | "slack";
+export type ConversationSource = "api" | "internal" | "local" | "plugin" | "resource_event" | "scheduler" | "slack";
 export type ConversationStatus = "awaiting_resume" | "failed" | "idle" | "pending" | "running";
 export interface ConversationExecution {
     lastCheckpointAtMs?: number;

package/dist/chat/plugins/agent-hooks.d.ts

@@ -19,7 +19,7 @@ export interface ToolHookResult {
 export interface PluginRouteRegistration extends PluginRoute {
     pluginName: string;
 }
-export interface PluginDashboardRouteRegistration {
+export interface PluginApiRouteRegistration {
     app: PluginRouteApp;
     pluginName: string;
 }
@@ -43,8 +43,8 @@ export declare function getPluginUserPromptContributions(args: {
 export declare function getPluginTools(context: ToolRuntimeContext): Record<string, ToolDefinition<any>>;
 /** Collect route handlers exposed by plugins for app-level mounting. */
 export declare function getPluginRoutes(): PluginRouteRegistration[];
-/** Collect dashboard-scoped route apps exposed by plugins. */
-export declare function getPluginDashboardRoutes(): PluginDashboardRouteRegistration[];
+/** Collect authenticated product API route apps exposed by plugins. */
+export declare function getPluginApiRoutes(): PluginApiRouteRegistration[];
 /** Resolve the first plugin conversation URL for finalized Slack footers. */
 export declare function getPluginSlackConversationLink(conversationId: string): SlackConversationLink | undefined;
 /** Collect read-only operational summaries exposed by plugins. */

package/dist/chat/resource-events/ingest.d.ts

@@ -0,0 +1,23 @@
+import type { StateAdapter } from "chat";
+import { z } from "zod";
+import type { ConversationWorkQueue } from "@/chat/task-execution/queue";
+declare const ingestResourceEventInputSchema: z.ZodObject<{
+    eventKey: z.ZodString;
+    eventType: z.ZodString;
+    occurredAtMs: z.ZodNumber;
+    provider: z.ZodString;
+    resourceRef: z.ZodString;
+    terminal: z.ZodOptional<z.ZodBoolean>;
+    trustedSummary: z.ZodString;
+    untrustedText: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type IngestResourceEventInput = z.output<typeof ingestResourceEventInputSchema>;
+/** Match a normalized provider event and enqueue notifications into conversations. */
+export declare function ingestResourceEvent(input: unknown, options: {
+    nowMs?: number;
+    queue: ConversationWorkQueue;
+    state?: StateAdapter;
+}): Promise<{
+    enqueued: number;
+}>;
+export {};

package/dist/chat/resource-events/notification.d.ts

@@ -0,0 +1,20 @@
+import type { ConversationWorkQueue } from "@/chat/task-execution/queue";
+import { appendAndEnqueueInboundMessage } from "@/chat/task-execution/store";
+import type { ResourceEventSubscription } from "@/chat/resource-events/store";
+export interface ResourceEventNotification {
+    eventKey: string;
+    eventType: string;
+    occurredAtMs: number;
+    provider: string;
+    resourceRef: string;
+    terminal?: boolean;
+    trustedSummary: string;
+    untrustedText?: string;
+}
+/** Enqueue a resource event as normal conversation mailbox input. */
+export declare function enqueueResourceEventNotification(args: {
+    event: ResourceEventNotification;
+    queue: ConversationWorkQueue;
+    subscription: ResourceEventSubscription;
+    state?: Parameters<typeof appendAndEnqueueInboundMessage>[0]["state"];
+}): Promise<Awaited<ReturnType<typeof appendAndEnqueueInboundMessage>>>;

package/dist/chat/resource-events/store.d.ts

@@ -0,0 +1,79 @@
+import type { StateAdapter } from "chat";
+import { type Destination } from "@sentry/junior-plugin-api";
+import { z } from "zod";
+declare const subscriptionSchema: z.ZodObject<{
+    conversationId: z.ZodString;
+    createdAtMs: z.ZodNumber;
+    destination: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        platform: z.ZodLiteral<"slack">;
+        teamId: z.ZodString;
+        channelId: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        platform: z.ZodLiteral<"local">;
+        conversationId: z.ZodString;
+    }, z.core.$strict>], "platform">;
+    events: z.ZodArray<z.ZodString>;
+    expiresAtMs: z.ZodNumber;
+    id: z.ZodString;
+    intent: z.ZodString;
+    label: z.ZodString;
+    provider: z.ZodString;
+    resourceRef: z.ZodString;
+    resourceType: z.ZodString;
+    status: z.ZodEnum<{
+        completed: "completed";
+        active: "active";
+        cancelled: "cancelled";
+    }>;
+    updatedAtMs: z.ZodNumber;
+}, z.core.$strict>;
+export type ResourceEventSubscription = z.output<typeof subscriptionSchema>;
+export interface CreateResourceEventSubscriptionInput {
+    conversationId: string;
+    destination: Destination;
+    events: string[];
+    expiresAtMs: number;
+    intent: string;
+    label: string;
+    provider: string;
+    resourceRef: string;
+    resourceType: string;
+}
+/** Create or replace the active subscription for one conversation/resource/event set. */
+export declare function createResourceEventSubscription(input: CreateResourceEventSubscriptionInput, options?: {
+    nowMs?: number;
+    state?: StateAdapter;
+}): Promise<ResourceEventSubscription>;
+/** List active subscriptions bound to one conversation. */
+export declare function listResourceEventSubscriptions(input: {
+    conversationId: string;
+    nowMs?: number;
+    state?: StateAdapter;
+}): Promise<ResourceEventSubscription[]>;
+/** Cancel a current-conversation subscription and remove it from match indexes. */
+export declare function cancelResourceEventSubscription(input: {
+    conversationId: string;
+    id: string;
+    nowMs?: number;
+    state?: StateAdapter;
+}): Promise<ResourceEventSubscription | undefined>;
+/** Find active subscriptions interested in a normalized provider event. */
+export declare function findMatchingResourceEventSubscriptions(input: {
+    eventType: string;
+    nowMs?: number;
+    provider: string;
+    resourceRef: string;
+    state?: StateAdapter;
+}): Promise<ResourceEventSubscription[]>;
+/** Recheck and deliver a matched subscription while holding its status lock. */
+export declare function deliverResourceEventSubscription(input: {
+    deliver: (subscription: ResourceEventSubscription) => Promise<boolean>;
+    eventType: string;
+    nowMs?: number;
+    provider: string;
+    resourceRef: string;
+    state?: StateAdapter;
+    subscription: ResourceEventSubscription;
+    terminal?: boolean;
+}): Promise<boolean>;
+export {};

package/dist/chat/services/pending-auth.d.ts

@@ -28,4 +28,9 @@ export declare function applyPendingAuthUpdate(args: {
     conversationId: string | undefined;
     nextPendingAuth: ConversationPendingAuthState;
 }): Promise<void>;
+/**
+ * Decide whether an auth callback still belongs to the latest real human
+ * request, ignoring bot-authored and passive bystander rows while treating
+ * failed human turns and opt-outs as newer freshness blockers.
+ */
 export declare function isPendingAuthLatestRequest(conversation: ThreadConversationState, pendingAuth: ConversationPendingAuthState): boolean;

package/dist/chat/slack/client.d.ts

@@ -1,5 +1,5 @@
 import { WebClient } from "@slack/web-api";
-export type SlackActionErrorCode = "missing_token" | "missing_scope" | "rate_limited" | "feature_unavailable" | "canvas_creation_failed" | "canvas_editing_failed" | "invalid_arguments" | "not_found" | "not_in_channel" | "already_reacted" | "no_reaction" | "internal_error";
+export type SlackActionErrorCode = "missing_token" | "missing_scope" | "rate_limited" | "feature_unavailable" | "canvas_creation_failed" | "canvas_editing_failed" | "invalid_arguments" | "not_found" | "not_in_channel" | "already_reacted" | "no_reaction" | "read_only_channel" | "internal_error";
 export declare class SlackActionError extends Error {
     code: SlackActionErrorCode;
     apiError?: string;
@@ -28,6 +28,8 @@ export declare class SlackActionError extends Error {
 interface SlackRetryContext {
     action?: string;
     attributes?: Record<string, string | number | boolean>;
+    /** Extra attributes forwarded onto the per-attempt Sentry span. */
+    spanAttributes?: Record<string, string | number | boolean>;
 }
 /** Extract a header value by case-insensitive name from a raw headers object. */
 export declare function getHeaderString(headers: unknown, name: string): string | undefined;

package/dist/chat/state/session-log.d.ts

@@ -110,6 +110,8 @@ declare const sessionLogEntrySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     subagentInvocationId: z.ZodString;
     outcome: z.ZodUnion<readonly [z.ZodLiteral<"success">, z.ZodLiteral<"error">, z.ZodLiteral<"aborted">]>;
     errorCode: z.ZodOptional<z.ZodString>;
+    transcriptEndMessageIndex: z.ZodOptional<z.ZodNumber>;
+    transcriptStartMessageIndex: z.ZodOptional<z.ZodNumber>;
     createdAtMs: z.ZodNumber;
 }, z.core.$strip>], "type">;
 /** Requester identity stored with turn-start messages for durable continuation. */
@@ -224,6 +226,8 @@ export declare function recordSubagentEnded(args: Scope & {
     sessionId?: string;
     store?: SessionLogStore;
     subagentInvocationId: string;
+    transcriptEndMessageIndex?: number;
+    transcriptStartMessageIndex?: number;
     ttlMs: number;
 }): Promise<void>;
 /**

package/dist/chat/task-execution/slack-work.d.ts

@@ -15,6 +15,25 @@ export interface SlackConversationMessageMetadata {
     route: SlackConversationRoute;
     thread: SerializedThread;
 }
+interface SlackResourceEventInboundInput {
+    event: {
+        eventKey: string;
+        eventType: string;
+        occurredAtMs: number;
+        provider: string;
+        resourceRef: string;
+    };
+    subscription: {
+        conversationId: string;
+        destination: {
+            channelId: string;
+            platform: "slack";
+            teamId: string;
+        };
+        id: string;
+    };
+    text: string;
+}
 export interface CreateSlackConversationWorkerOptions {
     getSlackAdapter: () => SlackAdapter;
     lookupSlackUser?: (teamId: string, userId: string) => Promise<SlackRequesterProfile | null | undefined>;
@@ -23,6 +42,8 @@ export interface CreateSlackConversationWorkerOptions {
     runtime: Pick<SlackTurnRuntime<unknown>, "handleNewMention" | "handleSubscribedMessage">;
     state?: StateAdapter;
 }
+/** Create a Slack mailbox record for a subscribed resource-event notification. */
+export declare function createSlackResourceEventInboundMessage(input: SlackResourceEventInboundInput): InboundMessage;
 /** Build the worker run function for queued Slack conversation work. */
 export declare function createSlackConversationWorker(options: CreateSlackConversationWorkerOptions): (context: ConversationWorkerContext) => Promise<ConversationWorkerResult>;
 /** Serialize a Slack message into the generic durable conversation mailbox. */
@@ -34,3 +55,4 @@ export declare function buildSlackInboundMessage(args: {
     route: SlackConversationRoute;
     thread: ThreadImpl;
 }): InboundMessage;
+export {};

package/dist/chat/task-execution/state.d.ts

@@ -6,7 +6,7 @@ export declare const CONVERSATION_ACTIVE_INDEX_KEY = "junior:conversation:active
 export declare const CONVERSATION_WORK_LEASE_TTL_MS = 90000;
 export declare const CONVERSATION_WORK_CHECK_IN_INTERVAL_MS = 15000;
 export declare const CONVERSATION_WORK_STALE_ENQUEUE_MS = 60000;
-export type Source = "api" | "internal" | "local" | "plugin" | "scheduler" | "slack";
+export type Source = "api" | "internal" | "local" | "plugin" | "resource_event" | "scheduler" | "slack";
 export type ExecutionStatus = "awaiting_resume" | "failed" | "idle" | "pending" | "running";
 export interface AgentInput {
     attachments?: unknown[];
@@ -127,7 +127,7 @@ export declare function recordConversationActivity(args: {
     state?: StateAdapter;
     title?: string;
 }): Promise<void>;
-/** Store task-execution metadata for local/no-SQL reporting. */
+/** Store task-execution metadata for legacy SQL import. */
 export declare function recordConversationExecution(args: {
     channelName?: string;
     conversationId: string;
@@ -153,6 +153,12 @@ export declare function markConversationWorkEnqueued(args: {
     nowMs?: number;
     state?: StateAdapter;
 }): Promise<void>;
+/** Clear a wake marker after its queue delivery finds no runnable work. */
+export declare function clearConsumedConversationWake(args: {
+    conversationId: string;
+    nowMs?: number;
+    state?: StateAdapter;
+}): Promise<boolean>;
 /** Try to acquire the durable execution lease for one conversation. */
 export declare function startConversationWork(args: {
     conversationId: string;

package/dist/chat/task-execution/store.d.ts

@@ -4,6 +4,12 @@ import type { ConversationWorkQueue } from "./queue";
 import * as workState from "./state";
 export { CONVERSATION_ACTIVE_INDEX_KEY, CONVERSATION_BY_ACTIVITY_INDEX_KEY, CONVERSATION_WORK_CHECK_IN_INTERVAL_MS, CONVERSATION_WORK_LEASE_TTL_MS, CONVERSATION_WORK_STALE_ENQUEUE_MS, type AgentInput, type AppendAndEnqueueInboundMessageResult, type AppendInboundMessageResult, type Conversation, type ConversationExecution, type ConversationWorkLease, type ConversationWorkState, type ExecutionStatus, type InboundMessage, type Lease, type RequestConversationWorkResult, type Source, type StartConversationWorkAcquired, type StartConversationWorkActive, type StartConversationWorkNoWork, type StartConversationWorkResult, } from "@/chat/task-execution/state";
 import type { AppendAndEnqueueInboundMessageResult, Conversation, InboundMessage } from "@/chat/task-execution/state";
+export type EnsureConversationWakeResult = {
+    queueMessageId?: string;
+    status: "enqueued";
+} | {
+    status: "already_enqueued" | "no_work";
+};
 /** Return a persisted conversation record, if one exists. */
 export declare function getConversation(args: {
     conversationId: string;
@@ -18,6 +24,22 @@ export declare function getConversationWorkState(args: {
 export declare function countPendingConversationMessages(conversation: Conversation): number;
 /** Return whether a conversation has pending or resumable execution work. */
 export declare function hasRunnableConversationWork(conversation: Conversation): boolean;
+/**
+ * Ensure runnable conversation work has one accepted queue wake-up nudge.
+ *
+ * Ordinary wakes coalesce on a recent accepted marker. Replacement is only for
+ * consumed or known-stale deliveries where another queue nudge must exist.
+ */
+export declare function ensureConversationWake(args: {
+    conversationId: string;
+    conversationStore?: ConversationStore;
+    delayMs?: number;
+    idempotencyKey: string;
+    nowMs?: number;
+    queue: ConversationWorkQueue;
+    replaceExistingWake?: true;
+    state?: StateAdapter;
+}): Promise<EnsureConversationWakeResult>;
 /** Persist one inbound message idempotently in its conversation mailbox. */
 export declare function appendInboundMessage(args: {
     message: InboundMessage;
@@ -25,7 +47,7 @@ export declare function appendInboundMessage(args: {
     nowMs?: number;
     state?: StateAdapter;
 }): Promise<workState.AppendInboundMessageResult>;
-/** Persist inbound work and send the queue nudge that wakes a worker. */
+/** Persist inbound work and ensure a worker wake-up. */
 export declare function appendAndEnqueueInboundMessage(args: {
     message: InboundMessage;
     conversationStore?: ConversationStore;
@@ -33,6 +55,13 @@ export declare function appendAndEnqueueInboundMessage(args: {
     queue: ConversationWorkQueue;
     state?: StateAdapter;
 }): Promise<AppendAndEnqueueInboundMessageResult>;
+/** Clear an accepted wake marker after its delivery finds no runnable work. */
+export declare function clearConsumedConversationWake(args: {
+    conversationId: string;
+    conversationStore?: ConversationStore;
+    nowMs?: number;
+    state?: StateAdapter;
+}): Promise<boolean>;
 /** Mark a conversation runnable when there is no new mailbox message. */
 export declare function requestConversationWork(args: {
     conversationId: string;
@@ -46,13 +75,6 @@ export declare function recordConversationActivity(args: Parameters<Conversation
     conversationStore?: ConversationStore;
     state?: StateAdapter;
 }): Promise<void>;
-/** Record that a wake-up nudge was accepted for the conversation. */
-export declare function markConversationWorkEnqueued(args: {
-    conversationId: string;
-    conversationStore?: ConversationStore;
-    nowMs?: number;
-    state?: StateAdapter;
-}): Promise<void>;
 /** Try to acquire the durable execution lease for one conversation. */
 export declare function startConversationWork(args: {
     conversationId: string;

package/dist/chat/tools/resource-events.d.ts

@@ -0,0 +1,19 @@
+import type { ToolRuntimeContext } from "@/chat/tools/types";
+/** Return whether the current runtime can safely manage conversation subscriptions. */
+export declare function canUseResourceEventSubscriptionTools(context: ToolRuntimeContext): boolean;
+/** Create the tool that subscribes the current conversation to resource events. */
+export declare function createSubscribeToResourceEventsTool(context: ToolRuntimeContext): import("@/chat/tools/definition").ToolDefinition<import("@sinclair/typebox").TObject<{
+    resourceRef: import("@sinclair/typebox").TString;
+    provider: import("@sinclair/typebox").TString;
+    resourceType: import("@sinclair/typebox").TString;
+    label: import("@sinclair/typebox").TString;
+    events: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+    intent: import("@sinclair/typebox").TString;
+    ttlMs: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+}>>;
+/** Create the tool that lists active resource subscriptions for this conversation. */
+export declare function createListResourceEventSubscriptionsTool(context: ToolRuntimeContext): import("@/chat/tools/definition").ToolDefinition<import("@sinclair/typebox").TObject<{}>>;
+/** Create the tool that cancels a current-conversation resource subscription. */
+export declare function createCancelResourceEventSubscriptionTool(context: ToolRuntimeContext): import("@/chat/tools/definition").ToolDefinition<import("@sinclair/typebox").TObject<{
+    subscriptionId: import("@sinclair/typebox").TString;
+}>>;

package/dist/{chunk-PQ2U2AO3.js → chunk-AAD2D7K3.js}

@@ -1,10 +1,10 @@
 import {
   parseDestination,
   sameDestination
-} from "./chunk-4XHCVBXH.js";
+} from "./chunk-BAPRSWNW.js";
 import {
   getChatConfig
-} from "./chunk-ABRNFE3N.js";
+} from "./chunk-ALL7GG6U.js";
 import {
   parseStoredSlackRequester
 } from "./chunk-ZPCGQRFJ.js";
@@ -371,7 +371,7 @@ function requiredMsFromDate(value) {
   return ms;
 }
 function sourceFromValue(value) {
-  if (value === "api" || value === "internal" || value === "local" || value === "plugin" || value === "scheduler" || value === "slack") {
+  if (value === "api" || value === "internal" || value === "local" || value === "plugin" || value === "resource_event" || value === "scheduler" || value === "slack") {
     return value;
   }
   return void 0;
@@ -408,6 +408,14 @@ function systemIdentityFromSource(source) {
       displayName: "Local CLI"
     };
   }
+  if (source === "resource_event") {
+    return {
+      kind: "system",
+      provider: "junior",
+      providerSubjectId: "resource-event",
+      displayName: "Resource Event"
+    };
+  }
   return void 0;
 }
 function actorIdentityForConversation(conversation) {
@@ -1033,14 +1041,6 @@ function createDb(args) {
 }
 function getSqlExecutor() {
   const { sql: sql3 } = getChatConfig();
-  if (!sql3.databaseUrl) {
-    if (current) {
-      const previous = current;
-      current = void 0;
-      void previous.db.close().catch(() => void 0);
-    }
-    throw new Error("DATABASE_URL or JUNIOR_DATABASE_URL is required");
-  }
   if (current?.databaseUrl !== sql3.databaseUrl || current.driver !== sql3.driver) {
     if (current) {
       const previous = current;

package/dist/{chunk-ABRNFE3N.js → chunk-ALL7GG6U.js}

@@ -757,13 +757,14 @@ function readBotConfig(env) {
     advisor: readAdvisorConfig(env)
   };
 }
-function readJuniorDatabaseUrl(env) {
-  return toOptionalTrimmed(env.JUNIOR_DATABASE_URL) ?? toOptionalTrimmed(env.DATABASE_URL);
-}
-function isLocalDatabaseUrl(databaseUrl) {
+function readDatabaseUrl(env) {
+  const databaseUrl = toOptionalTrimmed(env.DATABASE_URL);
   if (!databaseUrl) {
-    return false;
+    throw new Error("DATABASE_URL is required");
   }
+  return databaseUrl;
+}
+function isLocalDatabaseUrl(databaseUrl) {
   try {
     const { hostname } = new URL(databaseUrl);
     return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "[::1]";
@@ -785,7 +786,7 @@ function readSqlDriver(env, databaseUrl) {
   throw new Error("JUNIOR_DATABASE_DRIVER must be postgres or neon");
 }
 function readChatConfig(env = process.env) {
-  const databaseUrl = readJuniorDatabaseUrl(env);
+  const databaseUrl = readDatabaseUrl(env);
   return {
     bot: readBotConfig(env),
     functionMaxDurationSeconds: resolveFunctionMaxDurationSeconds(env),

package/dist/{chunk-4XHCVBXH.js → chunk-BAPRSWNW.js}

@@ -1,10 +1,13 @@
 import {
   getSlackBotToken
-} from "./chunk-ABRNFE3N.js";
+} from "./chunk-ALL7GG6U.js";
 import {
   isSlackConversationId,
   isSlackTeamId,
-  logWarn
+  logWarn,
+  setSpanAttributes,
+  setSpanStatus,
+  withSpan
 } from "./chunk-KF7522P3.js";
 
 // src/chat/slack/client.ts
@@ -142,6 +145,9 @@ function mapSlackError(error) {
   if (apiError === "not_in_channel") {
     return new SlackActionError(message, "not_in_channel", baseOptions);
   }
+  if (apiError === "restricted_action_read_only_channel") {
+    return new SlackActionError(message, "read_only_channel", baseOptions);
+  }
   if (apiError === "already_reacted") {
     return new SlackActionError(message, "already_reacted", baseOptions);
   }
@@ -182,15 +188,56 @@ function sleep(ms) {
 }
 async function withSlackRetries(task, maxAttempts = 3, context = {}) {
   let attempt = 0;
+  const action = context.action ?? "unknown";
   while (attempt < maxAttempts) {
     attempt += 1;
+    const attemptNumber = attempt;
     try {
-      return await task();
+      return await withSpan(
+        `POST slack.com/api/${action}`,
+        "http.client",
+        {},
+        async () => {
+          try {
+            return await task();
+          } catch (error) {
+            const mapped = mapSlackError(error);
+            const errorAttrs = {
+              "error.type": mapped.code
+            };
+            if (mapped.apiError) {
+              errorAttrs["app.slack.api_error_code"] = mapped.apiError;
+            }
+            if (mapped.code === "rate_limited") {
+              errorAttrs["http.response.status_code"] = 429;
+              if (mapped.retryAfterSeconds) {
+                errorAttrs["app.slack.retry_after_ms"] = mapped.retryAfterSeconds * 1e3;
+              }
+            } else if (mapped.statusCode != null) {
+              errorAttrs["http.response.status_code"] = mapped.statusCode;
+            }
+            setSpanAttributes(errorAttrs);
+            setSpanStatus("error");
+            throw error;
+          }
+        },
+        {
+          "http.request.method": "POST",
+          "server.address": "slack.com",
+          "url.scheme": "https",
+          "url.path": `/api/${action}`,
+          "app.slack.method": action,
+          "app.retry.max_attempts": maxAttempts,
+          ...attemptNumber > 1 ? { "http.resend_count": attemptNumber - 1 } : {},
+          ...context.attributes ?? {},
+          ...context.spanAttributes ?? {}
+        }
+      );
     } catch (error) {
       const mapped = mapSlackError(error);
       const isRetryable = mapped.code === "rate_limited";
       const baseLogAttributes = {
-        "app.slack.action": context.action ?? "unknown",
+        "app.slack.action": action,
         "app.slack.error_code": mapped.code,
         ...mapped.apiError ? { "app.slack.api_error": mapped.apiError } : {},
         ...mapped.detail ? { "app.slack.detail": mapped.detail } : {},
@@ -253,7 +300,12 @@ async function getFilePermalink(fileId) {
   const response = await withSlackRetries(
     () => client2.files.info({
       file: fileId
-    })
+    }),
+    3,
+    {
+      action: "files.info",
+      spanAttributes: { "app.slack.file_id": fileId }
+    }
   );
   return response.file?.permalink;
 }
@@ -265,15 +317,31 @@ async function downloadPrivateSlackFile(url) {
       "missing_token"
     );
   }
-  const response = await fetch(url, {
-    headers: {
-      Authorization: `Bearer ${token}`
+  return withSpan(
+    "GET files.slack.com",
+    "http.client",
+    {},
+    async () => {
+      const response = await fetch(url, {
+        headers: {
+          Authorization: `Bearer ${token}`
+        }
+      });
+      setSpanAttributes({ "http.response.status_code": response.status });
+      if (!response.ok) {
+        setSpanAttributes({ "error.type": String(response.status) });
+        setSpanStatus("error");
+        throw new Error(`Slack file download failed: ${response.status}`);
+      }
+      return Buffer.from(await response.arrayBuffer());
+    },
+    {
+      "http.request.method": "GET",
+      "server.address": "files.slack.com",
+      "url.scheme": "https",
+      "app.slack.method": "files.download"
     }
-  });
-  if (!response.ok) {
-    throw new Error(`Slack file download failed: ${response.status}`);
-  }
-  return Buffer.from(await response.arrayBuffer());
+  );
 }
 
 // src/chat/destination.ts