@sentry/junior 0.72.0 → 0.73.0

package/dist/chunk-ZDA2HYX5.js

@@ -0,0 +1,275 @@
+import {
+  normalizeSlackConversationId
+} from "./chunk-V4VYUY4A.js";
+import {
+  getStateAdapter
+} from "./chunk-DIMX5F3T.js";
+import {
+  parseSlackThreadId
+} from "./chunk-WS2EG3GW.js";
+import {
+  parseStoredSlackRequester
+} from "./chunk-CYUI7JU5.js";
+import {
+  isRecord,
+  toOptionalNumber
+} from "./chunk-3BYAPS6B.js";
+import {
+  sentry_exports
+} from "./chunk-SJHUF3DP.js";
+
+// src/handlers/health.ts
+function GET() {
+  return Response.json({
+    status: "ok",
+    service: "junior",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  });
+}
+
+// src/chat/sentry-links.ts
+function getSentryOrgSlug() {
+  const slug = process.env.SENTRY_ORG_SLUG?.trim();
+  return slug || void 0;
+}
+function isSentrySaasDsnHost(host) {
+  return host === "sentry.io" || host.endsWith(".sentry.io");
+}
+function buildSentryWebBaseUrl(dsn) {
+  if (isSentrySaasDsnHost(dsn.host)) {
+    return "https://sentry.io";
+  }
+  const port = dsn.port ? `:${dsn.port}` : "";
+  const path = dsn.path ? `/${dsn.path}` : "";
+  return `${dsn.protocol}://${dsn.host}${port}${path}`;
+}
+function buildSentryConversationUrl(conversationId) {
+  const client = sentry_exports.getClient();
+  const dsn = client?.getDsn();
+  if (!dsn?.host || !dsn.projectId) {
+    return void 0;
+  }
+  const orgSlug = getSentryOrgSlug();
+  if (!orgSlug) {
+    return void 0;
+  }
+  const encodedId = encodeURIComponent(conversationId);
+  const params = new URLSearchParams();
+  params.set("project", dsn.projectId);
+  const path = `explore/conversations/${encodedId}/?${params.toString()}`;
+  if (isSentrySaasDsnHost(dsn.host)) {
+    return `https://${orgSlug}.sentry.io/${path}`;
+  }
+  return `${buildSentryWebBaseUrl(dsn)}/organizations/${orgSlug}/${path}`;
+}
+function buildSentryTraceUrl(traceId) {
+  const client = sentry_exports.getClient();
+  const dsn = client?.getDsn();
+  if (!dsn?.host || !dsn.projectId) {
+    return void 0;
+  }
+  const orgSlug = getSentryOrgSlug();
+  if (!orgSlug) {
+    return void 0;
+  }
+  const encodedTraceId = encodeURIComponent(traceId);
+  const params = new URLSearchParams();
+  params.set("project", dsn.projectId);
+  const path = `performance/trace/${encodedTraceId}/?${params.toString()}`;
+  if (isSentrySaasDsnHost(dsn.host)) {
+    return `https://${orgSlug}.sentry.io/${path}`;
+  }
+  return `${buildSentryWebBaseUrl(dsn)}/organizations/${orgSlug}/${path}`;
+}
+
+// src/chat/slack/conversation-context.ts
+function normalizeConversationName(type, channelName) {
+  const trimmed = channelName?.trim();
+  if (!trimmed) return void 0;
+  if (type === "public_channel" || type === "private_channel" || type === "private_channel_or_group_dm") {
+    return trimmed.startsWith("#") ? trimmed : `#${trimmed}`;
+  }
+  return trimmed;
+}
+function typeFromSlackChannelType(channelType) {
+  if (channelType === "channel") return "public_channel";
+  if (channelType === "group") return "private_channel";
+  if (channelType === "mpim") return "group_dm";
+  if (channelType === "im") return "direct_message";
+  return void 0;
+}
+function typeFromChannelId(channelId, channelName) {
+  const normalized = normalizeSlackConversationId(channelId);
+  if (!normalized) return void 0;
+  if (normalized.startsWith("C")) return "public_channel";
+  if (normalized.startsWith("D")) return "direct_message";
+  if (normalized.startsWith("G")) {
+    return channelName?.trim().startsWith("mpdm-") ? "group_dm" : "private_channel_or_group_dm";
+  }
+  return void 0;
+}
+function toSlackEventChannelType(channelType) {
+  if (channelType === "channel" || channelType === "group" || channelType === "mpim" || channelType === "im") {
+    return channelType;
+  }
+  return void 0;
+}
+function resolveSlackChannelTypeFromMessage(message) {
+  const raw = message.raw;
+  if (!raw || typeof raw !== "object") {
+    return void 0;
+  }
+  const channelType = raw.channel_type;
+  return typeof channelType === "string" ? toSlackEventChannelType(channelType.trim()) : void 0;
+}
+function resolveSlackConversationContext(input) {
+  const type = typeFromSlackChannelType(input.channelType) ?? typeFromChannelId(input.channelId, input.channelName);
+  if (!type) return void 0;
+  const name = normalizeConversationName(type, input.channelName);
+  return {
+    type,
+    ...name ? { name } : {}
+  };
+}
+function resolveSlackConversationContextFromThreadId(input) {
+  const slackThread = parseSlackThreadId(input.threadId);
+  return resolveSlackConversationContext({
+    channelId: slackThread?.channelId,
+    channelName: input.channelName
+  });
+}
+function formatSlackConversationTypeLabel(type) {
+  if (type === "public_channel") return "Public Channel";
+  if (type === "private_channel") return "Private Channel";
+  if (type === "group_dm") return "Group DM";
+  if (type === "direct_message") return "Direct Message";
+  return "Private Channel or Group DM";
+}
+function formatSlackConversationRedactedLabel(context) {
+  if (!context) return void 0;
+  return formatSlackConversationTypeLabel(context.type);
+}
+
+// src/chat/state/conversation-details.ts
+import { THREAD_STATE_TTL_MS } from "chat";
+var CONVERSATION_PREFIX = "junior:conversation";
+var CONVERSATION_DETAILS_TTL_MS = THREAD_STATE_TTL_MS;
+function conversationContextKey(conversationId) {
+  return `${CONVERSATION_PREFIX}:${conversationId}:context`;
+}
+function conversationTitleKey(conversationId) {
+  return `${CONVERSATION_PREFIX}:${conversationId}:title`;
+}
+function parseOriginRequester(value) {
+  return parseStoredSlackRequester(value);
+}
+function parseOriginSurface(value) {
+  if (value === "slack" || value === "api" || value === "scheduler" || value === "internal") {
+    return value;
+  }
+  return void 0;
+}
+function storedContextFromInput(context) {
+  return {
+    ...context.channelName ? { channelName: context.channelName } : {},
+    ...context.originSurface ? { originSurface: context.originSurface } : {},
+    ...context.originRequester ? { originRequester: context.originRequester } : {},
+    startedAtMs: context.startedAtMs
+  };
+}
+function parseContext(value) {
+  if (!isRecord(value)) return void 0;
+  const startedAtMs = toOptionalNumber(value.startedAtMs);
+  if (startedAtMs === void 0) return void 0;
+  return {
+    ...typeof value.channelName === "string" && value.channelName.trim() ? { channelName: value.channelName.trim() } : {},
+    ...parseOriginSurface(value.originSurface) ? { originSurface: parseOriginSurface(value.originSurface) } : {},
+    ...parseOriginRequester(value.originRequester) ? { originRequester: parseOriginRequester(value.originRequester) } : {},
+    startedAtMs
+  };
+}
+function parseTitle(value) {
+  if (!isRecord(value)) return void 0;
+  const displayTitle = typeof value.displayTitle === "string" && value.displayTitle.trim() ? value.displayTitle.trim() : void 0;
+  if (!displayTitle) return void 0;
+  return {
+    displayTitle,
+    ...typeof value.titleSourceMessageId === "string" ? { titleSourceMessageId: value.titleSourceMessageId } : {}
+  };
+}
+async function initConversationContext(conversationId, context) {
+  const stateAdapter = getStateAdapter();
+  await stateAdapter.connect();
+  const key = conversationContextKey(conversationId);
+  const inserted = await stateAdapter.setIfNotExists(
+    key,
+    storedContextFromInput(context),
+    CONVERSATION_DETAILS_TTL_MS
+  );
+  if (inserted) return;
+  const existing = parseContext(await stateAdapter.get(key));
+  if (!existing) {
+    return;
+  }
+  await stateAdapter.set(key, existing, CONVERSATION_DETAILS_TTL_MS);
+}
+async function setConversationTitle(conversationId, title) {
+  const stateAdapter = getStateAdapter();
+  await stateAdapter.connect();
+  await stateAdapter.set(
+    conversationTitleKey(conversationId),
+    {
+      displayTitle: title.displayTitle,
+      ...title.titleSourceMessageId ? { titleSourceMessageId: title.titleSourceMessageId } : {}
+    },
+    CONVERSATION_DETAILS_TTL_MS
+  );
+}
+async function getConversationDetails(conversationId) {
+  const stateAdapter = getStateAdapter();
+  await stateAdapter.connect();
+  const [rawContext, rawTitle] = await Promise.all([
+    stateAdapter.get(conversationContextKey(conversationId)),
+    stateAdapter.get(conversationTitleKey(conversationId))
+  ]);
+  const context = parseContext(rawContext);
+  const title = parseTitle(rawTitle);
+  if (!context && !title) return void 0;
+  return {
+    conversationId,
+    ...title?.displayTitle ? { displayTitle: title.displayTitle } : {},
+    ...title?.titleSourceMessageId ? { titleSourceMessageId: title.titleSourceMessageId } : {},
+    ...context?.channelName ? { channelName: context.channelName } : {},
+    ...context?.originSurface ? { originSurface: context.originSurface } : {},
+    ...context?.originRequester ? { originRequester: context.originRequester } : {},
+    ...context?.startedAtMs !== void 0 ? { startedAtMs: context.startedAtMs } : {}
+  };
+}
+async function getConversationDetailsForIds(conversationIds) {
+  const uniqueIds = [...new Set(conversationIds)].filter(Boolean);
+  const entries = await Promise.all(
+    uniqueIds.map(async (id) => {
+      const details = await getConversationDetails(id);
+      return details ? [id, details] : void 0;
+    })
+  );
+  const result = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    if (entry) result.set(entry[0], entry[1]);
+  }
+  return result;
+}
+
+export {
+  GET,
+  buildSentryConversationUrl,
+  buildSentryTraceUrl,
+  resolveSlackChannelTypeFromMessage,
+  resolveSlackConversationContext,
+  resolveSlackConversationContextFromThreadId,
+  formatSlackConversationRedactedLabel,
+  initConversationContext,
+  setConversationTitle,
+  getConversationDetails,
+  getConversationDetailsForIds
+};

package/dist/cli/chat.js

@@ -0,0 +1,205 @@
+import "../chunk-2KG3PWR4.js";
+
+// src/cli/chat.ts
+import {
+  stdin as defaultStdin,
+  stderr as defaultStderr,
+  stdout as defaultStdout
+} from "process";
+import { randomUUID } from "crypto";
+import * as readline from "readline/promises";
+
+// src/chat/local/conversation.ts
+import { createHash } from "crypto";
+import path from "path";
+var LOCAL_CONVERSATION_ALIAS_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
+function slugifyConversationAlias(alias) {
+  const trimmed = alias.trim();
+  if (!LOCAL_CONVERSATION_ALIAS_PATTERN.test(trimmed)) {
+    return void 0;
+  }
+  return trimmed.toLowerCase().replaceAll(".", "-");
+}
+function workspaceKey(cwd) {
+  return createHash("sha256").update(path.resolve(cwd)).digest("hex").slice(0, 12);
+}
+function normalizeLocalConversationId(input) {
+  const slug = slugifyConversationAlias(input.alias);
+  if (!slug) {
+    return void 0;
+  }
+  return `local:${workspaceKey(input.cwd ?? process.cwd())}:${slug}`;
+}
+
+// src/cli/chat.ts
+var CHAT_USAGE = "usage: junior chat\n       junior chat -p <message>";
+var DEFAULT_IO = {
+  error: (line) => writeStream(defaultStderr, `${line}
+`),
+  input: defaultStdin,
+  output: defaultStdout,
+  write: (text) => writeStream(defaultStdout, text)
+};
+var ChatOutputError = class extends Error {
+  constructor(error) {
+    super(errorMessage(error));
+    this.name = "ChatOutputError";
+  }
+};
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+async function deliverReply(io, reply) {
+  try {
+    const files = reply.files ?? [];
+    if (files.length > 0) {
+      const names = files.map(
+        (file) => typeof file.filename === "string" && file.filename.trim() ? file.filename : "generated file"
+      ).join(", ");
+      throw new Error(`Local chat cannot deliver files yet: ${names}`);
+    }
+    await io.write(formatReply(reply));
+  } catch (error) {
+    throw new ChatOutputError(error);
+  }
+}
+async function reportStatus(io, status) {
+  try {
+    await io.error(status);
+  } catch (error) {
+    throw new ChatOutputError(error);
+  }
+}
+function writeStream(stream, text) {
+  return new Promise((resolve, reject) => {
+    stream.write(text, (error) => {
+      if (error) {
+        reject(error);
+        return;
+      }
+      resolve();
+    });
+  });
+}
+function defaultStateAdapterForLocalChat() {
+  if (process.env.JUNIOR_STATE_ADAPTER) {
+    return;
+  }
+  process.env.JUNIOR_STATE_ADAPTER = "memory";
+}
+function parseChatArgs(argv) {
+  if (argv.length === 0) {
+    return { mode: "interactive" };
+  }
+  if (argv[0] !== "-p") {
+    return void 0;
+  }
+  const message = argv.slice(1).join(" ").trim();
+  if (!message) {
+    return void 0;
+  }
+  return { message, mode: "prompt" };
+}
+function formatReply(reply) {
+  const lines = [];
+  const text = reply.text.trim();
+  if (text) {
+    lines.push(text);
+  }
+  return `${lines.join("\n") || "[empty response]"}
+`;
+}
+function newRunConversationId() {
+  const conversationId = normalizeLocalConversationId({
+    alias: `run-${randomUUID()}`
+  });
+  if (!conversationId) {
+    throw new Error("Invalid local conversation name");
+  }
+  return conversationId;
+}
+async function runPrompt(options, io) {
+  defaultStateAdapterForLocalChat();
+  const conversationId = newRunConversationId();
+  const { runLocalAgentTurn } = await import("../runner-LMAM4OGD.js");
+  const result = await runLocalAgentTurn(
+    {
+      conversationId,
+      message: options.message
+    },
+    {
+      deliverReply: async (reply) => {
+        await deliverReply(io, reply);
+      },
+      onStatus: async (status) => {
+        await reportStatus(io, status);
+      }
+    }
+  );
+  return result.outcome === "success" ? 0 : 1;
+}
+async function runInteractive(io) {
+  defaultStateAdapterForLocalChat();
+  const conversationId = newRunConversationId();
+  const { runLocalAgentTurn } = await import("../runner-LMAM4OGD.js");
+  const rl = readline.createInterface({
+    input: io.input,
+    output: io.output,
+    terminal: true
+  });
+  try {
+    while (true) {
+      const message = (await rl.question("junior> ")).trim();
+      if (!message) {
+        continue;
+      }
+      if (message === "/exit" || message === "/quit") {
+        break;
+      }
+      try {
+        await runLocalAgentTurn(
+          {
+            conversationId,
+            message
+          },
+          {
+            deliverReply: async (reply) => {
+              await deliverReply(io, reply);
+            },
+            onStatus: async (status) => {
+              await reportStatus(io, status);
+            }
+          }
+        );
+      } catch (error) {
+        if (error instanceof ChatOutputError) {
+          throw error;
+        }
+        await reportStatus(io, errorMessage(error));
+      }
+    }
+  } finally {
+    rl.close();
+  }
+}
+async function runChat(argv, io = DEFAULT_IO) {
+  const options = parseChatArgs(argv);
+  if (!options) {
+    await io.error(CHAT_USAGE);
+    return 1;
+  }
+  try {
+    if (options.mode === "prompt") {
+      return await runPrompt(options, io);
+    }
+    await runInteractive(io);
+    return 0;
+  } catch (error) {
+    await io.error(errorMessage(error));
+    return 1;
+  }
+}
+export {
+  CHAT_USAGE,
+  runChat
+};

package/dist/cli/check.js

@@ -1,19 +1,18 @@
-import {
-  JUNIOR_CONVERSATION_WORK_CALLBACK_ROUTE,
-  JUNIOR_HEARTBEAT_ROUTE,
-  LEGACY_JUNIOR_CONVERSATION_WORK_FUNCTION
-} from "../chunk-6YY4Q3D4.js";
 import {
   parseSkillFile
-} from "../chunk-55XEZFGD.js";
+} from "../chunk-OR6NQJ5E.js";
 import {
   parseInlinePluginManifest,
   parsePluginManifest
-} from "../chunk-GB3AL54K.js";
+} from "../chunk-7Q5YOUUT.js";
 import "../chunk-KVZL5NZS.js";
-import "../chunk-PP7AGSBU.js";
-import "../chunk-6GEYPE6T.js";
-import "../chunk-Z3YD6NHK.js";
+import "../chunk-CYUI7JU5.js";
+import "../chunk-3BYAPS6B.js";
+import {
+  JUNIOR_CONVERSATION_WORK_CALLBACK_ROUTE,
+  JUNIOR_HEARTBEAT_ROUTE,
+  LEGACY_JUNIOR_CONVERSATION_WORK_FUNCTION
+} from "../chunk-SJHUF3DP.js";
 import "../chunk-2KG3PWR4.js";
 
 // src/cli/check.ts

package/dist/cli/run.js

@@ -1,12 +1,20 @@
 import "../chunk-2KG3PWR4.js";
 
 // src/cli/run.ts
-var CLI_USAGE = "usage: junior init <dir>\n       junior snapshot create\n       junior check [dir]\n       junior upgrade";
+var CLI_USAGE = "usage: junior init <dir>\n       junior snapshot create\n       junior check [dir]\n       junior upgrade\n       junior chat\n       junior chat -p <message>";
 var DEFAULT_IO = {
   error: console.error
 };
+function normalizeCliArgv(argv) {
+  return argv[0] === "--" ? argv.slice(1) : argv;
+}
 async function runCli(argv, handlers, io = DEFAULT_IO) {
-  const [command, subcommand, ...rest] = argv;
+  const [command, subcommand, ...rest] = normalizeCliArgv(argv);
+  if (command === "chat") {
+    return await handlers.runChat(
+      subcommand === void 0 ? [] : [subcommand, ...rest]
+    );
+  }
   if (command === "init") {
     if (!subcommand || rest.length > 0) {
       io.error(CLI_USAGE);

package/dist/cli/snapshot-warmup.js

@@ -1,20 +1,20 @@
 import {
   resolveRuntimeDependencySnapshot
-} from "../chunk-VLIO6RQR.js";
+} from "../chunk-RY6AL5C7.js";
 import "../chunk-G3E7SCME.js";
 import {
   getPluginProviders,
   getPluginRuntimeDependencies,
   getPluginRuntimePostinstall
-} from "../chunk-GB3AL54K.js";
+} from "../chunk-7Q5YOUUT.js";
 import "../chunk-KVZL5NZS.js";
 import {
   disconnectStateAdapter
-} from "../chunk-3FYPXHPL.js";
-import "../chunk-ZJQPA67D.js";
-import "../chunk-PP7AGSBU.js";
-import "../chunk-6GEYPE6T.js";
-import "../chunk-Z3YD6NHK.js";
+} from "../chunk-DIMX5F3T.js";
+import "../chunk-WS2EG3GW.js";
+import "../chunk-CYUI7JU5.js";
+import "../chunk-3BYAPS6B.js";
+import "../chunk-SJHUF3DP.js";
 import "../chunk-2KG3PWR4.js";
 
 // src/cli/snapshot-warmup.ts

package/dist/cli/upgrade.js

@@ -1,29 +1,29 @@
 import {
   coerceThreadConversationState
-} from "../chunk-4JXCSGSA.js";
+} from "../chunk-M4FLLXXD.js";
 import {
   JUNIOR_THREAD_STATE_TTL_MS,
   getConversation,
   requestConversationWork
-} from "../chunk-HNMUVGSR.js";
+} from "../chunk-AL5T52ZD.js";
 import {
   parseDestination,
   sameDestination
-} from "../chunk-XC33FJZN.js";
+} from "../chunk-V4VYUY4A.js";
 import {
   disconnectStateAdapter,
   getConnectedStateContext
-} from "../chunk-3FYPXHPL.js";
+} from "../chunk-DIMX5F3T.js";
 import {
   getChatConfig
-} from "../chunk-ZJQPA67D.js";
-import "../chunk-PP7AGSBU.js";
+} from "../chunk-WS2EG3GW.js";
+import "../chunk-CYUI7JU5.js";
 import {
   isRecord,
   toOptionalNumber,
   toOptionalString
-} from "../chunk-6GEYPE6T.js";
-import "../chunk-Z3YD6NHK.js";
+} from "../chunk-3BYAPS6B.js";
+import "../chunk-SJHUF3DP.js";
 import "../chunk-2KG3PWR4.js";
 
 // src/cli/upgrade/migrations/redis-conversation-state.ts

package/dist/deployment.d.ts

@@ -2,3 +2,7 @@ export declare const JUNIOR_HEARTBEAT_ROUTE = "/api/internal/heartbeat";
 export declare const JUNIOR_HEARTBEAT_CRON_SCHEDULE = "* * * * *";
 export declare const JUNIOR_CONVERSATION_WORK_CALLBACK_ROUTE = "/api/internal/agent/continue";
 export declare const LEGACY_JUNIOR_CONVERSATION_WORK_FUNCTION = "api/internal/agent/continue.ts";
+/** Resolve the deployment version used for release and telemetry correlation. */
+export declare function getDeploymentServiceVersion(): string | undefined;
+/** Resolve deployment-scoped telemetry attributes from host environment. */
+export declare function getDeploymentTelemetryAttributes(): Record<string, string>;

package/dist/handlers/agent-dispatch.d.ts

@@ -1,3 +1,8 @@
+import type { SandboxEgressTracePropagationConfig } from "@/chat/sandbox/egress-tracing";
 import type { WaitUntilFn } from "@/handlers/types";
+interface AgentDispatchHandlerOptions {
+    tracePropagation?: SandboxEgressTracePropagationConfig;
+}
 /** Handle the authenticated internal agent-dispatch callback. */
-export declare function POST(request: Request, waitUntil: WaitUntilFn): Promise<Response>;
+export declare function POST(request: Request, waitUntil: WaitUntilFn, options?: AgentDispatchHandlerOptions): Promise<Response>;
+export {};

package/dist/handlers/mcp-oauth-callback.d.ts

@@ -1,2 +1,7 @@
+import type { generateAssistantReply } from "@/chat/respond";
 import type { WaitUntilFn } from "@/handlers/types";
-export declare function GET(request: Request, provider: string, waitUntil: WaitUntilFn): Promise<Response>;
+interface McpOAuthCallbackOptions {
+    generateReply?: typeof generateAssistantReply;
+}
+export declare function GET(request: Request, provider: string, waitUntil: WaitUntilFn, options?: McpOAuthCallbackOptions): Promise<Response>;
+export {};

package/dist/handlers/oauth-callback.d.ts

@@ -1,2 +1,7 @@
 import type { WaitUntilFn } from "@/handlers/types";
-export declare function GET(request: Request, provider: string, waitUntil: WaitUntilFn): Promise<Response>;
+import type { generateAssistantReply } from "@/chat/respond";
+interface OAuthCallbackOptions {
+    generateReply?: typeof generateAssistantReply;
+}
+export declare function GET(request: Request, provider: string, waitUntil: WaitUntilFn, options?: OAuthCallbackOptions): Promise<Response>;
+export {};

package/dist/handlers/sandbox-egress-proxy.d.ts

@@ -1,6 +1,8 @@
 import { type SandboxEgressHttpInterceptor } from "@/chat/sandbox/egress-proxy";
+import type { SandboxEgressTracePropagationConfig } from "@/chat/sandbox/egress-tracing";
 interface SandboxEgressProxyOptions {
     interceptHttp?: SandboxEgressHttpInterceptor;
+    tracePropagation?: SandboxEgressTracePropagationConfig;
 }
 /** Handles Vercel Sandbox firewall egress proxy requests. */
 export declare function ALL(request: Request, options?: SandboxEgressProxyOptions): Promise<Response>;

package/dist/handlers/webhooks.d.ts

@@ -1,4 +1,5 @@
 import type { SlackAdapter } from "@chat-adapter/slack";
+import { type SlackWebhookServices } from "@/chat/ingress/slack-webhook";
 import { JuniorChat } from "@/chat/ingress/junior-chat";
 import type { WaitUntilFn } from "@/handlers/types";
 type LegacyChatSdkBot = JuniorChat<{
@@ -10,8 +11,9 @@ type LegacyChatSdkBot = JuniorChat<{
  * Slack production ingress persists messages into the durable conversation
  * mailbox and wakes the queue worker. The optional `legacyBot` parameter is
  * kept for integration tests that still exercise Chat SDK fixtures directly.
+ * The optional `services` parameter carries app-scoped runtime services.
  */
-export declare function handlePlatformWebhook(request: Request, platform: string, waitUntil: WaitUntilFn, legacyBot?: LegacyChatSdkBot): Promise<Response>;
+export declare function handlePlatformWebhook(request: Request, platform: string, waitUntil: WaitUntilFn, legacyBot?: LegacyChatSdkBot, services?: SlackWebhookServices): Promise<Response>;
 /** Handle a platform webhook request from the app route. */
-export declare function POST(request: Request, platform: string, waitUntil: WaitUntilFn): Promise<Response>;
+export declare function POST(request: Request, platform: string, waitUntil: WaitUntilFn, services?: SlackWebhookServices): Promise<Response>;
 export {};