feat(n8n): propagate originating-conversation routing into workflow generator

When the workflow is generated from inside a platform conversation
(e.g. a Discord DM or a Telegram chat), surface the originating channel
or chat to the LLM as a `## Runtime Facts` line so the user can say
"post the result back to this channel" and the generated send node
targets the right ID without naming it.

End-to-end wiring:

- `client-types-chat.ts`: extend `N8nWorkflowGenerateRequest` with
  optional `bridgeConversationId`. AutomationsView already had the id
  in scope (it uses it to bind the workflow to the originating
  conversation); now also forwards it on the generation request.

- `n8n-routes.ts`: when `bridgeConversationId` is present, read the
  originating conversation's tail inbound message metadata via
  `runtime.getMemories({ roomId, tableName: "messages", count: 12 })`,
  derive a `TriggerContext` (Discord channelId/guildId, Telegram
  chatId/threadId, Slack channelId/teamId), and thread it into
  `service.generateWorkflowDraft(prompt, { triggerContext })`. The
  helper reads BOTH the canonical `metadata.discord.{channelId,guildId}`
  sub-object AND the legacy flat `discordChannelId` / `discordServerId`
  fields — pre-existing schema gap; canonical wins when present, flat
  is the fallback so nothing today breaks.

- `n8n-runtime-context-provider.ts`: extend `RuntimeContextProviderInput`
  to accept the trigger context, render it as a fact line:

      This workflow was prompted from a Discord conversation in
      #general (id 9876543210) within "Cozy Devs" (id 1234567890).
      When the user references "this channel" or "back to here",
      target that channel ID.

  Same pattern for Telegram chats and Slack channels. Empty / missing
  routing data → no fact line.

Backward compatibility:
- Routes still work without `bridgeConversationId` (no triggerContext
  threading, baseline behavior).
- Plugin still works with hosts that don't pass triggerContext (the
  optional `opts` arg on `generateWorkflowDraft` is unused — see
  elizaos-plugins/plugin-n8n-workflow#26).

Out of scope (follow-up):
- Persist `originChannelContext` on the workflow's conversation metadata
  for re-runs without a fresh inbound message.
- Switch upstream plugin-discord/telegram from flat metadata fields to
  the canonical nested `metadata.discord.{channelId,guildId,messageId}`
  shape.

Depends on: elizaos-plugins/plugin-n8n-workflow#26 (TriggerContext on
RuntimeContextProviderInput) at runtime; this PR's host code compiles
and falls through cleanly until the plugin upgrade is wired.

Author: 2-A-M

packages/app-core/src/api/client-types-chat.ts

@@ -505,4 +505,12 @@ export interface N8nWorkflowGenerateRequest {
   prompt: string;
   name?: string;
   workflowId?: string;
+  /**
+   * Optional originating conversation id. When present, the server reads
+   * the conversation's tail inbound message metadata and threads platform
+   * routing (Discord channelId/guildId, Telegram chatId, etc.) into the
+   * workflow generator so the LLM can target "this channel" / "back to
+   * here" without the user naming an ID.
+   */
+  bridgeConversationId?: string;
 }

packages/app-core/src/api/n8n-routes.ts

@@ -610,6 +610,142 @@ function readOptionalNumber(
     : undefined;
 }
 
+/**
+ * Shape of the routing block we hand to the n8n workflow service so the
+ * generator can target "this channel" / "back to here" without the user
+ * naming an ID. Mirrors the upstream `TriggerContext` in
+ * `@elizaos/plugin-n8n-workflow` — duplicated here so this route doesn't
+ * import from the plugin (the host already has its own copy in the
+ * runtime context provider, and the LLM ultimately reads it as a
+ * `## Runtime Facts` line, not via the plugin's prompt builder).
+ */
+interface TriggerContext {
+  source?: string;
+  discord?: { channelId?: string; guildId?: string; threadId?: string };
+  telegram?: { chatId?: string | number; threadId?: string | number };
+  slack?: { channelId?: string; teamId?: string };
+  resolvedNames?: { channel?: string; server?: string };
+}
+
+/**
+ * Read the originating conversation's tail inbound message metadata and
+ * derive a `TriggerContext`. Reads both the canonical
+ * `metadata.discord.{channelId,guildId,messageId}` /
+ * `metadata.telegram.{chatId,threadId}` blocks AND the flat
+ * `discordChannelId` / `discordServerId` / `discordMessageId` fields the
+ * upstream Discord plugin currently writes (pre-existing schema gap —
+ * canonical wins when present, flat is the fallback so nothing today
+ * breaks).
+ *
+ * Returns `undefined` when the conversation has no inbound platform
+ * metadata or the runtime can't read memories.
+ */
+async function buildTriggerContextFromConversation(
+  runtime: AgentRuntime | undefined,
+  roomId: string,
+): Promise<TriggerContext | undefined> {
+  if (!runtime || typeof runtime.getMemories !== "function") return undefined;
+  let memories: Array<{
+    entityId?: string;
+    metadata?: Record<string, unknown>;
+  }>;
+  try {
+    memories = (await runtime.getMemories({
+      roomId: roomId as never,
+      tableName: "messages",
+      count: 12,
+    } as Parameters<typeof runtime.getMemories>[0])) as Array<{
+      entityId?: string;
+      metadata?: Record<string, unknown>;
+    }>;
+  } catch (err) {
+    logger.debug?.(
+      `[n8n-routes] buildTriggerContextFromConversation: getMemories threw: ${
+        err instanceof Error ? err.message : String(err)
+      }`,
+    );
+    return undefined;
+  }
+  if (!Array.isArray(memories) || memories.length === 0) return undefined;
+
+  // Tail inbound = most recent memory whose entityId is NOT the agent.
+  // `runtime.getMemories` typically returns most-recent-first; defensively
+  // handle either order.
+  const inbound = memories.find(
+    (m) => m.entityId && m.entityId !== runtime.agentId,
+  );
+  if (!inbound?.metadata) return undefined;
+
+  const meta = inbound.metadata as Record<string, unknown>;
+  const discord = (meta.discord ?? {}) as Record<string, unknown>;
+  const telegram = (meta.telegram ?? {}) as Record<string, unknown>;
+  const slack = (meta.slack ?? {}) as Record<string, unknown>;
+
+  // Canonical wins; flat fields are the legacy de-facto shape.
+  const discordChannelId =
+    (typeof discord.channelId === "string" ? discord.channelId : undefined) ??
+    (typeof meta.discordChannelId === "string"
+      ? meta.discordChannelId
+      : undefined);
+  const discordGuildId =
+    (typeof discord.guildId === "string" ? discord.guildId : undefined) ??
+    (typeof meta.discordServerId === "string"
+      ? meta.discordServerId
+      : undefined);
+  const discordThreadId =
+    typeof discord.threadId === "string" ? discord.threadId : undefined;
+
+  const telegramChatId =
+    (typeof telegram.chatId === "string" || typeof telegram.chatId === "number"
+      ? telegram.chatId
+      : undefined) ??
+    (typeof meta.fromId === "string" || typeof meta.fromId === "number"
+      ? (meta.fromId as string | number)
+      : undefined);
+  const telegramThreadId =
+    typeof telegram.threadId === "string" ||
+    typeof telegram.threadId === "number"
+      ? (telegram.threadId as string | number)
+      : undefined;
+
+  const slackChannelId =
+    typeof slack.channelId === "string" ? slack.channelId : undefined;
+  const slackTeamId =
+    typeof slack.teamId === "string" ? slack.teamId : undefined;
+
+  if (discordChannelId) {
+    return {
+      source: "discord",
+      discord: {
+        ...(discordChannelId ? { channelId: discordChannelId } : {}),
+        ...(discordGuildId ? { guildId: discordGuildId } : {}),
+        ...(discordThreadId ? { threadId: discordThreadId } : {}),
+      },
+    };
+  }
+  if (telegramChatId !== undefined) {
+    return {
+      source: "telegram",
+      telegram: {
+        chatId: telegramChatId,
+        ...(telegramThreadId !== undefined
+          ? { threadId: telegramThreadId }
+          : {}),
+      },
+    };
+  }
+  if (slackChannelId) {
+    return {
+      source: "slack",
+      slack: {
+        channelId: slackChannelId,
+        ...(slackTeamId ? { teamId: slackTeamId } : {}),
+      },
+    };
+  }
+  return undefined;
+}
+
 function readPosition(value: unknown): [number, number] | null {
   return Array.isArray(value) &&
     value.length >= 2 &&
@@ -1130,10 +1266,14 @@ async function handleGenerateWorkflow(ctx: N8nRouteContext): Promise<boolean> {
 
   const name = readOptionalString(body, "name");
   const workflowId = readOptionalString(body, "workflowId");
+  const bridgeConversationId = readOptionalString(body, "bridgeConversationId");
 
   const service = ctx.runtime?.getService?.("n8n_workflow") as
     | {
-        generateWorkflowDraft?: (prompt: string) => Promise<{
+        generateWorkflowDraft?: (
+          prompt: string,
+          opts?: { triggerContext?: TriggerContext },
+        ) => Promise<{
           id?: string;
           [k: string]: unknown;
         }>;
@@ -1158,7 +1298,14 @@ async function handleGenerateWorkflow(ctx: N8nRouteContext): Promise<boolean> {
     return true;
   }
 
-  const draft = await service.generateWorkflowDraft(prompt);
+  const triggerContext = bridgeConversationId
+    ? await buildTriggerContextFromConversation(ctx.runtime, bridgeConversationId)
+    : undefined;
+
+  const draft = await service.generateWorkflowDraft(
+    prompt,
+    triggerContext ? { triggerContext } : undefined,
+  );
   if (name?.trim()) {
     (draft as Record<string, unknown>).name = name.trim();
   }

packages/app-core/src/components/pages/AutomationsView.tsx

@@ -4596,6 +4596,7 @@ function AutomationsLayout() {
           prompt,
           ...(title?.trim() ? { name: title.trim() } : {}),
           ...(workflowId ? { workflowId } : {}),
+          ...(bridgeConversationId ? { bridgeConversationId } : {}),
         });
         if (isMissingCredentialsResponse(result)) {
           setMissingCredentials(result.missingCredentials);

packages/app-core/src/services/n8n-runtime-context-provider.ts

@@ -95,10 +95,28 @@ interface PluginNodeDefinition {
   credentials?: Array<{ name: string; required?: boolean }>;
 }
 
+/**
+ * Originating-conversation routing context. Hosts pass this when the workflow
+ * is being generated from inside a platform conversation (e.g. a Discord DM),
+ * so the LLM can target "this channel" / "back to me" without the user
+ * naming an ID.
+ *
+ * Mirrors the shape introduced upstream in `@elizaos/plugin-n8n-workflow` —
+ * the host duplicates the type so it doesn't need to import from the plugin.
+ */
+export interface TriggerContext {
+  source?: string;
+  discord?: { channelId?: string; guildId?: string; threadId?: string };
+  telegram?: { chatId?: string | number; threadId?: string | number };
+  slack?: { channelId?: string; teamId?: string };
+  resolvedNames?: { channel?: string; server?: string };
+}
+
 interface RuntimeContextProviderInput {
   userId: string;
   relevantNodes: PluginNodeDefinition[];
   relevantCredTypes: string[];
+  triggerContext?: TriggerContext;
 }
 
 /**
@@ -209,6 +227,40 @@ export interface MiladyN8nRuntimeContextProviderHandle {
 /** Re-exported for tests + runtime helpers. */
 export { SERVICE_TYPE as N8N_RUNTIME_CONTEXT_PROVIDER_SERVICE_TYPE };
 
+/**
+ * Render a trigger-source fact line the LLM can read as part of the
+ * `## Runtime Facts` block. Returns `undefined` when the trigger context
+ * is empty / has no actionable platform routing info.
+ */
+function formatTriggerContextFact(
+  ctx: TriggerContext | undefined,
+): string | undefined {
+  if (!ctx) return undefined;
+  const channelName = ctx.resolvedNames?.channel;
+  const serverName = ctx.resolvedNames?.server;
+
+  if (ctx.discord?.channelId) {
+    const channelLabel = channelName ? `#${channelName}` : "the channel";
+    const serverPart = ctx.discord.guildId
+      ? serverName
+        ? ` within "${serverName}" (id ${ctx.discord.guildId})`
+        : ` within guild id ${ctx.discord.guildId}`
+      : "";
+    return `This workflow was prompted from a Discord conversation in ${channelLabel} (id ${ctx.discord.channelId})${serverPart}. When the user references "this channel" or "back to here", target that channel ID.`;
+  }
+  if (ctx.telegram?.chatId !== undefined) {
+    return `This workflow was prompted from a Telegram chat (id ${ctx.telegram.chatId}). When the user references "this chat" or "back to here", target that chat ID.`;
+  }
+  if (ctx.slack?.channelId) {
+    const teamPart = ctx.slack.teamId ? ` in team ${ctx.slack.teamId}` : "";
+    return `This workflow was prompted from a Slack channel (id ${ctx.slack.channelId})${teamPart}. When the user references "this channel" or "back to here", target that channel ID.`;
+  }
+  if (ctx.source) {
+    return `This workflow was prompted from a ${ctx.source} conversation.`;
+  }
+  return undefined;
+}
+
 export function startMiladyN8nRuntimeContextProvider(
   runtime: AgentRuntime,
   options: MiladyN8nRuntimeContextProviderOptions,
@@ -389,6 +441,14 @@ export function startMiladyN8nRuntimeContextProvider(
       }
     }
 
+    // Originating-conversation routing fact. Surfaced regardless of which
+    // nodes are in scope — the user might say "post the result back here"
+    // and the relevant node search has no way to anchor that intent.
+    const triggerFact = formatTriggerContextFact(input.triggerContext);
+    if (triggerFact) {
+      facts.push(triggerFact);
+    }
+
     return { supportedCredentials, facts };
   };