@mastra/factory 0.24.0 → 0.25.0-alpha.1

package/dist/integrations/slack/channel-reply-processor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"channel-reply-processor.js","names":[],"sources":["../../../src/integrations/slack/channel-reply-processor.ts"],"sourcesContent":["import type { ProcessInputStepArgs, Processor } from '@mastra/core/processors';\n\n/** Mirrors `REPLY_TOOL_NAME` in `reply-tool.ts`, which imports this module. */\nconst REPLY_TOOL = 'reply_in_thread';\n\nconst ID = 'factory-channel-reply';\n\nexport const SESSION_LINK_LABEL = 'Open session ↗';\n\n/**\n * Tells the agent how to open a reply when the run came in over a chat\n * channel (Slack, …): acknowledge a job in one line that names it — \"On it —\n * sleeping 30s, then running the echo\" — before starting, so the sender sees\n * a task-specific first message rather than a silent typing status until the\n * first tool finishes. The channel driver posts that opener on its own before\n * the tool widget, so the instruction and the rendering agree. The session\n * link is not the model's job: `FactoryChannelSessionLinkProcessor` appends it\n * to the first reply of a new session, so it is there whether or not the\n * model judged the request worth an opener. A run on a Slack-linked session\n * that didn't start from Slack gets a shorter note on when to post there; runs\n * with no channel at all (Studio, API, boards) get nothing.\n */\nexport class FactoryChannelReplyProcessor implements Processor {\n  readonly id = ID;\n\n  processInputStep({ messageList, requestContext, tools }: ProcessInputStepArgs) {\n    if (!requestContext?.get('channel')) {\n      // A run on a Slack-linked session that didn't start from a Slack message\n      // (a web prompt, a woken run) still has the reply tool; core's channel\n      // prompt says the thread is linked, this says how to use it.\n      if (!tools || !(REPLY_TOOL in tools)) return undefined;\n      messageList.addSystem(\n        {\n          role: 'system',\n          content: `Post to that thread with \\`${REPLY_TOOL}\\`. This request came from outside it, so don't post an opener or progress there; post the outcome when the people in the thread asked for this work or are waiting on it, or when you're asked to. Don't write a note about what you posted.`,\n        },\n        ID,\n      );\n      return { messageList };\n    }\n    // With reply text hidden the thread only sees what the reply tool posts,\n    // so the opener advice becomes advice about when to call it.\n    const content =\n      tools && REPLY_TOOL in tools\n        ? [\n            `Only messages you send with \\`${REPLY_TOOL}\\` reach this thread; your other text stays in the session. Don't write a note about what you posted. After a reply, either keep working or end your turn with an empty message; any text you write after posting is wasted.`,\n            `When a request will take tools or more than a moment, post one short line first that says what you are about to do, then do the work and post the outcome when you finish — not a replay of the steps.`,\n            `Post again in between only when you need an answer or have news the people in the thread would want. When a message needs nothing from you, don't call it.`,\n          ]\n        : [\n            'When a request will take tools or more than a moment to answer, reply first with one short line that says what you are about to do — \"On it — <the task in a few words>.\" — then do the work; the opener posts as its own message before any progress is shown. Give direct answers and trivial replies without an opener.',\n            'Finish with the outcome, not a replay of the steps.',\n          ];\n    messageList.addSystem({ role: 'system', content: content.join('\\n') }, ID);\n    return { messageList };\n  }\n}\n\nexport interface SessionLinkTarget {\n  threadId: string;\n  sessionId: string;\n  resourceId: string;\n  factoryProjectId?: string;\n}\n\n/**\n * The web URL for a session, or undefined without a public origin. Same\n * routes the Factory UI navigates to: a repo-backed thread's Factory session\n * id is the workspace segment; chat-only threads keep the literal `channel`\n * segment and name their session in the query; a session with no factory\n * falls back to the factory-agnostic /threads/ redirect, which forwards the\n * query through.\n */\nexport function sessionLink({\n  threadId,\n  sessionId,\n  resourceId,\n  factoryProjectId,\n}: SessionLinkTarget): string | undefined {\n  const origin = process.env.MASTRACODE_PUBLIC_URL;\n  if (!origin) return undefined;\n  const isChatOnly = resourceId.startsWith('channel:');\n  const sessionParam = `?sessionId=${encodeURIComponent(sessionId)}`;\n  if (!factoryProjectId) return `${origin}/threads/${encodeURIComponent(threadId)}${sessionParam}`;\n  const workspaceSegment = isChatOnly ? 'channel' : encodeURIComponent(sessionId);\n  return `${origin}/factories/${encodeURIComponent(factoryProjectId)}/workspaces/${workspaceSegment}/threads/${encodeURIComponent(threadId)}${isChatOnly ? sessionParam : ''}`;\n}\n"],"mappings":";;AAGA,MAAM,aAAa;AAEnB,MAAM,KAAK;AAEX,MAAa,qBAAqB;;;;;;;;;;;;;;AAelC,IAAa,+BAAb,MAA+D;CAC7D,KAAc;CAEd,iBAAiB,EAAE,aAAa,gBAAgB,SAA+B;EAC7E,IAAI,CAAC,gBAAgB,IAAI,SAAS,GAAG;GAInC,IAAI,CAAC,SAAS,EAAE,cAAc,QAAQ,OAAO,KAAA;GAC7C,YAAY,UACV;IACE,MAAM;IACN,SAAS,8BAA8B,WAAW;GACpD,GACA,EACF;GACA,OAAO,EAAE,YAAY;EACvB;EAGA,MAAM,UACJ,SAAS,cAAc,QACnB;GACE,iCAAiC,WAAW;GAC5C;GACA;EACF,IACA,CACE,gUACA,qDACF;EACN,YAAY,UAAU;GAAE,MAAM;GAAU,SAAS,QAAQ,KAAK,IAAI;EAAE,GAAG,EAAE;EACzE,OAAO,EAAE,YAAY;CACvB;AACF;;;;;;;;;AAiBA,SAAgB,YAAY,EAC1B,UACA,WACA,YACA,oBACwC;CACxC,MAAM,SAAS,QAAQ,IAAI;CAC3B,IAAI,CAAC,QAAQ,OAAO,KAAA;CACpB,MAAM,aAAa,WAAW,WAAW,UAAU;CACnD,MAAM,eAAe,cAAc,mBAAmB,SAAS;CAC/D,IAAI,CAAC,kBAAkB,OAAO,GAAG,OAAO,WAAW,mBAAmB,QAAQ,IAAI;CAElF,OAAO,GAAG,OAAO,aAAa,mBAAmB,gBAAgB,EAAE,cAD1C,aAAa,YAAY,mBAAmB,SAAS,EACoB,WAAW,mBAAmB,QAAQ,IAAI,aAAa,eAAe;AAC1K"}

package/dist/integrations/slack/channel-session-link-processor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"channel-session-link-processor.d.ts","sourceRoot":"","sources":["../../../src/integrations/slack/channel-session-link-processor.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,qBAAqB,EAAE,uBAAuB,EAAE,MAAM,yBAAyB,CAAC;AACzG,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AACnE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAKrD;;;GAGG;AACH,eAAO,MAAM,uBAAuB,+BAA+B,CAAC;AAEpE,wBAAgB,qBAAqB,CAAC,cAAc,EAAE,cAAc,GAAG,IAAI,CAE1E;AAaD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,qBAAa,kCAAmC,YAAW,SAAS;IAClE,QAAQ,CAAC,EAAE,kCAAkC;IAEvC,mBAAmB,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,cAAc,EAAE,EAAE,uBAAuB,GAAG,OAAO,CAAC,SAAS,CAAC;IAmBvG,iBAAiB,CAAC,EAAE,WAAW,EAAE,cAAc,EAAE,EAAE,qBAAqB;CAiBzE"}

package/dist/{session → integrations/slack}/channel-session-link-processor.js

@@ -1,6 +1,7 @@
-import { readFactorySessionScope } from "../rules/binding-context.js";
+import { readFactorySessionScope } from "../../rules/binding-context.js";
 import { SESSION_LINK_LABEL, sessionLink } from "./channel-reply-processor.js";
-//#region src/session/channel-session-link-processor.ts
+import { CHAT_CHANNEL_RENDER_CONTEXT_KEY } from "@mastra/core/channels";
+//#region src/integrations/slack/channel-session-link-processor.ts
 /**
 * Request-context marker a channel handler sets on the run that opens a new
 * thread. Only that run gets the link; follow-ups in the same thread don't.
@@ -45,7 +46,7 @@ const LINK_PART_ID = "factory-session-link";
 var FactoryChannelSessionLinkProcessor = class {
 	id = "factory-channel-session-link";
 	async processOutputStream({ part, state, requestContext }) {
-		if (state.linked || !requestContext?.get("factory__newChannelSession")) return part;
+		if (state.linked || !linksThisRun(requestContext)) return part;
 		if (part.type === "text-delta") {
 			state.textStarted = true;
 			return part;
@@ -66,7 +67,7 @@ var FactoryChannelSessionLinkProcessor = class {
 		};
 	}
 	processOutputStep({ messageList, requestContext }) {
-		if (!requestContext?.get("factory__newChannelSession")) return messageList;
+		if (!linksThisRun(requestContext)) return messageList;
 		const link = sessionLinkFromRequest(requestContext);
 		if (!link) return messageList;
 		const suffix = linkSuffix(link);
@@ -81,6 +82,14 @@ var FactoryChannelSessionLinkProcessor = class {
 		return messageList;
 	}
 };
+/**
+* With reply text hidden the reply text never reaches the thread, and
+* `reply_in_thread` appends the link to its own first post instead.
+*/
+function linksThisRun(requestContext) {
+	if (!requestContext?.get("factory__newChannelSession")) return false;
+	return requestContext.get(CHAT_CHANNEL_RENDER_CONTEXT_KEY)?.textDisplay !== "hidden";
+}
 function linkSuffix(link) {
 	return `\n\n[${SESSION_LINK_LABEL}](${link})`;
 }

package/dist/integrations/slack/channel-session-link-processor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"channel-session-link-processor.js","names":[],"sources":["../../../src/integrations/slack/channel-session-link-processor.ts"],"sourcesContent":["import type { AgentControllerRequestContext } from '@mastra/core/agent-controller';\nimport { CHAT_CHANNEL_RENDER_CONTEXT_KEY } from '@mastra/core/channels';\nimport type { ChatChannelRenderContext } from '@mastra/core/channels';\nimport type { Processor, ProcessOutputStepArgs, ProcessOutputStreamArgs } from '@mastra/core/processors';\nimport type { RequestContext } from '@mastra/core/request-context';\nimport type { ChunkType } from '@mastra/core/stream';\n\nimport { readFactorySessionScope } from '../../rules/binding-context.js';\nimport { SESSION_LINK_LABEL, sessionLink } from './channel-reply-processor.js';\n\n/**\n * Request-context marker a channel handler sets on the run that opens a new\n * thread. Only that run gets the link; follow-ups in the same thread don't.\n */\nexport const NEW_CHANNEL_SESSION_KEY = 'factory__newChannelSession';\n\nexport function markNewChannelSession(requestContext: RequestContext): void {\n  requestContext.set(NEW_CHANNEL_SESSION_KEY, true);\n}\n\n/**\n * State key the core ProcessorRunner reads to re-drive one extra part through\n * the output chain after the part a processor returned. Internal to core\n * (`processors/stream-reprocess.ts`, used by `BatchPartsProcessor`); mirrored\n * here rather than exported so Factory's one use doesn't widen core's API.\n */\nconst REPROCESS_PART_KEY = '__mastraReprocessPart';\n\n/** Text-part id of the link delta; never collides with a model block id. */\nconst LINK_PART_ID = 'factory-session-link';\n\n/**\n * Emits an `Open session ↗` link right after the first reply of a new channel\n * session, so the link closes the reply rather than leading it. The channel\n * driver ends a post at `text-end`, so Slack shows the link as its own short\n * message after the reply.\n *\n * \"End of the reply\" is not `text-end`: a reply with citations is several\n * text blocks (`text … source … text`), each with its own `text-end`. The\n * reply ends at the first `tool-call` (the opener before tools run) or at\n * `step-finish` (a reply with no tools), whichever comes first after some\n * text. A processor can only return one part, so on that chunk this returns\n * a `text-delta` carrying the link and stashes the chunk itself under\n * `REPROCESS_PART_KEY`, which the runner re-drives through the chain right\n * after — the link lands before it and downstream processors see both.\n * Factory-emitted rather than left to the model so a skipped opener can't\n * drop it. No-op without the new-session marker or a public origin.\n *\n * The streamed text is also what gets persisted, and the link is a Slack\n * display detail: in memory it would show the model its own `[↗](…)` on\n * later turns (inviting it to fabricate links) and render a self-link in\n * the web transcript. The link delta opens its own text part, so\n * `processOutputStep` drops that part from the assistant message before\n * `MessageHistory` saves it.\n */\nexport class FactoryChannelSessionLinkProcessor implements Processor {\n  readonly id = 'factory-channel-session-link';\n\n  async processOutputStream({ part, state, requestContext }: ProcessOutputStreamArgs): Promise<ChunkType> {\n    if (state.linked || !linksThisRun(requestContext)) return part;\n    if (part.type === 'text-delta') {\n      state.textStarted = true;\n      return part;\n    }\n    if ((part.type !== 'tool-call' && part.type !== 'step-finish') || !state.textStarted) return part;\n    state.linked = true;\n    const link = sessionLinkFromRequest(requestContext);\n    if (!link) return part;\n    state[REPROCESS_PART_KEY] = part;\n    return {\n      type: 'text-delta',\n      runId: part.runId,\n      from: part.from,\n      payload: { id: LINK_PART_ID, text: linkSuffix(link) },\n    };\n  }\n\n  processOutputStep({ messageList, requestContext }: ProcessOutputStepArgs) {\n    if (!linksThisRun(requestContext)) return messageList;\n    const link = sessionLinkFromRequest(requestContext);\n    if (!link) return messageList;\n    const suffix = linkSuffix(link);\n    for (const message of messageList.get.response.db()) {\n      if (message.role !== 'assistant') continue;\n      const index = message.content.parts.findIndex(part => part.type === 'text' && part.text === suffix);\n      if (index === -1) continue;\n      message.content.parts.splice(index, 1);\n      if (typeof message.content.content === 'string' && message.content.content.endsWith(suffix)) {\n        message.content.content = message.content.content.slice(0, -suffix.length);\n      }\n      return messageList;\n    }\n    return messageList;\n  }\n}\n\n/**\n * With reply text hidden the reply text never reaches the thread, and\n * `reply_in_thread` appends the link to its own first post instead.\n */\nfunction linksThisRun(requestContext: RequestContext | undefined): requestContext is RequestContext {\n  if (!requestContext?.get(NEW_CHANNEL_SESSION_KEY)) return false;\n  const render = requestContext.get(CHAT_CHANNEL_RENDER_CONTEXT_KEY) as ChatChannelRenderContext | undefined;\n  return render?.textDisplay !== 'hidden';\n}\n\nfunction linkSuffix(link: string): string {\n  // Own paragraph: the link closes the message, it is not part of the last sentence.\n  return `\\n\\n[${SESSION_LINK_LABEL}](${link})`;\n}\n\nfunction sessionLinkFromRequest(requestContext: RequestContext): string | undefined {\n  const controller = requestContext.get('controller') as AgentControllerRequestContext | undefined;\n  if (!controller?.threadId) return undefined;\n  return sessionLink({\n    threadId: controller.threadId,\n    sessionId: controller.sessionId,\n    resourceId: controller.resourceId,\n    factoryProjectId: readFactorySessionScope(requestContext)?.factoryProjectId,\n  });\n}\n"],"mappings":";;;;;;;;AAcA,MAAa,0BAA0B;AAEvC,SAAgB,sBAAsB,gBAAsC;CAC1E,eAAe,IAAI,yBAAyB,IAAI;AAClD;;;;;;;AAQA,MAAM,qBAAqB;;AAG3B,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;AA0BrB,IAAa,qCAAb,MAAqE;CACnE,KAAc;CAEd,MAAM,oBAAoB,EAAE,MAAM,OAAO,kBAA+D;EACtG,IAAI,MAAM,UAAU,CAAC,aAAa,cAAc,GAAG,OAAO;EAC1D,IAAI,KAAK,SAAS,cAAc;GAC9B,MAAM,cAAc;GACpB,OAAO;EACT;EACA,IAAK,KAAK,SAAS,eAAe,KAAK,SAAS,iBAAkB,CAAC,MAAM,aAAa,OAAO;EAC7F,MAAM,SAAS;EACf,MAAM,OAAO,uBAAuB,cAAc;EAClD,IAAI,CAAC,MAAM,OAAO;EAClB,MAAM,sBAAsB;EAC5B,OAAO;GACL,MAAM;GACN,OAAO,KAAK;GACZ,MAAM,KAAK;GACX,SAAS;IAAE,IAAI;IAAc,MAAM,WAAW,IAAI;GAAE;EACtD;CACF;CAEA,kBAAkB,EAAE,aAAa,kBAAyC;EACxE,IAAI,CAAC,aAAa,cAAc,GAAG,OAAO;EAC1C,MAAM,OAAO,uBAAuB,cAAc;EAClD,IAAI,CAAC,MAAM,OAAO;EAClB,MAAM,SAAS,WAAW,IAAI;EAC9B,KAAK,MAAM,WAAW,YAAY,IAAI,SAAS,GAAG,GAAG;GACnD,IAAI,QAAQ,SAAS,aAAa;GAClC,MAAM,QAAQ,QAAQ,QAAQ,MAAM,WAAU,SAAQ,KAAK,SAAS,UAAU,KAAK,SAAS,MAAM;GAClG,IAAI,UAAU,IAAI;GAClB,QAAQ,QAAQ,MAAM,OAAO,OAAO,CAAC;GACrC,IAAI,OAAO,QAAQ,QAAQ,YAAY,YAAY,QAAQ,QAAQ,QAAQ,SAAS,MAAM,GACxF,QAAQ,QAAQ,UAAU,QAAQ,QAAQ,QAAQ,MAAM,GAAG,CAAC,OAAO,MAAM;GAE3E,OAAO;EACT;EACA,OAAO;CACT;AACF;;;;;AAMA,SAAS,aAAa,gBAA8E;CAClG,IAAI,CAAC,gBAAgB,IAAA,4BAA2B,GAAG,OAAO;CAE1D,OADe,eAAe,IAAI,+BACtB,CAAC,EAAE,gBAAgB;AACjC;AAEA,SAAS,WAAW,MAAsB;CAExC,OAAO,QAAQ,mBAAmB,IAAI,KAAK;AAC7C;AAEA,SAAS,uBAAuB,gBAAoD;CAClF,MAAM,aAAa,eAAe,IAAI,YAAY;CAClD,IAAI,CAAC,YAAY,UAAU,OAAO,KAAA;CAClC,OAAO,YAAY;EACjB,UAAU,WAAW;EACrB,WAAW,WAAW;EACtB,YAAY,WAAW;EACvB,kBAAkB,wBAAwB,cAAc,CAAC,EAAE;CAC7D,CAAC;AACH"}

package/dist/integrations/slack/integration.d.ts

@@ -17,10 +17,13 @@
  * of the box). The integration interface remains open — third parties still add
  * capabilities by implementing `FactoryIntegration` from outside the package.
  */
+import type { AgentChannels } from '@mastra/core/channels';
+import type { InputProcessor, OutputProcessor } from '@mastra/core/processors';
+import type { RequestContext } from '@mastra/core/request-context';
 import type { ApiRoute } from '@mastra/core/server';
 import type { SlackAdapterChannelConfig } from '@mastra/slack';
 import type { WorkItemFeedPublisher } from '../../storage/domains/comments/feed-sync.js';
-import type { FactoryChannelsConfig, FactoryIntegration, IntegrationContext } from '../base.js';
+import type { FactoryChannelsConfig, FactoryIntegration, IntegrationContext, IntegrationTools } from '../base.js';
 /**
  * Slack app credentials, read from env ONCE by the deploy entry. `signingSecret`
  * is required because the Slack adapter validates it at construction — an
@@ -71,7 +74,28 @@ export declare class SlackIntegration implements FactoryIntegration {
      * replica signed.
      */
     readonly requiresStableStateSigner = true;
+    /**
+     * With reply text hidden (the Factory default) the agent speaks through
+     * `reply_in_thread`, so the prompt, reminder and live streaming for that
+     * tool come with it. The setting is fixed for the deployment, so it is
+     * decided once here rather than on every run.
+     */
+    readonly processors: {
+        input: InputProcessor[];
+        output: OutputProcessor[];
+    };
     constructor(config: SlackIntegrationConfig);
+    initialize(args: {
+        channels?: () => AgentChannels | null | undefined;
+    }): void;
+    /**
+     * `attach_file`, and `reply_in_thread` when reply text is hidden, on runs
+     * whose session is linked to a Slack thread. The tools find the thread to
+     * post into when they are called.
+     */
+    agentTools({ requestContext }: {
+        requestContext: RequestContext;
+    }): Promise<IntegrationTools>;
     channels(ctx: IntegrationContext): FactoryChannelsConfig;
     feedPublisher(ctx: IntegrationContext): WorkItemFeedPublisher;
     routes(ctx: IntegrationContext): ApiRoute[];

package/dist/integrations/slack/integration.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"integration.d.ts","sourceRoot":"","sources":["../../../src/integrations/slack/integration.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAGH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,eAAe,CAAC;AAE/D,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,6CAA6C,CAAC;AACzF,OAAO,KAAK,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAMhG;;;;;GAKG;AACH,MAAM,WAAW,sBAAsB;IACrC,2DAA2D;IAC3D,aAAa,EAAE,MAAM,CAAC;IACtB,0DAA0D;IAC1D,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;OAGG;IACH,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,uDAAuD;IACvD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;;;;;;;;;;;OAaG;IACH,cAAc,CAAC,EAAE,yBAAyB,CAAC;CAC5C;AA4DD,qBAAa,gBAAiB,YAAW,kBAAkB;;IACzD,QAAQ,CAAC,EAAE,WAAW;IACtB;;;;OAIG;IACH,QAAQ,CAAC,yBAAyB,QAAQ;gBAU9B,MAAM,EAAE,sBAAsB;IAS1C,QAAQ,CAAC,GAAG,EAAE,kBAAkB,GAAG,qBAAqB;IAuBxD,aAAa,CAAC,GAAG,EAAE,kBAAkB,GAAG,qBAAqB;IAI7D,MAAM,CAAC,GAAG,EAAE,kBAAkB,GAAG,QAAQ,EAAE;IAc3C,WAAW,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CASvC"}
+{"version":3,"file":"integration.d.ts","sourceRoot":"","sources":["../../../src/integrations/slack/integration.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAkB,MAAM,uBAAuB,CAAC;AAC3E,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAC/E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AACnE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,eAAe,CAAC;AAE/D,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,6CAA6C,CAAC;AAEzF,OAAO,KAAK,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAWlH;;;;;GAKG;AACH,MAAM,WAAW,sBAAsB;IACrC,2DAA2D;IAC3D,aAAa,EAAE,MAAM,CAAC;IACtB,0DAA0D;IAC1D,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;OAGG;IACH,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,uDAAuD;IACvD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;;;;;;;;;;;OAaG;IACH,cAAc,CAAC,EAAE,yBAAyB,CAAC;CAC5C;AAyED,qBAAa,gBAAiB,YAAW,kBAAkB;;IACzD,QAAQ,CAAC,EAAE,WAAW;IACtB;;;;OAIG;IACH,QAAQ,CAAC,yBAAyB,QAAQ;IAO1C;;;;;OAKG;IACH,QAAQ,CAAC,UAAU,EAAE;QAAE,KAAK,EAAE,cAAc,EAAE,CAAC;QAAC,MAAM,EAAE,eAAe,EAAE,CAAA;KAAE,CAAC;gBAQhE,MAAM,EAAE,sBAAsB;IAyB1C,UAAU,CAAC,IAAI,EAAE;QAAE,QAAQ,CAAC,EAAE,MAAM,aAAa,GAAG,IAAI,GAAG,SAAS,CAAA;KAAE,GAAG,IAAI;IAI7E;;;;OAIG;IACG,UAAU,CAAC,EAAE,cAAc,EAAE,EAAE;QAAE,cAAc,EAAE,cAAc,CAAA;KAAE,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAQnG,QAAQ,CAAC,GAAG,EAAE,kBAAkB,GAAG,qBAAqB;IAuBxD,aAAa,CAAC,GAAG,EAAE,kBAAkB,GAAG,qBAAqB;IAI7D,MAAM,CAAC,GAAG,EAAE,kBAAkB,GAAG,QAAQ,EAAE;IAc3C,WAAW,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CASvC"}

package/dist/integrations/slack/integration.js

@@ -1,5 +1,10 @@
+import { FactoryChannelReplyProcessor } from "./channel-reply-processor.js";
+import { FactoryChannelSessionLinkProcessor } from "./channel-session-link-processor.js";
 import { createSlackConnectRoutes } from "./connect-route.js";
 import { SlackFeedPublisher } from "./feed-publisher.js";
+import { createShareFileTool, isSlackThread } from "./share-file-tool.js";
+import { FactoryReplyStreamProcessor, createReplyTool } from "./reply-tool.js";
+import { FactoryReplyReminderProcessor } from "./reply-reminder-processor.js";
 import { createSlackChannelsConfig } from "./slack.js";
 //#region src/integrations/slack/integration.ts
 /** Slack renders the status inline next to the app name; keep it to one short line. */
@@ -18,11 +23,19 @@ function describeToolCall(args) {
 	const text = line.length > MAX_STATUS_LENGTH ? `${line.slice(0, 79)}…` : line;
 	return `is ${/^[A-Z][a-z]/.test(text) ? text.charAt(0).toLowerCase() + text.slice(1) : text}`;
 }
-const factoryTypingStatus = (chunk) => {
+/**
+* With reply text hidden, streamed text never reaches the thread, so it gets
+* no status: an "is typing..." set after the reply tool's post would sit on
+* the thread with nothing coming, and race the clear at the end of the run.
+*/
+const factoryTypingStatus = (textDisplay) => (chunk) => {
 	switch (chunk.type) {
 		case "reasoning-delta": return "is thinking...";
-		case "text-delta": return "is typing...";
-		case "tool-call": return describeToolCall(chunk.payload.args) ?? "is working...";
+		case "text-delta": return textDisplay === "hidden" ? void 0 : "is typing...";
+		case "tool-call-input-streaming-start": return chunk.payload.toolName === "reply_in_thread" ? "is typing..." : void 0;
+		case "tool-call":
+			if (chunk.payload.toolName === "reply_in_thread") return "is typing...";
+			return describeToolCall(chunk.payload.args) ?? "is working...";
 		default: return;
 	}
 };
@@ -42,9 +55,11 @@ function adapterOverrides(options) {
 * who want Slack's "Thinking Steps" widget.
 */
 function factoryAdapterOptions(overrides) {
+	const textDisplay = overrides.textDisplay ?? "hidden";
 	return {
-		typingStatus: factoryTypingStatus,
+		typingStatus: factoryTypingStatus(textDisplay),
 		toolDisplay: "hidden",
+		textDisplay,
 		...overrides
 	};
 }
@@ -57,6 +72,17 @@ var SlackIntegration = class {
 	*/
 	requiresStableStateSigner = true;
 	#config;
+	#adapterOptions;
+	/** Bound in `initialize()`; the controller mounts after integrations are built. */
+	#channels;
+	#deps = { channels: () => this.#channels?.() };
+	/**
+	* With reply text hidden (the Factory default) the agent speaks through
+	* `reply_in_thread`, so the prompt, reminder and live streaming for that
+	* tool come with it. The setting is fixed for the deployment, so it is
+	* decided once here rather than on every run.
+	*/
+	processors;
 	/**
 	* Whether `channels()` found a source-control owner on the context and wired
 	* repo-backed sessions. Set at the channels() attach path, which runs once at
@@ -66,6 +92,30 @@ var SlackIntegration = class {
 	constructor(config) {
 		if (!config.signingSecret) throw new Error("SlackIntegration: 'signingSecret' is required — Slack cannot verify inbound requests without it.");
 		this.#config = config;
+		this.#adapterOptions = factoryAdapterOptions(adapterOverrides(config.adapterOptions));
+		const textHidden = this.#textHidden;
+		this.processors = {
+			input: [new FactoryChannelReplyProcessor(), ...textHidden ? [new FactoryReplyReminderProcessor()] : []],
+			output: [new FactoryChannelSessionLinkProcessor(), ...textHidden ? [new FactoryReplyStreamProcessor(this.#deps)] : []]
+		};
+	}
+	get #textHidden() {
+		return this.#adapterOptions.textDisplay === "hidden";
+	}
+	initialize(args) {
+		this.#channels = args.channels;
+	}
+	/**
+	* `attach_file`, and `reply_in_thread` when reply text is hidden, on runs
+	* whose session is linked to a Slack thread. The tools find the thread to
+	* post into when they are called.
+	*/
+	async agentTools({ requestContext }) {
+		if (!await isSlackThread(requestContext, this.#deps)) return {};
+		return {
+			...createShareFileTool(requestContext, this.#deps),
+			...this.#textHidden ? createReplyTool(requestContext, this.#deps) : {}
+		};
 	}
 	channels(ctx) {
 		const sourceControls = ctx.storage.sourceControls ?? (ctx.storage.sourceControlOwner ? [ctx.storage.sourceControlOwner] : []);
@@ -83,7 +133,7 @@ var SlackIntegration = class {
 			modelDefaults: ctx.storage.modelDefaults,
 			workItems: ctx.runtime?.workItems,
 			feed: ctx.feed,
-			adapterOptions: factoryAdapterOptions(adapterOverrides(this.#config.adapterOptions))
+			adapterOptions: this.#adapterOptions
 		});
 	}
 	feedPublisher(ctx) {

package/dist/integrations/slack/integration.js.map

@@ -1 +1 @@
-{"version":3,"file":"integration.js","names":[],"sources":["../../../src/integrations/slack/integration.ts"],"sourcesContent":["/**\n * `SlackIntegration` — Slack as a `FactoryIntegration`.\n *\n * Slack contributes two things to a factory: the chat channels that carry\n * inbound messages into agent runs (`channels()`), and the browser-facing\n * account-link routes that bind a Slack sender to a Mastra tenant (`routes()`).\n * Both used to be assembled by hand in the deploy entry, which had to reach\n * into the prepared agent controller by string key, resolve storage domains\n * itself, mint its own state signer, and splice routes onto the factory's\n * assembled server config. Implementing the integration interface instead means\n * the factory does all of that the same way it already does for GitHub and\n * Linear, and the entry's job shrinks to reading Slack's env vars once.\n *\n * Slack ships as a factory built-in alongside GitHub and Linear (it originally\n * lived in `mastracode/web` to keep `@mastra/slack`/`chat` out of this package;\n * the team reversed that so `create-factory` consumers get Slack channels out\n * of the box). The integration interface remains open — third parties still add\n * capabilities by implementing `FactoryIntegration` from outside the package.\n */\n\nimport type { TypingStatusFn } from '@mastra/core/channels';\nimport type { ApiRoute } from '@mastra/core/server';\nimport type { SlackAdapterChannelConfig } from '@mastra/slack';\n\nimport type { WorkItemFeedPublisher } from '../../storage/domains/comments/feed-sync.js';\nimport type { FactoryChannelsConfig, FactoryIntegration, IntegrationContext } from '../base.js';\n\nimport { createSlackConnectRoutes } from './connect-route.js';\nimport { SlackFeedPublisher } from './feed-publisher.js';\nimport { createSlackChannelsConfig } from './slack.js';\n\n/**\n * Slack app credentials, read from env ONCE by the deploy entry. `signingSecret`\n * is required because the Slack adapter validates it at construction — an\n * integration constructed without it would throw during `prepare()` rather than\n * reporting itself unconfigured.\n */\nexport interface SlackIntegrationConfig {\n  /** Verifies inbound Slack request signatures. Required. */\n  signingSecret: string;\n  /** Bot token used to post replies and ephemeral cards. */\n  botToken?: string;\n  /**\n   * OAuth client credentials. Required for account linking: \"Sign in with\n   * Slack\" (OIDC) is the only flow that writes a link, so without these the\n   * settings surface reports `canConnect: false` and no sender can link.\n   */\n  clientId?: string;\n  clientSecret?: string;\n  /**\n   * HTTPS origin Slack redirects back to. Slack requires HTTPS, so locally this\n   * is the tunnel origin rather than the app's own public URL.\n   */\n  oidcRedirectBaseUrl?: string;\n  /** SPA origin the post-connect redirect returns to. */\n  uiOrigin?: string;\n  /**\n   * Overrides for the Slack channel adapter entry.\n   *\n   * @example\n   * ```ts\n   * new SlackIntegration({\n   *   signingSecret,\n   *   adapterOptions: {\n   *     streaming: true,\n   *     toolDisplay: 'grouped',\n   *   },\n   * });\n   * ```\n   */\n  adapterOptions?: SlackAdapterChannelConfig;\n}\n\n/** Slack renders the status inline next to the app name; keep it to one short line. */\nconst MAX_STATUS_LENGTH = 80;\n\n/**\n * Turns a tool's `description` arg (\"Listing the repo root\") into a status\n * line that reads after the app name (\"<App> is listing the repo root…\").\n * Only the first line counts: issue/PR creators carry whole bodies there.\n */\nfunction describeToolCall(args: unknown): string | undefined {\n  if (!args || typeof args !== 'object') return undefined;\n  const { description } = args as { description?: unknown };\n  if (typeof description !== 'string') return undefined;\n  const line = description\n    .split('\\n')\n    .map(part => part.replace(/\\s+/g, ' ').trim())\n    .find(Boolean);\n  if (!line) return undefined;\n  const text = line.length > MAX_STATUS_LENGTH ? `${line.slice(0, MAX_STATUS_LENGTH - 1)}…` : line;\n  // Drop the sentence-case capital (\"Listing\" → \"listing\") but leave acronyms\n  // and identifiers (\"PR lookup\", \"CI status\") alone.\n  return `is ${/^[A-Z][a-z]/.test(text) ? text.charAt(0).toLowerCase() + text.slice(1) : text}`;\n}\n\nconst factoryTypingStatus: TypingStatusFn = chunk => {\n  switch (chunk.type) {\n    case 'reasoning-delta':\n      return 'is thinking...';\n    case 'text-delta':\n      return 'is typing...';\n    case 'tool-call':\n      return describeToolCall(chunk.payload.args) ?? 'is working...';\n    default:\n      return undefined;\n  }\n};\n\n/**\n * Drops keys the caller set to `undefined` so spreading the overrides cannot\n * erase the Factory defaults they sit on top of.\n */\nfunction adapterOverrides(options: SlackAdapterChannelConfig | undefined): SlackAdapterChannelConfig {\n  return Object.fromEntries(\n    Object.entries(options ?? {}).filter(([, value]) => value !== undefined),\n  ) as SlackAdapterChannelConfig;\n}\n\n/**\n * Factory defaults under the caller's overrides. Tool calls stay out of the\n * thread: a Factory session runs hundreds of them, and a row per call (or a\n * card per call) buries the reply. Progress shows through the typing status\n * instead, which names the tool's current step; the session link carries the\n * full trace. `grouped` remains available via `adapterOptions` for callers\n * who want Slack's \"Thinking Steps\" widget.\n */\nfunction factoryAdapterOptions(overrides: SlackAdapterChannelConfig): SlackAdapterChannelConfig {\n  return { typingStatus: factoryTypingStatus, toolDisplay: 'hidden', ...overrides };\n}\n\nexport class SlackIntegration implements FactoryIntegration {\n  readonly id = 'slack';\n  /**\n   * The OIDC connect flow round-trips a signed `state` through Slack, so the\n   * replica handling the callback must be able to verify a state a different\n   * replica signed.\n   */\n  readonly requiresStableStateSigner = true;\n\n  readonly #config: SlackIntegrationConfig;\n  /**\n   * Whether `channels()` found a source-control owner on the context and wired\n   * repo-backed sessions. Set at the channels() attach path, which runs once at\n   * boot before diagnostics are served.\n   */\n  #repoBackedSessions = false;\n\n  constructor(config: SlackIntegrationConfig) {\n    if (!config.signingSecret) {\n      throw new Error(\n        \"SlackIntegration: 'signingSecret' is required — Slack cannot verify inbound requests without it.\",\n      );\n    }\n    this.#config = config;\n  }\n\n  channels(ctx: IntegrationContext): FactoryChannelsConfig {\n    // Repo-backed sessions select the source-control provider from the linked\n    // repository on each Factory project.\n    const sourceControls =\n      ctx.storage.sourceControls ?? (ctx.storage.sourceControlOwner ? [ctx.storage.sourceControlOwner] : []);\n    this.#repoBackedSessions = sourceControls.length > 0;\n    return createSlackChannelsConfig({\n      slack: {\n        clientId: this.#config.clientId,\n        clientSecret: this.#config.clientSecret,\n        signingSecret: this.#config.signingSecret,\n        botToken: this.#config.botToken,\n      },\n      accountLinks: ctx.storage.channelIdentity,\n      projects: ctx.storage.projects,\n      sourceControls,\n      modelDefaults: ctx.storage.modelDefaults,\n      workItems: ctx.runtime?.workItems,\n      feed: ctx.feed,\n      adapterOptions: factoryAdapterOptions(adapterOverrides(this.#config.adapterOptions)),\n    });\n  }\n\n  feedPublisher(ctx: IntegrationContext): WorkItemFeedPublisher {\n    return new SlackFeedPublisher({ controller: ctx.controller });\n  }\n\n  routes(ctx: IntegrationContext): ApiRoute[] {\n    const { clientId, clientSecret, oidcRedirectBaseUrl, uiOrigin } = this.#config;\n    return createSlackConnectRoutes({\n      auth: ctx.auth,\n      accountLinks: ctx.storage.channelIdentity,\n      tenantStateSigner: ctx.stateSigner,\n      oidc:\n        clientId && clientSecret && oidcRedirectBaseUrl\n          ? { clientId, clientSecret, redirectBaseUrl: oidcRedirectBaseUrl, uiOrigin }\n          : undefined,\n      projects: ctx.storage.projects,\n    });\n  }\n\n  diagnostics(): Record<string, unknown> {\n    const { clientId, clientSecret, botToken, oidcRedirectBaseUrl } = this.#config;\n    return {\n      configured: true,\n      botTokenConfigured: Boolean(botToken),\n      oidcConfigured: Boolean(clientId && clientSecret && oidcRedirectBaseUrl),\n      repoBackedSessions: this.#repoBackedSessions,\n    };\n  }\n}\n"],"mappings":";;;;;AA0EA,MAAM,oBAAoB;;;;;;AAO1B,SAAS,iBAAiB,MAAmC;CAC3D,IAAI,CAAC,QAAQ,OAAO,SAAS,UAAU,OAAO,KAAA;CAC9C,MAAM,EAAE,gBAAgB;CACxB,IAAI,OAAO,gBAAgB,UAAU,OAAO,KAAA;CAC5C,MAAM,OAAO,YACV,MAAM,IAAI,CAAC,CACX,KAAI,SAAQ,KAAK,QAAQ,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAC7C,KAAK,OAAO;CACf,IAAI,CAAC,MAAM,OAAO,KAAA;CAClB,MAAM,OAAO,KAAK,SAAS,oBAAoB,GAAG,KAAK,MAAM,GAAG,EAAqB,EAAE,KAAK;CAG5F,OAAO,MAAM,cAAc,KAAK,IAAI,IAAI,KAAK,OAAO,CAAC,CAAC,CAAC,YAAY,IAAI,KAAK,MAAM,CAAC,IAAI;AACzF;AAEA,MAAM,uBAAsC,UAAS;CACnD,QAAQ,MAAM,MAAd;EACE,KAAK,mBACH,OAAO;EACT,KAAK,cACH,OAAO;EACT,KAAK,aACH,OAAO,iBAAiB,MAAM,QAAQ,IAAI,KAAK;EACjD,SACE;CACJ;AACF;;;;;AAMA,SAAS,iBAAiB,SAA2E;CACnG,OAAO,OAAO,YACZ,OAAO,QAAQ,WAAW,CAAC,CAAC,CAAC,CAAC,QAAQ,GAAG,WAAW,UAAU,KAAA,CAAS,CACzE;AACF;;;;;;;;;AAUA,SAAS,sBAAsB,WAAiE;CAC9F,OAAO;EAAE,cAAc;EAAqB,aAAa;EAAU,GAAG;CAAU;AAClF;AAEA,IAAa,mBAAb,MAA4D;CAC1D,KAAc;;;;;;CAMd,4BAAqC;CAErC;;;;;;CAMA,sBAAsB;CAEtB,YAAY,QAAgC;EAC1C,IAAI,CAAC,OAAO,eACV,MAAM,IAAI,MACR,kGACF;EAEF,KAAK,UAAU;CACjB;CAEA,SAAS,KAAgD;EAGvD,MAAM,iBACJ,IAAI,QAAQ,mBAAmB,IAAI,QAAQ,qBAAqB,CAAC,IAAI,QAAQ,kBAAkB,IAAI,CAAC;EACtG,KAAK,sBAAsB,eAAe,SAAS;EACnD,OAAO,0BAA0B;GAC/B,OAAO;IACL,UAAU,KAAK,QAAQ;IACvB,cAAc,KAAK,QAAQ;IAC3B,eAAe,KAAK,QAAQ;IAC5B,UAAU,KAAK,QAAQ;GACzB;GACA,cAAc,IAAI,QAAQ;GAC1B,UAAU,IAAI,QAAQ;GACtB;GACA,eAAe,IAAI,QAAQ;GAC3B,WAAW,IAAI,SAAS;GACxB,MAAM,IAAI;GACV,gBAAgB,sBAAsB,iBAAiB,KAAK,QAAQ,cAAc,CAAC;EACrF,CAAC;CACH;CAEA,cAAc,KAAgD;EAC5D,OAAO,IAAI,mBAAmB,EAAE,YAAY,IAAI,WAAW,CAAC;CAC9D;CAEA,OAAO,KAAqC;EAC1C,MAAM,EAAE,UAAU,cAAc,qBAAqB,aAAa,KAAK;EACvE,OAAO,yBAAyB;GAC9B,MAAM,IAAI;GACV,cAAc,IAAI,QAAQ;GAC1B,mBAAmB,IAAI;GACvB,MACE,YAAY,gBAAgB,sBACxB;IAAE;IAAU;IAAc,iBAAiB;IAAqB;GAAS,IACzE,KAAA;GACN,UAAU,IAAI,QAAQ;EACxB,CAAC;CACH;CAEA,cAAuC;EACrC,MAAM,EAAE,UAAU,cAAc,UAAU,wBAAwB,KAAK;EACvE,OAAO;GACL,YAAY;GACZ,oBAAoB,QAAQ,QAAQ;GACpC,gBAAgB,QAAQ,YAAY,gBAAgB,mBAAmB;GACvE,oBAAoB,KAAK;EAC3B;CACF;AACF"}
+{"version":3,"file":"integration.js","names":[],"sources":["../../../src/integrations/slack/integration.ts"],"sourcesContent":["/**\n * `SlackIntegration` — Slack as a `FactoryIntegration`.\n *\n * Slack contributes two things to a factory: the chat channels that carry\n * inbound messages into agent runs (`channels()`), and the browser-facing\n * account-link routes that bind a Slack sender to a Mastra tenant (`routes()`).\n * Both used to be assembled by hand in the deploy entry, which had to reach\n * into the prepared agent controller by string key, resolve storage domains\n * itself, mint its own state signer, and splice routes onto the factory's\n * assembled server config. Implementing the integration interface instead means\n * the factory does all of that the same way it already does for GitHub and\n * Linear, and the entry's job shrinks to reading Slack's env vars once.\n *\n * Slack ships as a factory built-in alongside GitHub and Linear (it originally\n * lived in `mastracode/web` to keep `@mastra/slack`/`chat` out of this package;\n * the team reversed that so `create-factory` consumers get Slack channels out\n * of the box). The integration interface remains open — third parties still add\n * capabilities by implementing `FactoryIntegration` from outside the package.\n */\n\nimport type { AgentChannels, TypingStatusFn } from '@mastra/core/channels';\nimport type { InputProcessor, OutputProcessor } from '@mastra/core/processors';\nimport type { RequestContext } from '@mastra/core/request-context';\nimport type { ApiRoute } from '@mastra/core/server';\nimport type { SlackAdapterChannelConfig } from '@mastra/slack';\n\nimport type { WorkItemFeedPublisher } from '../../storage/domains/comments/feed-sync.js';\n\nimport type { FactoryChannelsConfig, FactoryIntegration, IntegrationContext, IntegrationTools } from '../base.js';\nimport { FactoryChannelReplyProcessor } from './channel-reply-processor.js';\nimport { FactoryChannelSessionLinkProcessor } from './channel-session-link-processor.js';\nimport { createSlackConnectRoutes } from './connect-route.js';\nimport { SlackFeedPublisher } from './feed-publisher.js';\nimport { FactoryReplyReminderProcessor } from './reply-reminder-processor.js';\nimport { createReplyTool, FactoryReplyStreamProcessor, REPLY_TOOL_NAME } from './reply-tool.js';\nimport { createShareFileTool, isSlackThread } from './share-file-tool.js';\nimport type { ShareFileToolDeps } from './share-file-tool.js';\nimport { createSlackChannelsConfig } from './slack.js';\n\n/**\n * Slack app credentials, read from env ONCE by the deploy entry. `signingSecret`\n * is required because the Slack adapter validates it at construction — an\n * integration constructed without it would throw during `prepare()` rather than\n * reporting itself unconfigured.\n */\nexport interface SlackIntegrationConfig {\n  /** Verifies inbound Slack request signatures. Required. */\n  signingSecret: string;\n  /** Bot token used to post replies and ephemeral cards. */\n  botToken?: string;\n  /**\n   * OAuth client credentials. Required for account linking: \"Sign in with\n   * Slack\" (OIDC) is the only flow that writes a link, so without these the\n   * settings surface reports `canConnect: false` and no sender can link.\n   */\n  clientId?: string;\n  clientSecret?: string;\n  /**\n   * HTTPS origin Slack redirects back to. Slack requires HTTPS, so locally this\n   * is the tunnel origin rather than the app's own public URL.\n   */\n  oidcRedirectBaseUrl?: string;\n  /** SPA origin the post-connect redirect returns to. */\n  uiOrigin?: string;\n  /**\n   * Overrides for the Slack channel adapter entry.\n   *\n   * @example\n   * ```ts\n   * new SlackIntegration({\n   *   signingSecret,\n   *   adapterOptions: {\n   *     streaming: true,\n   *     toolDisplay: 'grouped',\n   *   },\n   * });\n   * ```\n   */\n  adapterOptions?: SlackAdapterChannelConfig;\n}\n\n/** Slack renders the status inline next to the app name; keep it to one short line. */\nconst MAX_STATUS_LENGTH = 80;\n\n/**\n * Turns a tool's `description` arg (\"Listing the repo root\") into a status\n * line that reads after the app name (\"<App> is listing the repo root…\").\n * Only the first line counts: issue/PR creators carry whole bodies there.\n */\nfunction describeToolCall(args: unknown): string | undefined {\n  if (!args || typeof args !== 'object') return undefined;\n  const { description } = args as { description?: unknown };\n  if (typeof description !== 'string') return undefined;\n  const line = description\n    .split('\\n')\n    .map(part => part.replace(/\\s+/g, ' ').trim())\n    .find(Boolean);\n  if (!line) return undefined;\n  const text = line.length > MAX_STATUS_LENGTH ? `${line.slice(0, MAX_STATUS_LENGTH - 1)}…` : line;\n  // Drop the sentence-case capital (\"Listing\" → \"listing\") but leave acronyms\n  // and identifiers (\"PR lookup\", \"CI status\") alone.\n  return `is ${/^[A-Z][a-z]/.test(text) ? text.charAt(0).toLowerCase() + text.slice(1) : text}`;\n}\n\n/**\n * With reply text hidden, streamed text never reaches the thread, so it gets\n * no status: an \"is typing...\" set after the reply tool's post would sit on\n * the thread with nothing coming, and race the clear at the end of the run.\n */\nconst factoryTypingStatus =\n  (textDisplay: SlackAdapterChannelConfig['textDisplay']): TypingStatusFn =>\n  chunk => {\n  switch (chunk.type) {\n    case 'reasoning-delta':\n      return 'is thinking...';\n    case 'text-delta':\n      return textDisplay === 'hidden' ? undefined : 'is typing...';\n    // The reply tool's text streams into the thread as the model writes it.\n    case 'tool-call-input-streaming-start':\n      return chunk.payload.toolName === REPLY_TOOL_NAME ? 'is typing...' : undefined;\n    case 'tool-call':\n      // Still finishing the streamed reply; don't flip to \"is working...\".\n      if (chunk.payload.toolName === REPLY_TOOL_NAME) return 'is typing...';\n      return describeToolCall(chunk.payload.args) ?? 'is working...';\n    default:\n      return undefined;\n  }\n};\n\n/**\n * Drops keys the caller set to `undefined` so spreading the overrides cannot\n * erase the Factory defaults they sit on top of.\n */\nfunction adapterOverrides(options: SlackAdapterChannelConfig | undefined): SlackAdapterChannelConfig {\n  return Object.fromEntries(\n    Object.entries(options ?? {}).filter(([, value]) => value !== undefined),\n  ) as SlackAdapterChannelConfig;\n}\n\n/**\n * Factory defaults under the caller's overrides. Tool calls stay out of the\n * thread: a Factory session runs hundreds of them, and a row per call (or a\n * card per call) buries the reply. Progress shows through the typing status\n * instead, which names the tool's current step; the session link carries the\n * full trace. `grouped` remains available via `adapterOptions` for callers\n * who want Slack's \"Thinking Steps\" widget.\n */\nfunction factoryAdapterOptions(overrides: SlackAdapterChannelConfig): SlackAdapterChannelConfig {\n  const textDisplay = overrides.textDisplay ?? 'hidden';\n  return { typingStatus: factoryTypingStatus(textDisplay), toolDisplay: 'hidden', textDisplay, ...overrides };\n}\n\nexport class SlackIntegration implements FactoryIntegration {\n  readonly id = 'slack';\n  /**\n   * The OIDC connect flow round-trips a signed `state` through Slack, so the\n   * replica handling the callback must be able to verify a state a different\n   * replica signed.\n   */\n  readonly requiresStableStateSigner = true;\n\n  readonly #config: SlackIntegrationConfig;\n  readonly #adapterOptions: SlackAdapterChannelConfig;\n  /** Bound in `initialize()`; the controller mounts after integrations are built. */\n  #channels: ShareFileToolDeps['channels'];\n  readonly #deps: ShareFileToolDeps = { channels: () => this.#channels?.() };\n  /**\n   * With reply text hidden (the Factory default) the agent speaks through\n   * `reply_in_thread`, so the prompt, reminder and live streaming for that\n   * tool come with it. The setting is fixed for the deployment, so it is\n   * decided once here rather than on every run.\n   */\n  readonly processors: { input: InputProcessor[]; output: OutputProcessor[] };\n  /**\n   * Whether `channels()` found a source-control owner on the context and wired\n   * repo-backed sessions. Set at the channels() attach path, which runs once at\n   * boot before diagnostics are served.\n   */\n  #repoBackedSessions = false;\n\n  constructor(config: SlackIntegrationConfig) {\n    if (!config.signingSecret) {\n      throw new Error(\n        \"SlackIntegration: 'signingSecret' is required — Slack cannot verify inbound requests without it.\",\n      );\n    }\n    this.#config = config;\n    this.#adapterOptions = factoryAdapterOptions(adapterOverrides(config.adapterOptions));\n    const textHidden = this.#textHidden;\n    this.processors = {\n      input: [\n        new FactoryChannelReplyProcessor(),\n        ...(textHidden ? [new FactoryReplyReminderProcessor()] : []),\n      ],\n      output: [\n        new FactoryChannelSessionLinkProcessor(),\n        ...(textHidden ? [new FactoryReplyStreamProcessor(this.#deps)] : []),\n      ],\n    };\n  }\n\n  get #textHidden(): boolean {\n    return this.#adapterOptions.textDisplay === 'hidden';\n  }\n\n  initialize(args: { channels?: () => AgentChannels | null | undefined }): void {\n    this.#channels = args.channels;\n  }\n\n  /**\n   * `attach_file`, and `reply_in_thread` when reply text is hidden, on runs\n   * whose session is linked to a Slack thread. The tools find the thread to\n   * post into when they are called.\n   */\n  async agentTools({ requestContext }: { requestContext: RequestContext }): Promise<IntegrationTools> {\n    if (!(await isSlackThread(requestContext, this.#deps))) return {};\n    return {\n      ...createShareFileTool(requestContext, this.#deps),\n      ...(this.#textHidden ? createReplyTool(requestContext, this.#deps) : {}),\n    };\n  }\n\n  channels(ctx: IntegrationContext): FactoryChannelsConfig {\n    // Repo-backed sessions select the source-control provider from the linked\n    // repository on each Factory project.\n    const sourceControls =\n      ctx.storage.sourceControls ?? (ctx.storage.sourceControlOwner ? [ctx.storage.sourceControlOwner] : []);\n    this.#repoBackedSessions = sourceControls.length > 0;\n    return createSlackChannelsConfig({\n      slack: {\n        clientId: this.#config.clientId,\n        clientSecret: this.#config.clientSecret,\n        signingSecret: this.#config.signingSecret,\n        botToken: this.#config.botToken,\n      },\n      accountLinks: ctx.storage.channelIdentity,\n      projects: ctx.storage.projects,\n      sourceControls,\n      modelDefaults: ctx.storage.modelDefaults,\n      workItems: ctx.runtime?.workItems,\n      feed: ctx.feed,\n      adapterOptions: this.#adapterOptions,\n    });\n  }\n\n  feedPublisher(ctx: IntegrationContext): WorkItemFeedPublisher {\n    return new SlackFeedPublisher({ controller: ctx.controller });\n  }\n\n  routes(ctx: IntegrationContext): ApiRoute[] {\n    const { clientId, clientSecret, oidcRedirectBaseUrl, uiOrigin } = this.#config;\n    return createSlackConnectRoutes({\n      auth: ctx.auth,\n      accountLinks: ctx.storage.channelIdentity,\n      tenantStateSigner: ctx.stateSigner,\n      oidc:\n        clientId && clientSecret && oidcRedirectBaseUrl\n          ? { clientId, clientSecret, redirectBaseUrl: oidcRedirectBaseUrl, uiOrigin }\n          : undefined,\n      projects: ctx.storage.projects,\n    });\n  }\n\n  diagnostics(): Record<string, unknown> {\n    const { clientId, clientSecret, botToken, oidcRedirectBaseUrl } = this.#config;\n    return {\n      configured: true,\n      botTokenConfigured: Boolean(botToken),\n      oidcConfigured: Boolean(clientId && clientSecret && oidcRedirectBaseUrl),\n      repoBackedSessions: this.#repoBackedSessions,\n    };\n  }\n}\n"],"mappings":";;;;;;;;;;AAkFA,MAAM,oBAAoB;;;;;;AAO1B,SAAS,iBAAiB,MAAmC;CAC3D,IAAI,CAAC,QAAQ,OAAO,SAAS,UAAU,OAAO,KAAA;CAC9C,MAAM,EAAE,gBAAgB;CACxB,IAAI,OAAO,gBAAgB,UAAU,OAAO,KAAA;CAC5C,MAAM,OAAO,YACV,MAAM,IAAI,CAAC,CACX,KAAI,SAAQ,KAAK,QAAQ,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAC7C,KAAK,OAAO;CACf,IAAI,CAAC,MAAM,OAAO,KAAA;CAClB,MAAM,OAAO,KAAK,SAAS,oBAAoB,GAAG,KAAK,MAAM,GAAG,EAAqB,EAAE,KAAK;CAG5F,OAAO,MAAM,cAAc,KAAK,IAAI,IAAI,KAAK,OAAO,CAAC,CAAC,CAAC,YAAY,IAAI,KAAK,MAAM,CAAC,IAAI;AACzF;;;;;;AAOA,MAAM,uBACH,iBACD,UAAS;CACT,QAAQ,MAAM,MAAd;EACE,KAAK,mBACH,OAAO;EACT,KAAK,cACH,OAAO,gBAAgB,WAAW,KAAA,IAAY;EAEhD,KAAK,mCACH,OAAO,MAAM,QAAQ,aAAA,oBAA+B,iBAAiB,KAAA;EACvE,KAAK;GAEH,IAAI,MAAM,QAAQ,aAAA,mBAA8B,OAAO;GACvD,OAAO,iBAAiB,MAAM,QAAQ,IAAI,KAAK;EACjD,SACE;CACJ;AACF;;;;;AAMA,SAAS,iBAAiB,SAA2E;CACnG,OAAO,OAAO,YACZ,OAAO,QAAQ,WAAW,CAAC,CAAC,CAAC,CAAC,QAAQ,GAAG,WAAW,UAAU,KAAA,CAAS,CACzE;AACF;;;;;;;;;AAUA,SAAS,sBAAsB,WAAiE;CAC9F,MAAM,cAAc,UAAU,eAAe;CAC7C,OAAO;EAAE,cAAc,oBAAoB,WAAW;EAAG,aAAa;EAAU;EAAa,GAAG;CAAU;AAC5G;AAEA,IAAa,mBAAb,MAA4D;CAC1D,KAAc;;;;;;CAMd,4BAAqC;CAErC;CACA;;CAEA;CACA,QAAoC,EAAE,gBAAgB,KAAK,YAAY,EAAE;;;;;;;CAOzE;;;;;;CAMA,sBAAsB;CAEtB,YAAY,QAAgC;EAC1C,IAAI,CAAC,OAAO,eACV,MAAM,IAAI,MACR,kGACF;EAEF,KAAK,UAAU;EACf,KAAK,kBAAkB,sBAAsB,iBAAiB,OAAO,cAAc,CAAC;EACpF,MAAM,aAAa,KAAK;EACxB,KAAK,aAAa;GAChB,OAAO,CACL,IAAI,6BAA6B,GACjC,GAAI,aAAa,CAAC,IAAI,8BAA8B,CAAC,IAAI,CAAC,CAC5D;GACA,QAAQ,CACN,IAAI,mCAAmC,GACvC,GAAI,aAAa,CAAC,IAAI,4BAA4B,KAAK,KAAK,CAAC,IAAI,CAAC,CACpE;EACF;CACF;CAEA,IAAI,cAAuB;EACzB,OAAO,KAAK,gBAAgB,gBAAgB;CAC9C;CAEA,WAAW,MAAmE;EAC5E,KAAK,YAAY,KAAK;CACxB;;;;;;CAOA,MAAM,WAAW,EAAE,kBAAiF;EAClG,IAAI,CAAE,MAAM,cAAc,gBAAgB,KAAK,KAAK,GAAI,OAAO,CAAC;EAChE,OAAO;GACL,GAAG,oBAAoB,gBAAgB,KAAK,KAAK;GACjD,GAAI,KAAK,cAAc,gBAAgB,gBAAgB,KAAK,KAAK,IAAI,CAAC;EACxE;CACF;CAEA,SAAS,KAAgD;EAGvD,MAAM,iBACJ,IAAI,QAAQ,mBAAmB,IAAI,QAAQ,qBAAqB,CAAC,IAAI,QAAQ,kBAAkB,IAAI,CAAC;EACtG,KAAK,sBAAsB,eAAe,SAAS;EACnD,OAAO,0BAA0B;GAC/B,OAAO;IACL,UAAU,KAAK,QAAQ;IACvB,cAAc,KAAK,QAAQ;IAC3B,eAAe,KAAK,QAAQ;IAC5B,UAAU,KAAK,QAAQ;GACzB;GACA,cAAc,IAAI,QAAQ;GAC1B,UAAU,IAAI,QAAQ;GACtB;GACA,eAAe,IAAI,QAAQ;GAC3B,WAAW,IAAI,SAAS;GACxB,MAAM,IAAI;GACV,gBAAgB,KAAK;EACvB,CAAC;CACH;CAEA,cAAc,KAAgD;EAC5D,OAAO,IAAI,mBAAmB,EAAE,YAAY,IAAI,WAAW,CAAC;CAC9D;CAEA,OAAO,KAAqC;EAC1C,MAAM,EAAE,UAAU,cAAc,qBAAqB,aAAa,KAAK;EACvE,OAAO,yBAAyB;GAC9B,MAAM,IAAI;GACV,cAAc,IAAI,QAAQ;GAC1B,mBAAmB,IAAI;GACvB,MACE,YAAY,gBAAgB,sBACxB;IAAE;IAAU;IAAc,iBAAiB;IAAqB;GAAS,IACzE,KAAA;GACN,UAAU,IAAI,QAAQ;EACxB,CAAC;CACH;CAEA,cAAuC;EACrC,MAAM,EAAE,UAAU,cAAc,UAAU,wBAAwB,KAAK;EACvE,OAAO;GACL,YAAY;GACZ,oBAAoB,QAAQ,QAAQ;GACpC,gBAAgB,QAAQ,YAAY,gBAAgB,mBAAmB;GACvE,oBAAoB,KAAK;EAC3B;CACF;AACF"}

package/dist/integrations/slack/reply-reminder-processor.d.ts

@@ -0,0 +1,23 @@
+import type { ProcessInputStepArgs, Processor } from '@mastra/core/processors';
+/** How long a run may work without posting before it is nudged. */
+export declare const REPLY_REMINDER_AFTER_MS: number;
+export interface FactoryReplyReminderOptions {
+    afterMs?: number;
+    now?: () => number;
+}
+/**
+ * With reply text hidden, a long job can run silently for an hour while the
+ * person who asked has no idea whether anything is happening. Once a run has
+ * gone `afterMs` without calling `reply_in_thread`, this sends the agent one
+ * signal suggesting a status update, then restarts the clock. Ignoring it is
+ * how the agent stays quiet. A signal joins the end of the transcript, so the
+ * cached prompt prefix is untouched. Only runs that have the reply tool are
+ * touched.
+ */
+export declare class FactoryReplyReminderProcessor implements Processor {
+    #private;
+    readonly id = "factory-reply-reminder";
+    constructor({ afterMs, now }?: FactoryReplyReminderOptions);
+    processInputStep({ messageList, tools, state, sendSignal }: ProcessInputStepArgs): Promise<undefined>;
+}
+//# sourceMappingURL=reply-reminder-processor.d.ts.map

package/dist/integrations/slack/reply-reminder-processor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reply-reminder-processor.d.ts","sourceRoot":"","sources":["../../../src/integrations/slack/reply-reminder-processor.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAM/E,mEAAmE;AACnE,eAAO,MAAM,uBAAuB,QAAa,CAAC;AAQlD,MAAM,WAAW,2BAA2B;IAC1C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;CACpB;AAED;;;;;;;;GAQG;AACH,qBAAa,6BAA8B,YAAW,SAAS;;IAC7D,QAAQ,CAAC,EAAE,4BAAM;gBAIL,EAAE,OAAiC,EAAE,GAAc,EAAE,GAAE,2BAAgC;IAK7F,gBAAgB,CAAC,EAAE,WAAW,EAAE,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,EAAE,oBAAoB;CAqBvF"}

package/dist/integrations/slack/reply-reminder-processor.js

@@ -0,0 +1,58 @@
+import { REPLY_TOOL_NAME } from "./reply-tool.js";
+//#region src/integrations/slack/reply-reminder-processor.ts
+const ID = "factory-reply-reminder";
+/** How long a run may work without posting before it is nudged. */
+const REPLY_REMINDER_AFTER_MS = 3e5;
+/**
+* With reply text hidden, a long job can run silently for an hour while the
+* person who asked has no idea whether anything is happening. Once a run has
+* gone `afterMs` without calling `reply_in_thread`, this sends the agent one
+* signal suggesting a status update, then restarts the clock. Ignoring it is
+* how the agent stays quiet. A signal joins the end of the transcript, so the
+* cached prompt prefix is untouched. Only runs that have the reply tool are
+* touched.
+*/
+var FactoryReplyReminderProcessor = class {
+	id = ID;
+	#afterMs;
+	#now;
+	constructor({ afterMs = REPLY_REMINDER_AFTER_MS, now = Date.now } = {}) {
+		this.#afterMs = afterMs;
+		this.#now = now;
+	}
+	async processInputStep({ messageList, tools, state, sendSignal }) {
+		if (!tools || !("reply_in_thread" in tools) || !sendSignal) return void 0;
+		const reminder = state;
+		const now = this.#now();
+		reminder.quietSince ??= now;
+		const seen = new Set(reminder.seenCalls ?? []);
+		const calls = replyCalls(messageList.get.response.db());
+		if (calls.some((id) => !seen.has(id))) reminder.quietSince = now;
+		reminder.seenCalls = calls;
+		const silentFor = now - reminder.quietSince;
+		if (silentFor < this.#afterMs) return void 0;
+		const minutes = Math.floor(silentFor / 6e4);
+		await sendSignal({
+			type: "reactive",
+			contents: `It has been ${minutes} minute${minutes === 1 ? "" : "s"} since you last posted in this thread. If the people there would want to know where things stand, post a short status with \`${REPLY_TOOL_NAME}\`. Otherwise keep working.`
+		});
+		reminder.quietSince = now;
+	}
+};
+/** Ids of the `reply_in_thread` calls this run has finished. */
+function replyCalls(messages) {
+	const ids = [];
+	for (const message of messages) {
+		if (message.role !== "assistant") continue;
+		for (const part of message.content.parts ?? []) {
+			if (part.type !== "tool-invocation") continue;
+			const { toolName, toolCallId, state } = part.toolInvocation;
+			if (toolName === "reply_in_thread" && state === "result") ids.push(toolCallId);
+		}
+	}
+	return ids;
+}
+//#endregion
+export { FactoryReplyReminderProcessor, REPLY_REMINDER_AFTER_MS };
+
+//# sourceMappingURL=reply-reminder-processor.js.map

package/dist/integrations/slack/reply-reminder-processor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reply-reminder-processor.js","names":[],"sources":["../../../src/integrations/slack/reply-reminder-processor.ts"],"sourcesContent":["import type { MastraDBMessage } from '@mastra/core/agent';\nimport type { ProcessInputStepArgs, Processor } from '@mastra/core/processors';\n\nimport { REPLY_TOOL_NAME } from './reply-tool.js';\n\nconst ID = 'factory-reply-reminder';\n\n/** How long a run may work without posting before it is nudged. */\nexport const REPLY_REMINDER_AFTER_MS = 5 * 60_000;\n\ninterface ReminderState {\n  /** When the current silence started: run start, last post, or last nudge. */\n  quietSince?: number;\n  seenCalls?: string[];\n}\n\nexport interface FactoryReplyReminderOptions {\n  afterMs?: number;\n  now?: () => number;\n}\n\n/**\n * With reply text hidden, a long job can run silently for an hour while the\n * person who asked has no idea whether anything is happening. Once a run has\n * gone `afterMs` without calling `reply_in_thread`, this sends the agent one\n * signal suggesting a status update, then restarts the clock. Ignoring it is\n * how the agent stays quiet. A signal joins the end of the transcript, so the\n * cached prompt prefix is untouched. Only runs that have the reply tool are\n * touched.\n */\nexport class FactoryReplyReminderProcessor implements Processor {\n  readonly id = ID;\n  readonly #afterMs: number;\n  readonly #now: () => number;\n\n  constructor({ afterMs = REPLY_REMINDER_AFTER_MS, now = Date.now }: FactoryReplyReminderOptions = {}) {\n    this.#afterMs = afterMs;\n    this.#now = now;\n  }\n\n  async processInputStep({ messageList, tools, state, sendSignal }: ProcessInputStepArgs) {\n    if (!tools || !(REPLY_TOOL_NAME in tools) || !sendSignal) return undefined;\n    const reminder = state as ReminderState;\n    const now = this.#now();\n    reminder.quietSince ??= now;\n\n    const seen = new Set(reminder.seenCalls ?? []);\n    const calls = replyCalls(messageList.get.response.db());\n    if (calls.some(id => !seen.has(id))) reminder.quietSince = now;\n    reminder.seenCalls = calls;\n\n    const silentFor = now - reminder.quietSince;\n    if (silentFor < this.#afterMs) return undefined;\n    const minutes = Math.floor(silentFor / 60_000);\n    await sendSignal({\n      type: 'reactive',\n      contents: `It has been ${minutes} minute${minutes === 1 ? '' : 's'} since you last posted in this thread. If the people there would want to know where things stand, post a short status with \\`${REPLY_TOOL_NAME}\\`. Otherwise keep working.`,\n    });\n    reminder.quietSince = now;\n    return undefined;\n  }\n}\n\n/** Ids of the `reply_in_thread` calls this run has finished. */\nfunction replyCalls(messages: MastraDBMessage[]): string[] {\n  const ids: string[] = [];\n  for (const message of messages) {\n    if (message.role !== 'assistant') continue;\n    for (const part of message.content.parts ?? []) {\n      if (part.type !== 'tool-invocation') continue;\n      const { toolName, toolCallId, state } = part.toolInvocation;\n      if (toolName === REPLY_TOOL_NAME && state === 'result') ids.push(toolCallId);\n    }\n  }\n  return ids;\n}\n"],"mappings":";;AAKA,MAAM,KAAK;;AAGX,MAAa,0BAA0B;;;;;;;;;;AAsBvC,IAAa,gCAAb,MAAgE;CAC9D,KAAc;CACd;CACA;CAEA,YAAY,EAAE,UAAU,yBAAyB,MAAM,KAAK,QAAqC,CAAC,GAAG;EACnG,KAAK,WAAW;EAChB,KAAK,OAAO;CACd;CAEA,MAAM,iBAAiB,EAAE,aAAa,OAAO,OAAO,cAAoC;EACtF,IAAI,CAAC,SAAS,EAAA,qBAAqB,UAAU,CAAC,YAAY,OAAO,KAAA;EACjE,MAAM,WAAW;EACjB,MAAM,MAAM,KAAK,KAAK;EACtB,SAAS,eAAe;EAExB,MAAM,OAAO,IAAI,IAAI,SAAS,aAAa,CAAC,CAAC;EAC7C,MAAM,QAAQ,WAAW,YAAY,IAAI,SAAS,GAAG,CAAC;EACtD,IAAI,MAAM,MAAK,OAAM,CAAC,KAAK,IAAI,EAAE,CAAC,GAAG,SAAS,aAAa;EAC3D,SAAS,YAAY;EAErB,MAAM,YAAY,MAAM,SAAS;EACjC,IAAI,YAAY,KAAK,UAAU,OAAO,KAAA;EACtC,MAAM,UAAU,KAAK,MAAM,YAAY,GAAM;EAC7C,MAAM,WAAW;GACf,MAAM;GACN,UAAU,eAAe,QAAQ,SAAS,YAAY,IAAI,KAAK,IAAI,+HAA+H,gBAAgB;EACpN,CAAC;EACD,SAAS,aAAa;CAExB;AACF;;AAGA,SAAS,WAAW,UAAuC;CACzD,MAAM,MAAgB,CAAC;CACvB,KAAK,MAAM,WAAW,UAAU;EAC9B,IAAI,QAAQ,SAAS,aAAa;EAClC,KAAK,MAAM,QAAQ,QAAQ,QAAQ,SAAS,CAAC,GAAG;GAC9C,IAAI,KAAK,SAAS,mBAAmB;GACrC,MAAM,EAAE,UAAU,YAAY,UAAU,KAAK;GAC7C,IAAI,aAAA,qBAAgC,UAAU,UAAU,IAAI,KAAK,UAAU;EAC7E;CACF;CACA,OAAO;AACT"}

package/dist/integrations/slack/reply-tool.d.ts

@@ -0,0 +1,31 @@
+import type { Processor, ProcessOutputStreamArgs } from '@mastra/core/processors';
+import type { RequestContext } from '@mastra/core/request-context';
+import type { ChunkType } from '@mastra/core/stream';
+import type { IntegrationTools } from '../base.js';
+import type { ShareFileToolDeps } from './share-file-tool.js';
+export declare const REPLY_TOOL_NAME = "reply_in_thread";
+/**
+ * The only way a channel run speaks when the adapter hides reply text
+ * (`textDisplay: 'hidden'`). Posting becomes a choice the agent makes, so it
+ * stops narrating each step into the thread and can say nothing on purpose.
+ * Offered only when the Slack adapter hides reply text and the run's thread is
+ * linked to Slack; with text shown the reply stream already posts and this
+ * tool would double every message.
+ */
+export declare function createReplyTool(requestContext: RequestContext, deps?: ShareFileToolDeps): IntegrationTools;
+/**
+ * Streams a `reply_in_thread` call's `text` into the thread while the model is
+ * still writing it, so a long reply appears as it is written instead of all at
+ * once when the call completes. The tool finishes the post with the validated
+ * text. Runs whose adapter doesn't stream, or that show reply text, are left
+ * alone.
+ */
+export declare class FactoryReplyStreamProcessor implements Processor {
+    private readonly deps;
+    readonly id = "factory-reply-stream";
+    constructor(deps?: ShareFileToolDeps);
+    processOutputStream({ part, state, requestContext }: ProcessOutputStreamArgs): Promise<ChunkType>;
+}
+/** The decoded value of a top-level string field in JSON that may still be cut off mid-string. */
+export declare function partialStringField(json: string, field: string): string | undefined;
+//# sourceMappingURL=reply-tool.d.ts.map

package/dist/integrations/slack/reply-tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reply-tool.d.ts","sourceRoot":"","sources":["../../../src/integrations/slack/reply-tool.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,uBAAuB,EAAE,MAAM,yBAAyB,CAAC;AAClF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AACnE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAKrD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAInD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAE9D,eAAO,MAAM,eAAe,oBAAoB,CAAC;AAWjD;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,cAAc,EAAE,cAAc,EAAE,IAAI,GAAE,iBAAsB,GAAG,gBAAgB,CAyB9G;AA8FD;;;;;;GAMG;AACH,qBAAa,2BAA4B,YAAW,SAAS;IAG/C,OAAO,CAAC,QAAQ,CAAC,IAAI;IAFjC,QAAQ,CAAC,EAAE,0BAA0B;gBAER,IAAI,GAAE,iBAAsB;IAEnD,mBAAmB,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,cAAc,EAAE,EAAE,uBAAuB,GAAG,OAAO,CAAC,SAAS,CAAC;CAyBxG;AAmBD,kGAAkG;AAClG,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAwBlF"}

package/dist/integrations/slack/reply-tool.js

@@ -0,0 +1,203 @@
+import { readFactorySessionScope } from "../../rules/binding-context.js";
+import { SESSION_LINK_LABEL, sessionLink } from "./channel-reply-processor.js";
+import "./channel-session-link-processor.js";
+import { postTarget, resolveRenderContext } from "./share-file-tool.js";
+import "@mastra/core/channels";
+import { z } from "zod";
+import { createTool } from "@mastra/core/tools";
+//#region src/integrations/slack/reply-tool.ts
+const REPLY_TOOL_NAME = "reply_in_thread";
+/** Set once the first reply of a new session carried the session link. */
+const LINKED_KEY = "factory__replyLinked";
+const replyInput = z.object({ text: z.string().trim().min(1).max(12e3).describe("The message to post, in markdown.") }).strict();
+/**
+* The only way a channel run speaks when the adapter hides reply text
+* (`textDisplay: 'hidden'`). Posting becomes a choice the agent makes, so it
+* stops narrating each step into the thread and can say nothing on purpose.
+* Offered only when the Slack adapter hides reply text and the run's thread is
+* linked to Slack; with text shown the reply stream already posts and this
+* tool would double every message.
+*/
+function createReplyTool(requestContext, deps = {}) {
+	return { [REPLY_TOOL_NAME]: createTool({
+		id: REPLY_TOOL_NAME,
+		description: "Post a message in this chat thread. Nothing you write outside this tool reaches the thread, so use it for anything the people there should see: a short note that you are starting a longer job, a question you need answered, and the outcome when you finish. Post when you have something new; do not repeat yourself or post that nothing changed. To stay quiet, do not call it.",
+		inputSchema: replyInput,
+		execute: async (input, context) => {
+			const link = firstReplyLink(requestContext);
+			const suffix = link ? `\n\n[${SESSION_LINK_LABEL}](${link})` : "";
+			const toolCallId = context?.agent?.toolCallId;
+			const streamed = toolCallId ? replyStreams(requestContext).get(toolCallId) : void 0;
+			if (toolCallId) replyStreams(requestContext).delete(toolCallId);
+			if (!streamed || !await streamed.finish(input.text, suffix)) await (await postTarget(requestContext, deps)).chatThread.post({ markdown: `${input.text}${suffix}` });
+			if (link) requestContext.set(LINKED_KEY, true);
+			return { posted: true };
+		}
+	}) };
+}
+/**
+* The session link the first reply of a new session ends with. With reply
+* text hidden, `FactoryChannelSessionLinkProcessor`'s text delta never
+* reaches the thread, so the tool carries the link instead.
+*/
+function firstReplyLink(requestContext) {
+	if (!requestContext.get("factory__newChannelSession") || requestContext.get(LINKED_KEY)) return void 0;
+	const controller = requestContext.get("controller");
+	if (!controller?.threadId) return void 0;
+	return sessionLink({
+		threadId: controller.threadId,
+		sessionId: controller.sessionId,
+		resourceId: controller.resourceId,
+		factoryProjectId: readFactorySessionScope(requestContext)?.factoryProjectId
+	});
+}
+/** Live posts of `reply_in_thread` calls whose text is still streaming in, by tool call id. */
+const STREAMS_KEY = "factory__replyStreams";
+function replyStreams(requestContext) {
+	let streams = requestContext.get(STREAMS_KEY);
+	if (!streams) {
+		streams = /* @__PURE__ */ new Map();
+		requestContext.set(STREAMS_KEY, streams);
+	}
+	return streams;
+}
+/**
+* One streamed Slack post, opened on the first visible text so an abandoned
+* call never leaves an empty message behind.
+*/
+function openReplyStream(chatThread) {
+	const queue = [];
+	let sent = "";
+	let closed = false;
+	let wake;
+	let done;
+	async function* chunks() {
+		while (true) {
+			while (queue.length > 0) yield queue.shift();
+			if (closed) return;
+			await new Promise((resolve) => wake = resolve);
+		}
+	}
+	const push = (text) => {
+		if (!text) return;
+		queue.push(text);
+		done ??= chatThread.post(chunks()).then(() => true, (error) => {
+			console.warn("[factory] streamed reply failed; posting it whole", { error });
+			return false;
+		});
+		wake?.();
+	};
+	return {
+		update(text) {
+			const visible = text.trimStart();
+			if (!visible.startsWith(sent)) return;
+			push(visible.slice(sent.length));
+			sent = visible;
+		},
+		async finish(text, suffix) {
+			if (text.startsWith(sent)) push(text.slice(sent.length));
+			if (!done) return false;
+			push(suffix);
+			closed = true;
+			wake?.();
+			return done;
+		},
+		async close() {
+			closed = true;
+			wake?.();
+			return done ?? false;
+		}
+	};
+}
+/**
+* Streams a `reply_in_thread` call's `text` into the thread while the model is
+* still writing it, so a long reply appears as it is written instead of all at
+* once when the call completes. The tool finishes the post with the validated
+* text. Runs whose adapter doesn't stream, or that show reply text, are left
+* alone.
+*/
+var FactoryReplyStreamProcessor = class {
+	deps;
+	id = "factory-reply-stream";
+	constructor(deps = {}) {
+		this.deps = deps;
+	}
+	async processOutputStream({ part, state, requestContext }) {
+		if (!requestContext) return part;
+		const args = state.args ??= {};
+		if (part.type === "tool-call-input-streaming-start" && part.payload.toolName === "reply_in_thread") {
+			const render = await resolveRenderContext(requestContext, this.deps);
+			if (render?.textDisplay !== "hidden" || !render.streaming?.enabled) return part;
+			args[part.payload.toolCallId] = "";
+			replyStreams(requestContext).set(part.payload.toolCallId, openReplyStream(render.chatThread));
+		} else if (part.type === "tool-call-delta" && part.payload.toolCallId in args) {
+			const text = partialStringField(args[part.payload.toolCallId] += part.payload.argsTextDelta, "text");
+			if (text !== void 0) replyStreams(requestContext).get(part.payload.toolCallId)?.update(text);
+		} else if ((part.type === "tool-error" || part.type === "tool-result") && part.payload.toolCallId in args) {
+			delete args[part.payload.toolCallId];
+			await closeStream(requestContext, part.payload.toolCallId);
+		} else if (RUN_END.has(part.type)) {
+			for (const toolCallId of Object.keys(args)) await closeStream(requestContext, toolCallId);
+			state.args = {};
+		}
+		return part;
+	}
+};
+/** Chunks after which no `reply_in_thread` call of this run will still execute. */
+const RUN_END = /* @__PURE__ */ new Set([
+	"finish",
+	"abort",
+	"error",
+	"tripwire"
+]);
+/**
+* Ends a streamed post whose call will never reach `execute`, keeping the text
+* shown so far, so Slack isn't left with a message that never finishes.
+*/
+async function closeStream(requestContext, toolCallId) {
+	const streams = replyStreams(requestContext);
+	const stream = streams.get(toolCallId);
+	if (!stream) return;
+	streams.delete(toolCallId);
+	await stream.close();
+}
+const ESCAPES = {
+	"\"": "\"",
+	"\\": "\\",
+	"/": "/",
+	b: "\b",
+	f: "\f",
+	n: "\n",
+	r: "\r",
+	t: "	"
+};
+/** The decoded value of a top-level string field in JSON that may still be cut off mid-string. */
+function partialStringField(json, field) {
+	const start = new RegExp(`"${field}"\\s*:\\s*"`).exec(json);
+	if (!start) return void 0;
+	let out = "";
+	for (let i = start.index + start[0].length; i < json.length; i++) {
+		const ch = json[i];
+		if (ch === "\"") return out;
+		if (ch !== "\\") {
+			out += ch;
+			continue;
+		}
+		const next = json[i + 1];
+		if (next === void 0) return out;
+		if (next === "u") {
+			const hex = json.slice(i + 2, i + 6);
+			if (hex.length < 4) return out;
+			out += String.fromCharCode(parseInt(hex, 16));
+			i += 5;
+		} else {
+			out += ESCAPES[next] ?? next;
+			i += 1;
+		}
+	}
+	return out;
+}
+//#endregion
+export { FactoryReplyStreamProcessor, REPLY_TOOL_NAME, createReplyTool, partialStringField };
+
+//# sourceMappingURL=reply-tool.js.map