@elizaos/plugin-workflow 2.0.0-beta.1 → 2.0.3-beta.6

package/src/services/workflow-dispatch.ts

@@ -27,10 +27,31 @@ export interface WorkflowDispatchResult {
   ok: boolean;
   error?: string;
   executionId?: string;
+  /**
+   * True when the call was short-circuited by an idempotency-key match.
+   * Callers (the trigger dispatcher, dashboards) can record a dedup
+   * instead of treating the call as a fresh execution.
+   */
+  dedup?: boolean;
+}
+
+/**
+ * Optional, structured dispatch options. The `idempotencyKey` field is
+ * the durable contract: same workflow + same key → at most one
+ * execution. Passed inline through the legacy `payload` shape (key
+ * `__idempotencyKey`) when the caller can't pass a second argument.
+ */
+export interface WorkflowDispatchOptions {
+  triggerData?: Record<string, unknown>;
+  idempotencyKey?: string;
 }
 
 export interface WorkflowDispatchService {
-  execute(workflowId: string, payload?: Record<string, unknown>): Promise<WorkflowDispatchResult>;
+  execute(
+    workflowId: string,
+    payload?: Record<string, unknown>,
+    options?: WorkflowDispatchOptions
+  ): Promise<WorkflowDispatchResult>;
 }
 
 interface WorkflowDispatchServiceEntry extends WorkflowDispatchService {
@@ -38,6 +59,24 @@ interface WorkflowDispatchServiceEntry extends WorkflowDispatchService {
   capabilityDescription: string;
 }
 
+/**
+ * Pull `__idempotencyKey` out of the legacy `payload` shape so existing
+ * callers (the trigger dispatcher's `event` payload) can attach a key
+ * without growing the signature. The wrapper key is stripped before the
+ * payload is forwarded as `triggerData`.
+ */
+function partitionPayload(payload: Record<string, unknown> | undefined): {
+  triggerData: Record<string, unknown>;
+  idempotencyKey?: string;
+} {
+  if (!payload) return { triggerData: {} };
+  const { __idempotencyKey, ...rest } = payload;
+  return {
+    triggerData: rest,
+    idempotencyKey: typeof __idempotencyKey === 'string' ? __idempotencyKey : undefined,
+  };
+}
+
 interface RuntimeServiceRegistry {
   set(serviceType: string, services: WorkflowDispatchServiceEntry[]): void;
 }
@@ -71,12 +110,33 @@ function getRuntimeServiceRegistry(runtime: IAgentRuntime): RuntimeServiceRegist
 /**
  * Construct the dispatch service. Registered under `WORKFLOW_DISPATCH` on the
  * runtime by the plugin's `init` lifecycle hook.
+ *
+ * Idempotency contract: when a caller passes an `idempotencyKey` (either via
+ * the explicit `options.idempotencyKey` or via the legacy
+ * `payload.__idempotencyKey`), the dispatch service first looks up an
+ * existing execution row for `(workflowId, idempotencyKey)`. If one exists,
+ * the new run is suppressed and the prior execution id is returned with
+ * `{ ok: true, dedup: true }`. Scheduled workflow dispatches use a
+ * minute-bucketed key so two simultaneous schedule fires collapse to one
+ * execution.
+ *
+ * Concurrent dispatches that race past the lookup are still safely
+ * coalesced because the embedded service persists the idempotency key on
+ * the execution row, so the second-to-write completes but is detectable
+ * as a duplicate on later lookups.
  */
 export function createWorkflowDispatchService(runtime: IAgentRuntime): WorkflowDispatchService {
+  // Track in-flight executions by `(workflowId, idempotencyKey)` so that
+  // two concurrent dispatches inside the same process collapse onto one
+  // run. The map entry resolves once the original run finishes, and the
+  // late caller returns the same execution id.
+  const inflight = new Map<string, Promise<WorkflowDispatchResult>>();
+
   return {
     async execute(
       workflowId: string,
-      _payload: Record<string, unknown> = {}
+      payload: Record<string, unknown> = {},
+      options: WorkflowDispatchOptions = {}
     ): Promise<WorkflowDispatchResult> {
       const id = workflowId.trim();
       if (!id) {
@@ -86,21 +146,64 @@ export function createWorkflowDispatchService(runtime: IAgentRuntime): WorkflowD
       if (!service) {
         return { ok: false, error: 'embedded workflow service not registered' };
       }
-      try {
-        const execution = await service.executeWorkflow(id, { mode: 'trigger' });
-        return execution.id ? { ok: true, executionId: execution.id } : { ok: true };
-      } catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        logger.warn(
-          { src: 'plugin:workflow:dispatch' },
-          `Workflow execution failed for ${id}: ${message}`
-        );
-        return { ok: false, error: message };
+
+      const partitioned = partitionPayload(payload);
+      const triggerData =
+        options.triggerData && Object.keys(options.triggerData).length > 0
+          ? options.triggerData
+          : partitioned.triggerData;
+      const idempotencyKey = options.idempotencyKey ?? partitioned.idempotencyKey;
+
+      if (idempotencyKey) {
+        const existing = await service.findExecutionByIdempotencyKey(id, idempotencyKey);
+        if (existing) {
+          return existing.id
+            ? { ok: true, executionId: existing.id, dedup: true }
+            : { ok: true, dedup: true };
+        }
+
+        const inflightKey = `${id}::${idempotencyKey}`;
+        const pending = inflight.get(inflightKey);
+        if (pending) {
+          const result = await pending;
+          return result.ok ? { ...result, dedup: true } : result;
+        }
+
+        const promise = runDispatch(service, id, triggerData, idempotencyKey).finally(() => {
+          inflight.delete(inflightKey);
+        });
+        inflight.set(inflightKey, promise);
+        return promise;
       }
+
+      return runDispatch(service, id, triggerData, undefined);
     },
   };
 }
 
+async function runDispatch(
+  service: EmbeddedWorkflowService,
+  workflowId: string,
+  triggerData: Record<string, unknown>,
+  idempotencyKey: string | undefined
+): Promise<WorkflowDispatchResult> {
+  try {
+    const execution = await service.executeWorkflow(workflowId, {
+      mode: 'trigger',
+      triggerData,
+      idempotencyKey,
+    });
+    return execution.id ? { ok: true, executionId: execution.id } : { ok: true };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    logger.warn(
+      { src: 'plugin:workflow:dispatch' },
+      `Workflow execution failed for ${workflowId}: ${message}`
+    );
+    return { ok: false, error: message };
+  }
+}
+
 /**
  * Register the dispatch service in the runtime services map under
  * `WORKFLOW_DISPATCH`. Called from the plugin's `init`.
@@ -113,7 +216,7 @@ export function createWorkflowDispatchService(runtime: IAgentRuntime): WorkflowD
 export function registerWorkflowDispatchService(runtime: IAgentRuntime): void {
   const dispatch = createWorkflowDispatchService(runtime);
   const serviceEntry: WorkflowDispatchServiceEntry = {
-    execute: dispatch.execute,
+    execute: dispatch.execute.bind(dispatch),
     stop: async () => {},
     capabilityDescription: 'Executes embedded workflows by id via the in-process workflow service.',
   };

package/src/services/workflow-service.ts

@@ -1,13 +1,16 @@
 import { type IAgentRuntime, logger, Service } from '@elizaos/core';
 import type {
   NodeDefinition,
+  NodeSearchResult,
   RuntimeContext,
   TriggerContext,
   WorkflowCreationResult,
   WorkflowCredentialStoreApi,
   WorkflowDefinition,
   WorkflowDefinitionResponse,
+  WorkflowEvaluationSuite,
   WorkflowExecution,
+  WorkflowRevision,
 } from '../types/index';
 import {
   isCredentialProvider,
@@ -22,6 +25,7 @@ import { filterNodesByIntegrationSupport, searchNodes } from '../utils/catalog';
 import { CATALOG_CLARIFICATION_SUFFIX, isCatalogClarification } from '../utils/clarification';
 import { getUserTagName } from '../utils/context';
 import { resolveCredentials } from '../utils/credentialResolver';
+import { buildWorkflowEvaluationSuite } from '../utils/evaluation-samples';
 import {
   assessFeasibility,
   collectExistingNodeDefinitions,
@@ -39,6 +43,7 @@ import {
   ensureExpressionPrefix,
   injectMissingCredentialBlocks,
   normalizeTriggerSimpleParam,
+  normalizeWorkflowNodeParameterShapes,
   positionNodes,
   validateNodeInputs,
   validateNodeParameters,
@@ -68,6 +73,9 @@ type WorkflowDefinitionClient = Pick<
   | 'deleteWorkflow'
   | 'activateWorkflow'
   | 'deactivateWorkflow'
+  | 'listWorkflowRevisions'
+  | 'restoreWorkflowRevision'
+  | 'executeWorkflow'
   | 'updateWorkflowTags'
   | 'createCredential'
   | 'listExecutions'
@@ -94,6 +102,105 @@ function isWorkflowCredentialStoreApi(service: unknown): service is WorkflowCred
   );
 }
 
+const FIELD_TRANSFORM_VERB_PATTERN =
+  /\b(adds?|adding|sets?|setting|assigns?|assigning|writes?|writing|maps?|mapping|appends?|appending|enrich(?:es|ing)?)\b/;
+const FIELD_TRANSFORM_TARGET_PATTERN =
+  /\b(field|fields|value|values|data|item|items|metadata|json|property|properties)\b/;
+const NETWORK_REQUEST_PATTERN =
+  /\b(http|https|url|api|request|fetch|call|post|get|put|patch|delete|webhook)\b/;
+
+function buildWorkflowSearchKeywords(prompt: string, keywords: string[]): string[] {
+  const normalized = new Set(keywords.map((keyword) => keyword.toLowerCase()));
+  const addKeyword = (keyword: string): void => {
+    if (!normalized.has(keyword)) {
+      keywords.unshift(keyword);
+      normalized.add(keyword);
+    }
+  };
+  const lowerPrompt = prompt.toLowerCase();
+  if (FIELD_TRANSFORM_VERB_PATTERN.test(lowerPrompt)) {
+    if (FIELD_TRANSFORM_TARGET_PATTERN.test(lowerPrompt)) {
+      addKeyword('set');
+    }
+  }
+  return keywords;
+}
+
+function filterPromptCandidateNodes(prompt: string, nodes: NodeSearchResult[]): NodeSearchResult[] {
+  const lowerPrompt = prompt.toLowerCase();
+  const looksLikeFieldTransform =
+    FIELD_TRANSFORM_VERB_PATTERN.test(lowerPrompt) &&
+    FIELD_TRANSFORM_TARGET_PATTERN.test(lowerPrompt);
+  const looksLikeNetworkRequest = NETWORK_REQUEST_PATTERN.test(lowerPrompt);
+  if (!looksLikeFieldTransform || looksLikeNetworkRequest) {
+    return nodes;
+  }
+  return nodes.filter((result) => result.node.name !== 'workflows-nodes-base.httpRequest');
+}
+
+function normalizeGeneratedNodeParameterShapes(
+  workflow: WorkflowDefinition,
+  context: 'generated workflow' | 'modified workflow'
+): void {
+  const fixes = normalizeWorkflowNodeParameterShapes(workflow);
+  if (fixes > 0) {
+    logger.debug(
+      { src: 'plugin:workflow:service:main' },
+      `Normalized ${fixes} node parameter shape(s) in ${context}`
+    );
+  }
+}
+
+/**
+ * Score a workflow against a lowercased query: name beats node type beats
+ * description, and an exact/prefix name match beats a substring. Returns 0 for
+ * no match. Pure + exported so the ranking is unit-testable without a DB.
+ */
+export function scoreWorkflowMatch(workflow: WorkflowDefinitionResponse, query: string): number {
+  const q = query.trim().toLowerCase();
+  if (!q) return 0;
+  const name = String(workflow.name ?? '').toLowerCase();
+  let score = 0;
+  if (name === q) score += 100;
+  else if (name.startsWith(q)) score += 50;
+  else if (name.includes(q)) score += 30;
+
+  const nodes = (workflow as { nodes?: Array<{ type?: unknown; name?: unknown }> }).nodes;
+  if (Array.isArray(nodes)) {
+    for (const node of nodes) {
+      const type = String(node?.type ?? '').toLowerCase();
+      const nodeName = String(node?.name ?? '').toLowerCase();
+      if (type.includes(q) || nodeName.includes(q)) {
+        score += 10;
+        break;
+      }
+    }
+  }
+
+  const description = String(
+    (workflow as { description?: unknown }).description ?? ''
+  ).toLowerCase();
+  if (description.includes(q)) score += 5;
+
+  return score;
+}
+
+/**
+ * Rank workflows best-match-first for a free-text query, dropping non-matches.
+ * An empty query returns the input order unchanged. Pure + exported (#8913).
+ */
+export function rankWorkflowsByQuery(
+  workflows: WorkflowDefinitionResponse[],
+  query: string
+): WorkflowDefinitionResponse[] {
+  if (!query.trim()) return workflows;
+  return workflows
+    .map((workflow) => ({ workflow, score: scoreWorkflowMatch(workflow, query) }))
+    .filter((entry) => entry.score > 0)
+    .sort((a, b) => b.score - a.score)
+    .map((entry) => entry.workflow);
+}
+
 /**
  * Workflow Service - Orchestrates the RAG pipeline for workflow generation.
  *
@@ -115,7 +222,7 @@ export class WorkflowService extends Service {
 
     // Get optional pre-configured credentials from character.settings.workflows
     // Note: runtime.getSetting() only returns primitives — nested objects must be read directly
-    const workflowSettings = runtime.character?.settings?.workflows as
+    const workflowSettings = runtime.character.settings?.workflows as
       | { credentials?: Record<string, string> }
       | undefined;
     const credentials = workflowSettings?.credentials;
@@ -283,21 +390,26 @@ export class WorkflowService extends Service {
 
     // Fetch host-supplied bias hints early (before keyword extraction) so the
     // LLM is told which providers the host already knows it can satisfy.
-    // We pass empty `relevantNodes` / `relevantCredTypes` here because we do
-    // not yet have searchNodes results — `preferredProviders` is derived from
-    // the host's connector config alone (independent of node search). The
+    // We pass empty `relevantNodes` / `relevantCredTypes` here before
+    // node-catalog search runs: `preferredProviders` is derived from the
+    // host's connector config alone (independent of node search). The
     // full runtime context (with credentials + facts) is fetched again later
     // once we have the filtered node list.
     const earlyContext = await this.fetchRuntimeContext([], opts?.userId ?? 'local');
     const preferredProviders = earlyContext?.preferredProviders;
 
-    const keywords = await extractKeywords(this.runtime, prompt, preferredProviders);
+    const keywords = buildWorkflowSearchKeywords(
+      prompt,
+      await extractKeywords(this.runtime, prompt, preferredProviders)
+    );
     logger.debug(
       { src: 'plugin:workflow:service:main' },
       `Extracted keywords: ${keywords.join(', ')}${preferredProviders?.length ? ` (with bias: ${preferredProviders.join(', ')})` : ''}`
     );
 
-    let relevantNodes = this.filterForEmbeddedBackend(searchNodes(keywords, 15));
+    let relevantNodes = this.filterForEmbeddedBackend(
+      filterPromptCandidateNodes(prompt, searchNodes(keywords, 15))
+    );
     logger.debug(
       { src: 'plugin:workflow:service:main' },
       `Found ${relevantNodes.length} relevant nodes`
@@ -369,7 +481,7 @@ export class WorkflowService extends Service {
     let workflow = await generateWorkflow(this.runtime, prompt, finalNodeDefs, runtimeContext);
     logger.debug(
       { src: 'plugin:workflow:service:main' },
-      `Generated workflow with ${workflow.nodes?.length || 0} nodes`
+      `Generated workflow with ${workflow.nodes.length || 0} nodes`
     );
 
     // Safety net: even with the MANDATORY INVARIANT prompt rule, the LLM
@@ -448,6 +560,7 @@ export class WorkflowService extends Service {
     }
 
     normalizeTriggerSimpleParam(workflow);
+    normalizeGeneratedNodeParameterShapes(workflow, 'generated workflow');
 
     const optionFixes = correctOptionParameters(workflow);
     if (optionFixes > 0) {
@@ -464,6 +577,7 @@ export class WorkflowService extends Service {
         `Found ${unknownParams.length} node(s) with unknown parameters, auto-correcting...`
       );
       workflow = await correctParameterNames(this.runtime, workflow, unknownParams);
+      normalizeGeneratedNodeParameterShapes(workflow, 'generated workflow');
     }
 
     const invalidRefs = validateOutputReferences(workflow);
@@ -473,6 +587,7 @@ export class WorkflowService extends Service {
         `Found ${invalidRefs.length} invalid field reference(s), auto-correcting...`
       );
       workflow = await correctFieldReferences(this.runtime, workflow, invalidRefs);
+      normalizeGeneratedNodeParameterShapes(workflow, 'generated workflow');
     }
 
     const exprPrefixed = ensureExpressionPrefix(workflow);
@@ -516,8 +631,13 @@ export class WorkflowService extends Service {
     const existingDefs = collectExistingNodeDefinitions(existingWorkflow);
 
     // Search for new nodes the modification might need
-    const keywords = await extractKeywords(this.runtime, modificationRequest);
-    const searchResults = this.filterForEmbeddedBackend(searchNodes(keywords, 10));
+    const keywords = buildWorkflowSearchKeywords(
+      modificationRequest,
+      await extractKeywords(this.runtime, modificationRequest)
+    );
+    const searchResults = this.filterForEmbeddedBackend(
+      filterPromptCandidateNodes(modificationRequest, searchNodes(keywords, 10))
+    );
     const newDefs = searchResults.map((r) => r.node);
 
     // Deduplicate: merge existing + new, preferring existing (already in workflow)
@@ -615,6 +735,7 @@ export class WorkflowService extends Service {
     }
 
     normalizeTriggerSimpleParam(workflow);
+    normalizeGeneratedNodeParameterShapes(workflow, 'modified workflow');
 
     const optionFixes = correctOptionParameters(workflow);
     if (optionFixes > 0) {
@@ -631,6 +752,7 @@ export class WorkflowService extends Service {
         `Found ${unknownParams.length} node(s) with unknown parameters in modified workflow, auto-correcting...`
       );
       workflow = await correctParameterNames(this.runtime, workflow, unknownParams);
+      normalizeGeneratedNodeParameterShapes(workflow, 'modified workflow');
     }
 
     const invalidRefs = validateOutputReferences(workflow);
@@ -640,6 +762,7 @@ export class WorkflowService extends Service {
         `Found ${invalidRefs.length} invalid field reference(s) in modified workflow, auto-correcting...`
       );
       workflow = await correctFieldReferences(this.runtime, workflow, invalidRefs);
+      normalizeGeneratedNodeParameterShapes(workflow, 'modified workflow');
     }
 
     const exprPrefixed = ensureExpressionPrefix(workflow);
@@ -767,7 +890,7 @@ export class WorkflowService extends Service {
       id: deployedWorkflow.id,
       name: deployedWorkflow.name,
       active,
-      nodeCount: deployedWorkflow.nodes?.length || 0,
+      nodeCount: deployedWorkflow.nodes.length || 0,
       missingCredentials: credentialResult.missingConnections,
     };
   }
@@ -793,6 +916,16 @@ export class WorkflowService extends Service {
     return response.data;
   }
 
+  /**
+   * Free-text search over the user's workflows by name, node type, and
+   * description, ranked best-match-first (#8913). Lets a user find "the Slack
+   * workflow" from a chat message without knowing its id.
+   */
+  async searchWorkflows(query: string, userId?: string): Promise<WorkflowDefinitionResponse[]> {
+    const workflows = await this.listWorkflows(userId);
+    return rankWorkflowsByQuery(workflows, query);
+  }
+
   async activateWorkflow(workflowId: string): Promise<void> {
     const client = this.getClient();
     await client.activateWorkflow(workflowId);
@@ -816,12 +949,55 @@ export class WorkflowService extends Service {
     return client.getWorkflow(workflowId);
   }
 
+  async listWorkflowRevisions(workflowId: string, limit?: number): Promise<WorkflowRevision[]> {
+    const client = this.getClient();
+    const response = await client.listWorkflowRevisions(workflowId, limit);
+    return response.data;
+  }
+
+  async restoreWorkflowRevision(
+    workflowId: string,
+    versionId: string
+  ): Promise<WorkflowDefinitionResponse> {
+    const client = this.getClient();
+    return client.restoreWorkflowRevision(workflowId, versionId);
+  }
+
+  async runWorkflow(
+    workflowId: string,
+    options?: {
+      mode?: WorkflowExecution['mode'];
+      triggerData?: Record<string, unknown>;
+      idempotencyKey?: string;
+      throwOnError?: boolean;
+    }
+  ): Promise<WorkflowExecution> {
+    const client = this.getClient();
+    return client.executeWorkflow(workflowId, {
+      mode: options?.mode ?? 'manual',
+      triggerData: options?.triggerData,
+      idempotencyKey: options?.idempotencyKey,
+      throwOnError: options?.throwOnError,
+    });
+  }
+
   async getWorkflowExecutions(workflowId: string, limit?: number): Promise<WorkflowExecution[]> {
     const client = this.getClient();
     const response = await client.listExecutions({ workflowId, limit });
     return response.data;
   }
 
+  async getWorkflowEvaluationSuite(
+    workflowId: string,
+    limit?: number
+  ): Promise<WorkflowEvaluationSuite> {
+    const [workflow, executions] = await Promise.all([
+      this.getWorkflow(workflowId),
+      this.getWorkflowExecutions(workflowId, limit),
+    ]);
+    return buildWorkflowEvaluationSuite(workflow, executions, { limit });
+  }
+
   async listExecutions(params?: {
     workflowId?: string;
     status?: 'canceled' | 'error' | 'running' | 'success' | 'waiting';

package/src/trigger-routes.ts

@@ -84,8 +84,8 @@ export interface NormalizedTriggerDraft {
   cronExpression?: string;
   eventKind?: string;
   maxRuns?: number;
-  kind?: TriggerKind;
-  workflowId?: string;
+  kind: TriggerKind;
+  workflowId: string;
   workflowName?: string;
 }
 
@@ -107,17 +107,6 @@ export interface TriggerExecutionResult {
   executionId?: string;
 }
 
-export interface TextTriggerWorkflowDraft {
-  displayName: string;
-  instructions: string;
-  wakeMode: TriggerWakeMode;
-}
-
-export interface DeployedTriggerWorkflow {
-  id: string;
-  name: string;
-}
-
 interface TriggerDraftInput {
   displayName?: string;
   instructions?: string;
@@ -173,17 +162,6 @@ export interface TriggerRouteContext extends RouteRequestContext {
     input: TriggerDraftInput;
     fallback: NormalizeTriggerDraftFallback;
   }) => { draft?: NormalizedTriggerDraft; error?: string };
-  /**
-   * Phase 2E: every persisted trigger is `kind: "workflow"`. When the
-   * caller submits `kind: "text"` (or omits `kind`), the route uses this
-   * to materialize a single-node `respondToEvent` workflow first, then
-   * stores the trigger as `kind: "workflow"` pointing at that workflow.
-   */
-  deployTextTriggerWorkflow: (
-    runtime: IAgentRuntime,
-    draft: TextTriggerWorkflowDraft,
-    ownerId: string
-  ) => Promise<DeployedTriggerWorkflow | null>;
   DISABLED_TRIGGER_INTERVAL_MS: number;
   TRIGGER_TASK_NAME: string;
   TRIGGER_TASK_TAGS: string[];
@@ -194,7 +172,7 @@ function trim(value: string): string {
 }
 
 function parseTriggerKind(value: unknown): TriggerKind | undefined {
-  if (value === 'text' || value === 'workflow') return value;
+  if (value === 'workflow') return value;
   return undefined;
 }
 
@@ -202,8 +180,8 @@ type ParsedTriggerKind = { ok: true; kind: TriggerKind } | { ok: false; error: s
 
 function parseTriggerKindStrict(value: unknown): ParsedTriggerKind | undefined {
   if (value === undefined) return undefined;
-  if (value === 'text' || value === 'workflow') return { ok: true, kind: value };
-  return { ok: false, error: "kind must be 'text' or 'workflow'" };
+  if (value === 'workflow') return { ok: true, kind: value };
+  return { ok: false, error: "kind must be 'workflow'" };
 }
 
 function parseNonEmptyString(value: unknown): string | undefined {
@@ -276,7 +254,6 @@ export async function handleTriggerRoutes(ctx: TriggerRouteContext): Promise<boo
     buildTriggerConfig,
     buildTriggerMetadata,
     normalizeTriggerDraft,
-    deployTextTriggerWorkflow,
     DISABLED_TRIGGER_INTERVAL_MS,
     TRIGGER_TASK_NAME,
     TRIGGER_TASK_TAGS,
@@ -315,7 +292,7 @@ export async function handleTriggerRoutes(ctx: TriggerRouteContext): Promise<boo
     const triggers = tasks
       .map(taskToTriggerSummary)
       .filter((summary): summary is TriggerSummary => summary !== null)
-      .sort((a, b) => String(a.displayName ?? '').localeCompare(String(b.displayName ?? '')));
+      .sort((a, b) => String(a.displayName).localeCompare(String(b.displayName)));
     listResponse(triggers);
     return true;
   }
@@ -330,49 +307,14 @@ export async function handleTriggerRoutes(ctx: TriggerRouteContext): Promise<boo
       error(res, kindParsed.error, 400);
       return true;
     }
-    const requestedKind: TriggerKind | undefined = kindParsed?.ok ? kindParsed.kind : undefined;
-    let workflowId = parseNonEmptyString(body.workflowId);
-    let workflowName = parseNonEmptyString(body.workflowName);
-    if (requestedKind === 'workflow' && !workflowId) {
+    const requestedKind: TriggerKind = kindParsed?.ok ? kindParsed.kind : 'workflow';
+    const workflowId = parseNonEmptyString(body.workflowId);
+    const workflowName = parseNonEmptyString(body.workflowName);
+    if (!workflowId) {
       error(res, "workflowId is required when kind is 'workflow'", 400);
       return true;
     }
 
-    // Phase 2E: when the client submits `kind: "text"` or omits `kind`,
-    // materialize a single-node `respondToEvent` workflow up front so the
-    // persisted trigger is always `kind: "workflow"`.
-    if (requestedKind !== 'workflow') {
-      const rawDisplayName =
-        typeof body.displayName === 'string' && trim(body.displayName)
-          ? trim(body.displayName)
-          : 'New Trigger';
-      const rawInstructions = typeof body.instructions === 'string' ? trim(body.instructions) : '';
-      if (!rawInstructions) {
-        error(res, 'instructions is required', 400);
-        return true;
-      }
-      const wakeModeForWorkflow: TriggerWakeMode =
-        typeof body.wakeMode === 'string' && body.wakeMode === 'next_autonomy_cycle'
-          ? 'next_autonomy_cycle'
-          : 'inject_now';
-      const deployed = await deployTextTriggerWorkflow(
-        runtime,
-        {
-          displayName: rawDisplayName,
-          instructions: rawInstructions,
-          wakeMode: wakeModeForWorkflow,
-        },
-        creator
-      );
-      if (!deployed) {
-        error(res, 'Workflow plugin is not loaded; cannot create text triggers.', 503);
-        return true;
-      }
-      workflowId = deployed.id;
-      workflowName = deployed.name;
-    }
-
-    const kind: TriggerKind = 'workflow';
     const inputDraft: TriggerDraftInput = {
       displayName: typeof body.displayName === 'string' ? body.displayName : undefined,
       instructions: typeof body.instructions === 'string' ? body.instructions : undefined,
@@ -387,7 +329,7 @@ export async function handleTriggerRoutes(ctx: TriggerRouteContext): Promise<boo
       cronExpression: typeof body.cronExpression === 'string' ? body.cronExpression : undefined,
       eventKind: typeof body.eventKind === 'string' ? body.eventKind : undefined,
       maxRuns: typeof body.maxRuns === 'number' ? body.maxRuns : undefined,
-      kind,
+      kind: requestedKind,
       workflowId,
       workflowName,
     };
@@ -615,7 +557,7 @@ export async function handleTriggerRoutes(ctx: TriggerRouteContext): Promise<boo
       return true;
     }
     const parsedKind: TriggerKind | undefined = kindParsed?.ok ? kindParsed.kind : undefined;
-    const nextKind: TriggerKind | undefined = parsedKind ?? parseTriggerKind(current.kind);
+    const nextKind: TriggerKind = parsedKind ?? parseTriggerKind(current.kind) ?? 'workflow';
     const nextWorkflowId = parseNonEmptyString(body.workflowId) ?? current.workflowId;
     const nextWorkflowName = parseNonEmptyString(body.workflowName) ?? current.workflowName;
     if (nextKind === 'workflow' && !nextWorkflowId) {