@mastra/factory 0.0.0-aggregate-trace-20261015182851

package/dist/integrations/slack/slack.js

@@ -0,0 +1,653 @@
+import { actorFromChannelAuthor } from "../../storage/domains/comments/actor.js";
+import { primeTenantCredentialsForRequestContext, primeTenantCredentialsForTenant } from "../../routes/tenant-credentials.js";
+import { readRequestContextOrgId, seedSessionOrg } from "../../session/org-seed.js";
+import { FactorySourceControlConflictError, createSourceControlSessionLookup, hydrateFactorySession, resolveFactorySessionModel, resolveFactorySourceControl, resolvePrimaryEnvironmentRepository } from "../../session/factory-session.js";
+import { prepareSessionRunContext } from "../subscription-session.js";
+import { resolveEmojiShortcodes } from "./emoji.js";
+import { slackCommentSource } from "./feed-publisher.js";
+import { ChannelSessionRejectedError } from "@mastra/core/channels";
+import { migratePersistedModelSelection } from "@mastra/core/agent-controller";
+import { createSlackAdapter } from "@mastra/slack";
+import { Actions, Card, CardText, LinkButton } from "chat";
+//#region src/integrations/slack/slack.ts
+const SLACK_REQUEST_TIMEOUT_MS = 15e3;
+var SlackSessionStartError = class extends Error {};
+function configuredSourceControls(deps) {
+	return deps.sourceControls ?? (deps.sourceControl ? [deps.sourceControl] : []);
+}
+/**
+* Read the Slack team id off a raw platform payload (Events API envelope or
+* slash-command body — both carry `team_id`), duck-typed to build the
+* workspace-scoped account-link key.
+*/
+function rawTeamId(rawPayload) {
+	if (!rawPayload || typeof rawPayload !== "object") return void 0;
+	const raw = rawPayload;
+	if (typeof raw.team_id === "string" && raw.team_id) return raw.team_id;
+	if (typeof raw.team === "string" && raw.team) return raw.team;
+	if (raw.team && typeof raw.team === "object") {
+		const id = raw.team.id;
+		if (typeof id === "string" && id) return id;
+	}
+}
+/**
+* The Slack team id survives onto a normalized chat Message only on
+* `message.raw` (the Slack Events API envelope).
+*/
+function slackTeamId(message) {
+	return rawTeamId(message.raw);
+}
+/**
+* Resolve the web-UI origin for links humans open in a browser (Connect card,
+* session deep links). Prefers `MASTRACODE_PUBLIC_URL` — the origin auth
+* cookies and OAuth redirect allow-lists are registered against — over the
+* channels tunnel, which only Slack's servers need to reach.
+*/
+function webPublicUrl() {
+	return process.env.MASTRACODE_PUBLIC_URL ?? process.env.MASTRACODE_CHANNELS_PUBLIC_URL;
+}
+/**
+* Resolve the sender's account link, posting an ephemeral "connect your
+* account" card (visible only to the sender) linking into the web UI's
+* Slack-connect flow when they're unlinked.
+*/
+async function resolveLinkedSender({ thread, message, accountLinks }) {
+	if (!accountLinks) return { status: "ungated" };
+	const platform = thread.adapter.name;
+	const externalUserId = message.author.userId;
+	const externalTeamId = slackTeamId(message);
+	const key = externalTeamId ? {
+		platform,
+		externalTeamId,
+		externalUserId
+	} : void 0;
+	const link = key ? await accountLinks.getAccountLink(key) : null;
+	if (link && key) return {
+		status: "linked",
+		link,
+		key
+	};
+	const publicUrl = webPublicUrl();
+	if (publicUrl) await thread.postEphemeral(message.author, buildConnectCard(publicUrl, thread), { fallbackToDM: true });
+	return { status: "blocked" };
+}
+const retryHint = (thread) => thread.isDM ? "message me again" : "mention me again";
+/**
+* The "connect your account" card. The link is deliberately identity-free —
+* `/connect/slack` sends the visitor to Connections, where "Connect Slack"
+* runs the OIDC flow and Slack itself asserts the (team, user) pair.
+*/
+function buildConnectCard(publicUrl, thread) {
+	return Card({
+		title: "Connect your account",
+		children: [CardText(`Connect your account to use this agent, then ${retryHint(thread)}.`), Actions([LinkButton({
+			url: `${publicUrl}/connect/slack`,
+			label: "Connect account"
+		})])]
+	});
+}
+/**
+* Decide which Factory project a linked sender's run belongs to:
+*
+* 1. The link's `defaultFactoryProjectId`, when it still exists (a stale id —
+*    deleted factory — falls through as if unset).
+* 2. Else, the tenant's only factory, stamped back onto the link so it shows
+*    up (and stays editable) in Connected Accounts settings.
+* 3. Else — zero or several factories — a "pick a default factory" card
+*    posted publicly in the thread so Slack notifies the sender, and the run is
+*    blocked.
+*/
+async function resolveFactoryForLink({ thread, link, key, accountLinks, projects }) {
+	if (!projects) return { status: "ungated" };
+	const orgId = link.orgId ?? "";
+	if (link.defaultFactoryProjectId) {
+		const existing = await projects.get({
+			orgId,
+			id: link.defaultFactoryProjectId
+		});
+		if (existing) return {
+			status: "resolved",
+			factoryProjectId: existing.id
+		};
+	}
+	const factories = orgId ? await projects.list({ orgId }) : [];
+	if (factories.length === 1) {
+		const only = factories[0];
+		await accountLinks.setDefaultFactory({
+			...key,
+			userId: link.userId,
+			factoryProjectId: only.id
+		});
+		return {
+			status: "resolved",
+			factoryProjectId: only.id
+		};
+	}
+	const publicUrl = webPublicUrl();
+	if (publicUrl) await thread.post(Card({
+		title: "Pick a default factory",
+		children: [CardText(factories.length === 0 ? `Your account has no factory yet. Create one in the web app, then ${retryHint(thread)}.` : `Your account has several factories. Pick which one Slack sessions should go to, then ${retryHint(thread)}.`), Actions([LinkButton({
+			url: `${publicUrl}/settings/connections`,
+			label: "Open settings"
+		})])]
+	}));
+	return { status: "blocked" };
+}
+/**
+* Deterministic per-thread branch name: `slack/{threadTs}` with characters
+* outside the sandbox git-ref allow-list (`[A-Za-z0-9_./-]`, and `.` for
+* readability) mapped to `-`. `thread.id` is `{channelId}:{threadTs}`
+* (platform-prefixed on handler threads) — the trailing segment is the ts.
+*
+* Top-level DM and channel conversations use the empty-threadTs thread form,
+* so the trailing segment can be empty; a bare `slack/` is not a valid git
+* ref. Fall back to the last non-empty segment (the channel id): one
+* deterministic branch per top-level conversation.
+*/
+function threadBranch(threadId) {
+	return `slack/${(threadId.split(":").findLast((segment) => segment.length > 0) ?? threadId).replace(/[^A-Za-z0-9_/-]/g, "-")}`;
+}
+/**
+* Resolve the resourceId for a NEW Slack channel thread. A linked sender whose
+* factory has a repository gets a Factory user-session id — the controller
+* session then materializes the repo sandbox via the factory's dynamic
+* workspace (clone + PAT), the session shows up in the web Sessions list, and
+* View Session deep-links land on the normal workspace route.
+*
+* A gated deployment refuses a thread it cannot place, rather than falling back
+* to a chat-only session: a repo-backed thread is the whole point of the
+* integration, and answering in a chat-only one would run the sender's request
+* in no project, on the SDK's built-in defaults. A linked sender whose project
+* cannot start a session gets an actionable error in Slack; the dispatch gate
+* handles unlinked or unrouted senders before this hook runs.
+* The hook only runs when a NEW thread is actually created (`getOrCreateThread`
+* resolves the owner lazily), so an established conversation is never touched:
+* it keeps its session, its model, and its history.
+*
+* The chat-only `channel:...` id survives for two cases where refusing would be
+* wrong: a deployment that cannot produce a repo-backed thread at all (no
+* account linking, no projects, or no source-control integration registered),
+* and a message carrying no sender id. In both, a `channel:` thread is the only
+* shape a session can take.
+*
+* Pure lookups only — cards for unlinked/unrouted senders are the dispatch
+* gate's job; this hook must never post.
+*/
+function createChannelResourceIdResolver(deps) {
+	const { accountLinks, projects } = deps;
+	const sourceControls = configuredSourceControls(deps);
+	return async ({ platform, thread, message }) => {
+		const chatOnlyResourceId = `channel:${thread.id}`;
+		if (!accountLinks || !projects || sourceControls.length === 0) return chatOnlyResourceId;
+		if (!message.author.userId) return chatOnlyResourceId;
+		const externalTeamId = rawTeamId(message.raw);
+		if (!externalTeamId) throw new ChannelSessionRejectedError("No Slack workspace id on the message — the sender cannot be identified");
+		try {
+			const link = await accountLinks.getAccountLink({
+				platform,
+				externalTeamId,
+				externalUserId: message.author.userId
+			});
+			if (!link) throw new ChannelSessionRejectedError(`Slack sender ${message.author.userId} is not linked to a Factory account`);
+			const orgId = link.orgId ?? "";
+			let factoryProjectId;
+			if (link.defaultFactoryProjectId && await projects.get({
+				orgId,
+				id: link.defaultFactoryProjectId
+			})) factoryProjectId = link.defaultFactoryProjectId;
+			else if (orgId) {
+				const factories = await projects.list({ orgId });
+				if (factories.length === 1) factoryProjectId = factories[0].id;
+			}
+			if (!factoryProjectId) throw new ChannelSessionRejectedError(`Linked Slack sender ${message.author.userId} has no Factory project`);
+			const sourceControl = await resolveFactorySourceControl({
+				sourceControls,
+				orgId,
+				factoryProjectId
+			});
+			if (!sourceControl) throw new SlackSessionStartError((await Promise.all(sourceControls.map((sourceControl) => sourceControl.connections.list({
+				orgId,
+				factoryProjectId
+			})))).some((rows) => rows.length > 0) ? "Could not start a session: link a repository to this Factory project." : "Could not start a session: connect source control to this Factory project.");
+			const repo = await resolvePrimaryEnvironmentRepository({
+				sourceControl,
+				orgId,
+				factoryProjectId
+			});
+			if (!repo.found) throw new SlackSessionStartError(repo.reason === "connection" ? "Could not start a session: connect source control to this Factory project." : "Could not start a session: link a repository to this Factory project.");
+			const branch = threadBranch(thread.id);
+			const existing = await sourceControl.sessions.getForBranch({
+				factoryProjectId,
+				userId: link.userId,
+				branch
+			});
+			if (existing) return existing.sessionId;
+			return (await sourceControl.sessions.create({
+				sessionId: globalThis.crypto.randomUUID(),
+				projectRepositoryId: repo.projectRepositoryId,
+				factoryProjectId,
+				orgId,
+				userId: link.userId,
+				branch,
+				baseBranch: repo.baseBranch,
+				visibility: thread.isDM ? "private" : "org"
+			})).sessionId;
+		} catch (error) {
+			if (error instanceof ChannelSessionRejectedError || error instanceof SlackSessionStartError) throw error;
+			if (error instanceof FactorySourceControlConflictError) throw new SlackSessionStartError("Could not start a session: this Factory project has repositories from more than one source-control provider.", { cause: error });
+			console.error("[slack] failed to start repo-backed session for thread", thread.id, error);
+			throw new SlackSessionStartError("Could not start a session right now. Please try again later.", { cause: error });
+		}
+	};
+}
+/**
+* Thread id for a NEW Slack channel thread. Repo-backed threads take the
+* user-session id AS their thread id, matching the web convention
+* (FactoryStartCoordinator seeds threads with threadId = sessionId) so
+* `/workspaces/{sessionId}/threads/{sessionId}` resolves Slack-created
+* sessions exactly like web-created ones — no `?resourceId=` override needed.
+* Chat-only threads keep the default random id: their `channel:...`
+* resourceId is a memory key, not a unique thread id.
+*/
+const resolveChannelThreadId = ({ resourceId, defaultThreadId }) => resourceId.startsWith("channel:") ? defaultThreadId : resourceId;
+/** Create channel sessions with their Factory ownership present in initial controller state. */
+function createChannelSessionResolver(deps) {
+	const sourceControlSessions = createSourceControlSessionLookup(configuredSourceControls(deps));
+	return async ({ controller, thread, requestContext }) => {
+		const sourceControl = thread.resourceId.startsWith("channel:") ? null : await sourceControlSessions.getSourceControlBySessionId(thread.resourceId);
+		const session = sourceControl ? await sourceControl.sessions.getBySessionId(thread.resourceId) : null;
+		return controller.createSession({
+			id: thread.resourceId,
+			ownerId: controller.id,
+			resourceId: thread.resourceId,
+			threadId: thread.id,
+			requestContext,
+			...session?.factoryProjectId ? { tags: { factoryProjectId: session.factoryProjectId } } : {}
+		});
+	};
+}
+/**
+* Apply the factory's configuration to a Slack-created session the first time
+* its thread reaches the controller.
+*
+* Without this a Slack session runs on the SDK's built-in mode default
+* (`openai/gpt-5.5`), so a factory configured for any other provider fails every
+* message with a missing-credentials error. The web kickoff has always applied
+* the factory default; this brings Slack to the same footing.
+*
+* Only repo-backed threads are configured. Their resourceId IS the Factory
+* session id, which the source-control rows turn back into a project — a
+* chat-only `channel:...` id names no project, so there is nothing to read.
+*
+* The model this session starts on is picked here, once, from the project's
+* effective model scope for a session: the Factory default or the durable session owner's
+* default, else the SDK's built-in model. The choice is persisted on the thread
+* as `currentModelId`, so it outlives the process that made it.
+*
+* The model resolution is skipped on a session that already has a model
+* persisted on the thread. That is the durable record of a deliberate choice —
+* either an earlier start or a user's own switch — and re-applying a preference
+* over it would undo the user's selection every time the process restarts.
+*/
+function createChannelSessionStartHook(deps) {
+	const { projects, modelDefaults } = deps;
+	const sourceControlSessions = createSourceControlSessionLookup(configuredSourceControls(deps));
+	return async ({ session, thread, requestContext }) => {
+		await seedSessionOrg(session, readRequestContextOrgId(requestContext));
+		if (!projects) return;
+		if (thread.resourceId.startsWith("channel:")) return;
+		const sourceControl = await sourceControlSessions.getSourceControlBySessionId(thread.resourceId);
+		if (!sourceControl) return;
+		const sourceSession = await sourceControl.sessions.getBySessionId(thread.resourceId);
+		if (!sourceSession?.factoryProjectId) return;
+		const threadId = session.thread.getId();
+		const binding = threadId && deps.workItems ? await deps.workItems.findRunBindingByThread({
+			orgId: sourceSession.orgId,
+			resourceId: thread.resourceId,
+			sessionId: thread.resourceId,
+			threadId,
+			rejectAmbiguous: true
+		}) : null;
+		const owner = {
+			factoryProjectId: binding?.factoryProjectId ?? sourceSession.factoryProjectId,
+			orgId: sourceSession.orgId,
+			userId: sourceSession.userId
+		};
+		const sessionModel = await resolveFactorySessionModel({
+			projects,
+			modelDefaults,
+			factoryProjectId: owner.factoryProjectId,
+			orgId: owner.orgId,
+			ownerUserId: owner.userId,
+			context: binding ? "run" : "session"
+		});
+		await session.state.set({
+			factoryProjectId: owner.factoryProjectId,
+			factoryModelScope: sessionModel.modelScope,
+			factoryOwnerUserId: owner.userId
+		});
+		await seedSessionOrg(session, owner.orgId);
+		await primeTenantCredentialsForTenant({
+			orgId: owner.orgId,
+			userId: owner.userId,
+			credentialScope: sessionModel.modelScope
+		});
+		const modeId = session.mode.get();
+		const activeThreadId = session.thread.getId();
+		if (await migratePersistedModelSelection({
+			getMetadata: async () => activeThreadId ? (await session.thread.getById({ threadId: activeThreadId }))?.metadata ?? {} : {},
+			modeId,
+			set: (key, value) => activeThreadId ? session.thread.setSettingOn({
+				threadId: activeThreadId,
+				key,
+				value
+			}) : Promise.resolve(),
+			threadId: activeThreadId ?? void 0
+		})) for (const agentType of SUBAGENT_TYPES) {
+			const modelId = await session.thread.getSetting({ key: pinnedSubagentModelKey(agentType) });
+			if (typeof modelId === "string") await applySubagentModel(session, agentType, modelId);
+		}
+		else {
+			await hydrateFactorySession(session, {
+				orgId: owner.orgId,
+				modelScope: sessionModel.modelScope,
+				ownerUserId: owner.userId,
+				defaultModelId: sessionModel.modelId
+			});
+			const selectedModelId = sessionModel.modelId ?? session.mode.resolve().defaultModelId ?? session.model.get();
+			for (const agentType of SUBAGENT_TYPES) {
+				if (!selectedModelId) continue;
+				if (await applySubagentModel(session, agentType, selectedModelId)) await session.thread.setSetting({
+					key: pinnedSubagentModelKey(agentType),
+					value: selectedModelId
+				});
+			}
+		}
+	};
+}
+const SUBAGENT_TYPES = [
+	"explore",
+	"plan",
+	"execute"
+];
+const pinnedSubagentModelKey = (agentType) => `slackSubagentModelId_${agentType}`;
+/** Best-effort: a subagent model that can't be applied must not fail the message. */
+async function applySubagentModel(session, agentType, modelId) {
+	try {
+		await session.subagents.model.set({
+			modelId,
+			agentType
+		});
+		return true;
+	} catch (error) {
+		console.warn("[slack] Failed to apply the subagent model", {
+			agentType,
+			modelId,
+			error: error instanceof Error ? error.message : String(error)
+		});
+		return false;
+	}
+}
+/**
+* The internal Mastra thread the framework created for a channel conversation.
+* The handler's `thread.id` is the platform thread id (e.g. `slack:C123:ts`),
+* NOT the internal UUID — the mapping lives in the stored thread's channel
+* metadata.
+*/
+async function findInternalThread(mastra, thread) {
+	const { threads } = await (await mastra?.getStorage()?.getStore("memory"))?.listThreads({
+		filter: { metadata: {
+			channel_platform: thread.adapter.name,
+			channel_externalThreadId: thread.id,
+			channel_externalChannelId: thread.channelId
+		} },
+		perPage: 1
+	}) ?? { threads: [] };
+	return threads[0];
+}
+async function prepareExistingSessionOwnerContext(thread, deps, ctx, options) {
+	const sourceControls = configuredSourceControls(deps);
+	if (sourceControls.length === 0 && !options.requireInternalThread) return "ready";
+	const internalThread = await findInternalThread(ctx.mastra, thread);
+	if (!internalThread) {
+		if (options.requireInternalThread) throw new Error(`Could not resolve the internal Slack thread for ${thread.id}.`);
+		return "ready";
+	}
+	if (sourceControls.length === 0 || internalThread.resourceId.startsWith("channel:")) return "ready";
+	if (!options.expectedOrgId) throw new Error(`Could not authorize the owner of Slack Factory session ${internalThread.resourceId}.`);
+	const preparation = await prepareSessionRunContext(ctx.requestContext, internalThread.resourceId, { sessions: createSourceControlSessionLookup(sourceControls) }, { expectedOrgId: options.expectedOrgId });
+	if (preparation === "organization-mismatch") return preparation;
+	if (preparation === "unavailable") throw new Error(`Could not authorize the owner of Slack Factory session ${internalThread.resourceId}.`);
+	return "ready";
+}
+/**
+* Build the "new session" handler for mention / direct-message events. A mention or
+* DM on a not-yet-subscribed thread starts a NEW session; once subscribed, later
+* events are follow-ups and don't re-announce.
+*/
+/**
+* Run the account-link + factory-routing gates for one inbound message.
+* Returns `null` when the run must not dispatch (a prompt card was posted
+* where possible); otherwise the dispatch context — with `routed` present
+* only when a linked sender resolved to a factory.
+*/
+async function gateDispatch(thread, message, deps, ctx, options = { requireInternalThread: false }) {
+	const { accountLinks, projects } = deps;
+	const sender = await resolveLinkedSender({
+		thread,
+		message,
+		accountLinks
+	});
+	if (sender.status === "blocked") return null;
+	if (sender.status === "linked" && accountLinks) {
+		ctx.requestContext.set("user", {
+			id: sender.link.userId,
+			organizationId: sender.link.orgId
+		});
+		if (await prepareExistingSessionOwnerContext(thread, deps, ctx, {
+			expectedOrgId: sender.link.orgId,
+			requireInternalThread: options.requireInternalThread
+		}) === "organization-mismatch") {
+			await thread.post("This thread belongs to a Factory session in another organization.");
+			return null;
+		}
+		await primeTenantCredentialsForRequestContext(ctx.requestContext);
+		const route = await resolveFactoryForLink({
+			thread,
+			...sender,
+			accountLinks,
+			projects
+		});
+		if (route.status === "blocked") return null;
+		if (route.status === "resolved") return { routed: {
+			link: sender.link,
+			factoryProjectId: route.factoryProjectId
+		} };
+	}
+	return {};
+}
+/**
+* A channel id and a `ts` name a thread only inside the workspace that issued
+* them, so the team scopes the card's key — without it two workspaces could
+* hold one key and an aside would land on another tenant's card.
+*/
+function slackThreadSource(thread, teamId) {
+	return {
+		integrationId: thread.adapter.name,
+		type: "slack-thread",
+		...teamId ? { workspaceId: teamId } : {},
+		externalId: thread.id
+	};
+}
+/** Cards written before the key carried a team are still keyed bare. */
+async function findThreadWorkItem(workItems, thread, teamId) {
+	const scoped = await workItems.getBySource(slackThreadSource(thread, teamId));
+	if (scoped || !teamId) return scoped;
+	return workItems.getBySource(slackThreadSource(thread));
+}
+function preDispatchErrorDetails(error) {
+	const readMessage = (value) => {
+		const message = typeof value === "string" ? value : value && typeof value === "object" && "message" in value ? value.message : void 0;
+		return typeof message === "string" && message.length > 0 ? message : void 0;
+	};
+	try {
+		const message = readMessage(error) ?? "Unknown error";
+		const cause = error && typeof error === "object" && "cause" in error ? readMessage(error.cause) : void 0;
+		return {
+			message,
+			...cause ? { cause: { message: cause } } : {}
+		};
+	} catch {
+		return { message: "Error details unavailable" };
+	}
+}
+async function reportPreDispatchError(thread, message, ctx, error) {
+	try {
+		if (error instanceof ChannelSessionRejectedError) return;
+	} catch {}
+	const correlation = {
+		platform: thread.adapter.name,
+		threadId: thread.id,
+		messageId: message.id,
+		authorId: message.author.userId
+	};
+	const logger = typeof ctx.mastra?.getLogger === "function" ? ctx.mastra.getLogger() : void 0;
+	const logError = (line) => logger ? logger.error(line) : console.error(line);
+	logError(`[slack] Pre-dispatch failure ${JSON.stringify({
+		...correlation,
+		error: preDispatchErrorDetails(error)
+	})}`);
+	try {
+		await thread.post(`Couldn’t start processing your message. Please try again.\n\`messageId: ${message.id}\``);
+	} catch (deliveryError) {
+		logError(`[slack] Failed to deliver pre-dispatch error reply ${JSON.stringify({
+			...correlation,
+			error: preDispatchErrorDetails(deliveryError)
+		})}`);
+	}
+}
+function createNewSessionChatHandler(deps) {
+	return async (thread, message, defaultHandler, ctx) => {
+		let gate;
+		let isNewSession;
+		try {
+			gate = await gateDispatch(thread, message, deps, ctx);
+			if (!gate) return;
+			isNewSession = !await thread.isSubscribed();
+		} catch (error) {
+			await reportPreDispatchError(thread, message, ctx, error);
+			return;
+		}
+		await defaultHandler(thread, message);
+		if (!isNewSession) return;
+		const internalThread = await findInternalThread(ctx.mastra, thread);
+		if (!internalThread) {
+			console.warn("[onMention] no internal thread found for", thread.id);
+			return;
+		}
+		const isChatOnly = internalThread.resourceId.startsWith("channel:");
+		const workspaceSegment = isChatOnly ? "channel" : encodeURIComponent(internalThread.resourceId);
+		const threadPath = gate.routed ? `/factories/${encodeURIComponent(gate.routed.factoryProjectId)}/workspaces/${workspaceSegment}/threads/${encodeURIComponent(internalThread.id)}` : `/threads/${internalThread.id}`;
+		const needsResourceParam = isChatOnly || !gate.routed;
+		const deepLink = process.env.MASTRACODE_PUBLIC_URL ? needsResourceParam ? `${process.env.MASTRACODE_PUBLIC_URL}${threadPath}?resourceId=${encodeURIComponent(internalThread.resourceId)}` : `${process.env.MASTRACODE_PUBLIC_URL}${threadPath}` : void 0;
+		if (!deepLink) return;
+		await thread.post(Card({
+			title: "New session started",
+			children: [Actions([LinkButton({
+				url: deepLink,
+				label: "View session"
+			})])]
+		}));
+	};
+}
+/**
+* An `aside` never reaches the agent, but it is still part of the conversation:
+* record it on the card the thread already has. The link is resolved here rather
+* than through `gateDispatch`, which posts a Connect card an aside must not
+* trigger. Best-effort — nothing here may surface in the Slack thread.
+*/
+async function ingestAside(thread, message, { feed, workItems, accountLinks }) {
+	if (!feed || !workItems) return;
+	const body = resolveEmojiShortcodes(message.text.replace(/^aside\b[,:]?\s*/i, "").trim());
+	if (!body) return;
+	try {
+		const teamId = slackTeamId(message);
+		const workItem = await findThreadWorkItem(workItems, thread, teamId);
+		if (!workItem) return;
+		const external = {
+			platform: thread.adapter.name,
+			...teamId ? { teamId } : {},
+			messageId: message.id,
+			userId: message.author.userId,
+			userName: message.author.userName,
+			fullName: message.author.fullName,
+			isBot: message.author.isBot
+		};
+		const link = accountLinks && teamId ? await accountLinks.getAccountLink({
+			platform: external.platform,
+			externalTeamId: teamId,
+			externalUserId: external.userId
+		}) : null;
+		const result = await feed.createComment({
+			orgId: workItem.orgId,
+			workItemId: workItem.id,
+			author: actorFromChannelAuthor(external, link),
+			body,
+			occurredAt: message.metadata.dateSent,
+			externalSource: slackCommentSource(thread.id, message.id, teamId)
+		});
+		if (result.status !== "created") console.warn("[slack] aside not ingested", {
+			thread: thread.id,
+			messageTs: message.id,
+			status: result.status
+		});
+	} catch (error) {
+		console.warn("[slack] aside ingest failed", {
+			thread: thread.id,
+			messageTs: message.id,
+			error
+		});
+	}
+}
+const createHandlers = (deps) => {
+	const newSessionChatHandler = createNewSessionChatHandler(deps);
+	return {
+		onSubscribedMessage: async (thread, message, defaultHandler, ctx) => {
+			if (/^aside\b/i.test(message.text)) return ingestAside(thread, message, deps);
+			try {
+				if (!await gateDispatch(thread, message, deps, ctx, { requireInternalThread: true })) return;
+			} catch (error) {
+				await reportPreDispatchError(thread, message, ctx, error);
+				return;
+			}
+			await defaultHandler(thread, message);
+		},
+		onMention: newSessionChatHandler,
+		onDirectMessage: newSessionChatHandler
+	};
+};
+function createSlackChannelsConfig(deps) {
+	const adapter = createSlackAdapter({
+		...deps.slack,
+		webClientOptions: { timeout: SLACK_REQUEST_TIMEOUT_MS }
+	});
+	return {
+		adapters: { slack: deps.adapterOptions?.streaming === false ? {
+			adapter,
+			...deps.adapterOptions
+		} : {
+			adapter,
+			...deps.adapterOptions,
+			streaming: deps.adapterOptions?.streaming ?? true
+		} },
+		handlers: createHandlers(deps),
+		resolveResourceId: createChannelResourceIdResolver(deps),
+		resolveThreadId: resolveChannelThreadId,
+		resolveSession: createChannelSessionResolver(deps),
+		onSessionStart: createChannelSessionStartHook(deps)
+	};
+}
+//#endregion
+export { createChannelResourceIdResolver, createChannelSessionResolver, createChannelSessionStartHook, createHandlers, createSlackChannelsConfig, resolveChannelThreadId, resolveFactoryForLink, resolveLinkedSender, slackThreadSource };
+
+//# sourceMappingURL=slack.js.map