@mastra/inngest 1.2.2 → 1.3.0-alpha.0

package/dist/index.js

@@ -1,6 +1,6 @@
 import { MessageList, Agent, TripWire } from '@mastra/core/agent';
 import { getErrorFromUnknown, MastraError, ErrorDomain, ErrorCategory } from '@mastra/core/error';
-import { EntityType, SpanType } from '@mastra/core/observability';
+import { EntityType, SpanType, InternalSpans } from '@mastra/core/observability';
 import { ProcessorStepOutputSchema, ProcessorStepSchema, ProcessorRunner } from '@mastra/core/processors';
 import { toStandardSchema } from '@mastra/core/schema';
 import { createTool, Tool } from '@mastra/core/tools';
@@ -8,10 +8,11 @@ import { DefaultExecutionEngine, createTimeTravelExecutionParams, Run, hydrateSe
 import { PUBSUB_SYMBOL, STREAM_FORMAT_SYMBOL } from '@mastra/core/workflows/_constants';
 import { z } from 'zod';
 import { randomUUID } from 'crypto';
+import { modelConfigSchema, baseIterationStateSchema, emitErrorEvent, createDurableLLMExecutionStep, createDurableToolCallStep, createDurableLLMMappingStep, createDurableBackgroundTaskCheckStep, DurableStepIds, createBaseIterationStateUpdate, durableAgenticOutputSchema, emitFinishEvent, createDurableAgentStream, prepareForDurableExecution, DurableAgentDefaults } from '@mastra/core/agent/durable';
 import { RequestContext } from '@mastra/core/di';
 import { NonRetriableError } from 'inngest';
 import { subscribe } from '@inngest/realtime';
-import { PubSub } from '@mastra/core/events';
+import { PubSub, CachingPubSub } from '@mastra/core/events';
 import { ReadableStream } from 'stream/web';
 import { ChunkFrom, WorkflowRunOutput } from '@mastra/core/stream';
 import { context } from '@opentelemetry/api';
@@ -228,7 +229,8 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
       const span = observability.startSpan({
         ...options,
         traceId: executionContext.tracingIds?.traceId,
-        parentSpanId
+        parentSpanId,
+        tracingPolicy: this.options?.tracingPolicy
       });
       return span?.exportSpan();
     });
@@ -516,6 +518,17 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
     };
   }
 };
+function parseTopic(topic) {
+  const workflowMatch = topic.match(/^workflow\.events\.v2\.(.+)$/);
+  if (workflowMatch && workflowMatch[1]) {
+    return { runId: workflowMatch[1], topicType: "workflow" };
+  }
+  const agentMatch = topic.match(/^agent\.stream\.(.+)$/);
+  if (agentMatch && agentMatch[1]) {
+    return { runId: agentMatch[1], topicType: "agent" };
+  }
+  return null;
+}
 var InngestPubSub = class extends PubSub {
   inngest;
   workflowId;
@@ -530,60 +543,84 @@ var InngestPubSub = class extends PubSub {
   /**
    * Publish an event to Inngest's realtime system.
    *
-   * Topic format: "workflow.events.v2.{runId}"
-   * Maps to Inngest channel: "workflow:{workflowId}:{runId}"
+   * Supported topic formats:
+   * - "workflow.events.v2.{runId}" - workflow events
+   *   -> channel: "workflow:{workflowId}:{runId}", topic: "watch"
+   * - "agent.stream.{runId}" - agent stream events
+   *   -> channel: "agent:{runId}", topic: "agent-stream"
+   *   (Note: agent stream uses runId-only channel so nested workflows can publish to same channel)
    */
   async publish(topic, event) {
     if (!this.publishFn) {
       return;
     }
-    const match = topic.match(/^workflow\.events\.v2\.(.+)$/);
-    if (!match) {
+    const parsed = parseTopic(topic);
+    if (!parsed) {
       return;
     }
-    const runId = match[1];
+    const { runId, topicType } = parsed;
+    const inngestTopic = topicType === "agent" ? "agent-stream" : "watch";
+    const channel = topicType === "agent" ? `agent:${runId}` : `workflow:${this.workflowId}:${runId}`;
     try {
+      const dataToSend = topicType === "agent" ? event : event.data;
       await this.publishFn({
-        channel: `workflow:${this.workflowId}:${runId}`,
-        topic: "watch",
-        data: event.data
+        channel,
+        topic: inngestTopic,
+        data: dataToSend
       });
     } catch (err) {
+      if (topicType === "agent" && (event.type === "finish" || event.type === "error")) {
+        throw err;
+      }
       console.error("InngestPubSub publish error:", err?.message ?? err);
     }
   }
   /**
    * Subscribe to events from Inngest's realtime system.
    *
-   * Topic format: "workflow.events.v2.{runId}"
-   * Maps to Inngest channel: "workflow:{workflowId}:{runId}"
+   * Supported topic formats:
+   * - "workflow.events.v2.{runId}" - workflow events
+   *   -> channel: "workflow:{workflowId}:{runId}", topic: "watch"
+   * - "agent.stream.{runId}" - agent stream events
+   *   -> channel: "agent:{runId}", topic: "agent-stream"
+   *   (Note: agent stream uses runId-only channel so nested workflows can publish to same channel)
    */
   async subscribe(topic, cb) {
-    const match = topic.match(/^workflow\.events\.v2\.(.+)$/);
-    if (!match || !match[1]) {
+    const parsed = parseTopic(topic);
+    if (!parsed) {
       return;
     }
-    const runId = match[1];
+    const { runId, topicType } = parsed;
     if (this.subscriptions.has(topic)) {
       this.subscriptions.get(topic).callbacks.add(cb);
       return;
     }
     const callbacks = /* @__PURE__ */ new Set([cb]);
-    const channel = `workflow:${this.workflowId}:${runId}`;
-    const streamPromise = subscribe(
+    const inngestTopic = topicType === "agent" ? "agent-stream" : "watch";
+    const channel = topicType === "agent" ? `agent:${runId}` : `workflow:${this.workflowId}:${runId}`;
+    const stream = await subscribe(
       {
         channel,
-        topics: ["watch"],
+        topics: [inngestTopic],
         app: this.inngest
       },
       (message) => {
-        const event = {
-          id: crypto.randomUUID(),
-          type: "watch",
-          runId,
-          data: message.data,
-          createdAt: /* @__PURE__ */ new Date()
-        };
+        let event;
+        if (topicType === "agent" && message.data?.type && message.data?.runId) {
+          event = {
+            id: crypto.randomUUID(),
+            createdAt: /* @__PURE__ */ new Date(),
+            ...message.data
+          };
+        } else {
+          event = {
+            id: crypto.randomUUID(),
+            type: inngestTopic,
+            runId,
+            data: message.data,
+            createdAt: /* @__PURE__ */ new Date()
+          };
+        }
         for (const callback of callbacks) {
           callback(event);
         }
@@ -591,9 +628,11 @@ var InngestPubSub = class extends PubSub {
     );
     this.subscriptions.set(topic, {
       unsubscribe: () => {
-        streamPromise.then((stream) => stream.cancel()).catch((err) => {
+        try {
+          void stream.cancel();
+        } catch (err) {
           console.error("InngestPubSub unsubscribe error:", err);
-        });
+        }
       },
       callbacks
     });
@@ -1575,13 +1614,26 @@ var InngestWorkflow = class _InngestWorkflow extends Workflow {
               }
             }
           });
-        } catch (error) {
-          throw error;
+        } catch (executionError) {
+          result = {
+            status: "failed",
+            steps: {},
+            state: initialState ?? {},
+            error: executionError instanceof Error ? executionError : new Error(String(executionError))
+          };
         }
         let finalizeError;
         let finalizeErrored = false;
         try {
           await step.run(`workflow.${this.id}.finalize`, async () => {
+            if (result.status === "failed" && inputData?.__workflowKind === "durable-agent" && inputData?.runId) {
+              const error = result.error instanceof Error ? result.error : new Error(String(result.error));
+              try {
+                await emitErrorEvent(pubsub, inputData.runId, error);
+              } catch (e) {
+                this.logger.debug?.("Failed to emit error event:", e);
+              }
+            }
             if (result.status !== "paused") {
               await engine.invokeLifecycleCallbacksInternal({
                 status: result.status,
@@ -1750,6 +1802,560 @@ var serve = createServe(serve$1);
 
 // src/types.ts
 var _compatibilityCheck = true;
+var durableAgenticInputSchema = z.object({
+  runId: z.string(),
+  agentId: z.string(),
+  agentName: z.string().optional(),
+  messageListState: z.any(),
+  toolsMetadata: z.array(z.any()),
+  modelConfig: modelConfigSchema,
+  options: z.any(),
+  state: z.any(),
+  messageId: z.string(),
+  // Observability fields (Inngest-specific)
+  agentSpanData: z.any().optional(),
+  modelSpanData: z.any().optional(),
+  stepIndex: z.number().optional()
+});
+var iterationStateSchema = baseIterationStateSchema.extend({
+  // Observability - exported span data for agent run
+  agentSpanData: z.any().optional(),
+  // Observability - exported span data for model generation (ONE span for entire run)
+  modelSpanData: z.any().optional(),
+  // Step index for continuation across iterations (maintains step: 0, 1, 2, ...)
+  stepIndex: z.number()
+});
+var INNGEST_ENGINE_PREFIX = "inngest";
+var InngestDurableStepIds = {
+  AGENTIC_EXECUTION: `${INNGEST_ENGINE_PREFIX}:${DurableStepIds.AGENTIC_EXECUTION}`,
+  AGENTIC_LOOP: `${INNGEST_ENGINE_PREFIX}:${DurableStepIds.AGENTIC_LOOP}`
+};
+function createInngestDurableAgenticWorkflow(options) {
+  const { inngest, maxSteps = DurableAgentDefaults.MAX_STEPS } = options;
+  const { createWorkflow } = init(inngest);
+  const llmExecutionStep = createDurableLLMExecutionStep();
+  const toolCallStep = createDurableToolCallStep();
+  const llmMappingStep = createDurableLLMMappingStep();
+  const backgroundTaskCheckStep = createDurableBackgroundTaskCheckStep();
+  const singleIterationWorkflow = createWorkflow({
+    id: InngestDurableStepIds.AGENTIC_EXECUTION,
+    inputSchema: iterationStateSchema,
+    outputSchema: iterationStateSchema,
+    options: {
+      tracingPolicy: {
+        // Mark all workflow spans as internal so they're hidden in traces
+        // This makes the trace structure match regular agents (agent_run -> model_generation -> tool_call)
+        internal: InternalSpans.WORKFLOW
+      },
+      shouldPersistSnapshot: ({ workflowStatus }) => workflowStatus === "suspended",
+      validateInputs: false
+    },
+    steps: []
+  }).map(
+    async ({ inputData }) => {
+      const state = inputData;
+      return {
+        runId: state.runId,
+        agentId: state.agentId,
+        agentName: state.agentName,
+        messageListState: state.messageListState,
+        toolsMetadata: state.toolsMetadata,
+        modelConfig: state.modelConfig,
+        options: state.options,
+        state: state.state,
+        messageId: state.messageId,
+        // Pass agent span data so model spans can use it as parent
+        agentSpanData: state.agentSpanData,
+        // Pass model span data (ONE span for entire agent run)
+        modelSpanData: state.modelSpanData,
+        // Pass step index for continuation (step: 0, 1, 2, ...)
+        stepIndex: state.stepIndex
+      };
+    },
+    { id: "map-to-llm-input" }
+  ).then(llmExecutionStep).map(
+    async ({ inputData }) => {
+      const llmOutput = inputData;
+      return llmOutput.toolCalls ?? [];
+    },
+    { id: "extract-tool-calls" }
+  ).foreach(toolCallStep).map(
+    async ({ inputData, getStepResult, getInitData, mastra }) => {
+      const toolResults = inputData;
+      const llmOutput = getStepResult(llmExecutionStep.id);
+      const initData = getInitData();
+      const observability = mastra?.observability?.getSelectedInstance({});
+      const modelSpanData = llmOutput?.modelSpanData;
+      const stepSpanData = llmOutput?.stepSpanData;
+      const modelSpan = modelSpanData ? observability?.rebuildSpan(modelSpanData) : void 0;
+      const stepSpan = stepSpanData ? observability?.rebuildSpan(stepSpanData) : void 0;
+      const agentSpan = initData.agentSpanData ? observability?.rebuildSpan(initData.agentSpanData) : void 0;
+      const toolParentSpan = stepSpan ?? modelSpan ?? agentSpan;
+      for (const tr of toolResults) {
+        const toolSpan = toolParentSpan?.createChildSpan({
+          type: SpanType.TOOL_CALL,
+          name: `tool: '${tr.toolName}'`,
+          entityType: EntityType.TOOL,
+          entityId: tr.toolName,
+          entityName: tr.toolName,
+          input: tr.args
+        });
+        if (tr.error) {
+          toolSpan?.error({ error: new Error(tr.error.message) });
+        } else {
+          toolSpan?.end({ output: tr.result });
+        }
+        if (!tr.error) {
+          stepSpan?.createEventSpan({
+            type: SpanType.MODEL_CHUNK,
+            name: `chunk: 'tool-result'`,
+            output: {
+              toolCallId: tr.toolCallId,
+              toolName: tr.toolName,
+              result: tr.result
+            }
+          });
+        }
+      }
+      const toolCalls = llmOutput?.toolCalls ?? [];
+      if (stepSpan) {
+        const stepFinishPayload = llmOutput.stepFinishPayload;
+        stepSpan.end({
+          output: {
+            toolCalls: toolCalls.map((tc) => ({
+              toolCallId: tc.toolCallId,
+              toolName: tc.toolName,
+              args: tc.args
+            })),
+            toolResults: toolResults.map((tr) => ({
+              toolCallId: tr.toolCallId,
+              toolName: tr.toolName,
+              result: tr.result,
+              error: tr.error
+            }))
+          },
+          attributes: {
+            usage: stepFinishPayload?.output?.usage,
+            finishReason: stepFinishPayload?.stepResult?.reason,
+            isContinued: stepFinishPayload?.stepResult?.isContinued
+          }
+        });
+      }
+      return {
+        llmOutput,
+        toolResults,
+        runId: initData.runId,
+        agentId: initData.agentId,
+        messageId: initData.messageId,
+        state: llmOutput?.state ?? initData.state
+      };
+    },
+    { id: "collect-tool-results" }
+  ).then(llmMappingStep).then(backgroundTaskCheckStep).map(
+    async ({ inputData, getInitData }) => {
+      const executionOutput = inputData;
+      const initData = getInitData();
+      const baseUpdate = createBaseIterationStateUpdate({
+        currentState: initData,
+        executionOutput
+      });
+      const newIterationState = {
+        ...baseUpdate,
+        // Preserve agent span data for observability
+        agentSpanData: initData.agentSpanData,
+        // Preserve model span data (ONE span for entire agent run)
+        modelSpanData: initData.modelSpanData,
+        // Increment step index for next iteration (step: 0 → 1 → 2 → ...)
+        stepIndex: initData.stepIndex + 1
+      };
+      return newIterationState;
+    },
+    { id: "update-iteration-state" }
+  ).commit();
+  return createWorkflow({
+    id: InngestDurableStepIds.AGENTIC_LOOP,
+    inputSchema: durableAgenticInputSchema,
+    outputSchema: durableAgenticOutputSchema,
+    options: {
+      tracingPolicy: {
+        // Mark all workflow spans as internal so they're hidden in traces
+        // This makes the trace structure match regular agents (agent_run -> model_generation -> tool_call)
+        internal: InternalSpans.WORKFLOW
+      },
+      shouldPersistSnapshot: ({ workflowStatus }) => workflowStatus === "suspended",
+      validateInputs: false
+    },
+    steps: []
+  }).map(
+    async ({ inputData }) => {
+      const input = inputData;
+      const agentSpanData = input.agentSpanData;
+      const modelSpanData = input.modelSpanData;
+      const iterationState = {
+        ...input,
+        iterationCount: 0,
+        accumulatedSteps: [],
+        accumulatedUsage: {
+          inputTokens: 0,
+          outputTokens: 0,
+          totalTokens: 0
+        },
+        lastStepResult: void 0,
+        agentSpanData,
+        modelSpanData,
+        stepIndex: input.stepIndex ?? 0
+      };
+      return iterationState;
+    },
+    { id: "init-iteration-state" }
+  ).dowhile(singleIterationWorkflow, async ({ inputData }) => {
+    const state = inputData;
+    const shouldContinue = state.lastStepResult?.isContinued === true;
+    const effectiveMaxSteps = state.options?.maxSteps ?? maxSteps;
+    const underMaxSteps = state.iterationCount < effectiveMaxSteps;
+    return shouldContinue && underMaxSteps;
+  }).map(
+    async (params) => {
+      const { inputData, mastra } = params;
+      const state = inputData;
+      const pubsub = params[PUBSUB_SYMBOL];
+      const lastStep = state.accumulatedSteps[state.accumulatedSteps.length - 1];
+      const finalText = lastStep?.text;
+      const finalOutput = {
+        messageListState: state.messageListState,
+        messageId: state.messageId,
+        stepResult: state.lastStepResult || {
+          reason: "stop",
+          warnings: [],
+          isContinued: false
+        },
+        output: {
+          text: finalText,
+          usage: state.accumulatedUsage,
+          steps: state.accumulatedSteps
+        },
+        state: state.state
+      };
+      const observability = mastra?.observability?.getSelectedInstance({});
+      if (state.modelSpanData) {
+        const modelSpan = observability?.rebuildSpan(state.modelSpanData);
+        modelSpan?.end({
+          output: {
+            text: finalText,
+            usage: state.accumulatedUsage
+          },
+          attributes: {
+            finishReason: state.lastStepResult?.reason || "stop"
+          }
+        });
+      }
+      if (state.agentSpanData) {
+        const agentSpan = observability?.rebuildSpan(state.agentSpanData);
+        agentSpan?.end({
+          output: finalOutput.output
+        });
+      }
+      if (pubsub) {
+        await emitFinishEvent(pubsub, state.runId, {
+          output: finalOutput.output,
+          stepResult: finalOutput.stepResult
+        });
+      }
+      return finalOutput;
+    },
+    { id: "map-final-output" }
+  ).commit();
+}
+
+// src/durable-agent/create-inngest-agent.ts
+function createInngestAgent(options) {
+  const {
+    agent,
+    inngest,
+    id: idOverride,
+    name: nameOverride,
+    pubsub: customPubsub,
+    cache,
+    mastra: mastraOption
+  } = options;
+  const agentId = idOverride ?? agent.id;
+  const agentName = nameOverride ?? agent.name;
+  let mastra = mastraOption;
+  const workflow = createInngestDurableAgenticWorkflow({ inngest });
+  let _customCache = cache;
+  let innerPubsub = customPubsub ?? new InngestPubSub(inngest, InngestDurableStepIds.AGENTIC_LOOP);
+  let _cachingPubsub = null;
+  function getPubsub() {
+    if (!_cachingPubsub) {
+      const resolvedCache = _customCache ?? mastra?.serverCache;
+      if (resolvedCache) {
+        _customCache = resolvedCache;
+        _cachingPubsub = new CachingPubSub(innerPubsub, resolvedCache);
+      } else {
+        _cachingPubsub = innerPubsub;
+      }
+    }
+    return _cachingPubsub;
+  }
+  function getCache() {
+    getPubsub();
+    return _customCache;
+  }
+  async function triggerWorkflow(runId, workflowInput, tracingOptions) {
+    const eventName = `workflow.${InngestDurableStepIds.AGENTIC_LOOP}`;
+    await inngest.send({
+      name: eventName,
+      data: {
+        inputData: workflowInput,
+        runId,
+        resourceId: workflowInput.state?.resourceId,
+        requestContext: {},
+        tracingOptions
+      }
+    });
+  }
+  async function emitError(runId, error) {
+    await emitErrorEvent(getPubsub(), runId, error);
+  }
+  const inngestAgent = {
+    get id() {
+      return agentId;
+    },
+    get name() {
+      return agentName;
+    },
+    get agent() {
+      return agent;
+    },
+    get inngest() {
+      return inngest;
+    },
+    get cache() {
+      return getCache();
+    },
+    get pubsub() {
+      return getPubsub();
+    },
+    async stream(messages, streamOptions) {
+      const preparation = await prepareForDurableExecution({
+        agent,
+        messages,
+        options: streamOptions,
+        runId: streamOptions?.runId,
+        requestContext: streamOptions?.requestContext
+      });
+      const { runId, messageId, workflowInput, threadId, resourceId } = preparation;
+      workflowInput.agentId = agentId;
+      workflowInput.agentName = agentName;
+      const observability = mastra?.observability?.getSelectedInstance({
+        requestContext: streamOptions?.requestContext
+      });
+      const agentSpan = observability?.startSpan({
+        type: SpanType.AGENT_RUN,
+        name: `agent run: '${agentId}'`,
+        entityType: EntityType.AGENT,
+        entityId: agentId,
+        entityName: agentName,
+        input: workflowInput.messageListState,
+        metadata: {
+          runId,
+          threadId,
+          resourceId
+        }
+      });
+      const agentSpanData = agentSpan?.exportSpan();
+      const modelSpan = agentSpan?.createChildSpan({
+        type: SpanType.MODEL_GENERATION,
+        name: `llm: '${workflowInput.modelConfig.modelId}'`,
+        input: { messages: workflowInput.messageListState },
+        attributes: {
+          model: workflowInput.modelConfig.modelId,
+          provider: workflowInput.modelConfig.provider,
+          streaming: true,
+          parameters: {
+            temperature: workflowInput.options?.temperature
+          }
+        }
+      });
+      const modelSpanData = modelSpan?.exportSpan();
+      workflowInput.agentSpanData = agentSpanData;
+      workflowInput.modelSpanData = modelSpanData;
+      workflowInput.stepIndex = 0;
+      const {
+        output,
+        cleanup: streamCleanup,
+        ready
+      } = createDurableAgentStream({
+        pubsub: getPubsub(),
+        runId,
+        messageId,
+        model: {
+          modelId: workflowInput.modelConfig.modelId,
+          provider: workflowInput.modelConfig.provider,
+          version: "v3"
+        },
+        threadId,
+        resourceId,
+        onChunk: streamOptions?.onChunk,
+        onStepFinish: streamOptions?.onStepFinish,
+        onFinish: streamOptions?.onFinish,
+        onError: streamOptions?.onError,
+        onSuspended: streamOptions?.onSuspended
+      });
+      const tracingOptions = agentSpanData ? { traceId: agentSpanData.traceId, parentSpanId: agentSpanData.id } : void 0;
+      ready.then(() => triggerWorkflow(runId, workflowInput, tracingOptions)).catch((error) => {
+        void emitError(runId, error);
+      });
+      const result = {
+        output,
+        runId,
+        threadId,
+        resourceId,
+        cleanup: streamCleanup,
+        // Also expose fullStream directly for server compatibility
+        get fullStream() {
+          return output.fullStream;
+        }
+      };
+      return result;
+    },
+    async resume(runId, resumeData, resumeOptions) {
+      const {
+        output,
+        cleanup: streamCleanup,
+        ready
+      } = createDurableAgentStream({
+        pubsub: getPubsub(),
+        runId,
+        messageId: crypto.randomUUID(),
+        model: {
+          modelId: void 0,
+          provider: void 0,
+          version: "v3"
+        },
+        threadId: resumeOptions?.threadId,
+        resourceId: resumeOptions?.resourceId,
+        onChunk: resumeOptions?.onChunk,
+        onStepFinish: resumeOptions?.onStepFinish,
+        onFinish: resumeOptions?.onFinish,
+        onError: resumeOptions?.onError,
+        onSuspended: resumeOptions?.onSuspended
+      });
+      const eventName = `workflow.${InngestDurableStepIds.AGENTIC_LOOP}`;
+      ready.then(async () => {
+        const workflowsStore = await mastra?.getStorage()?.getStore("workflows");
+        const snapshot = await workflowsStore?.loadWorkflowSnapshot({
+          workflowName: InngestDurableStepIds.AGENTIC_LOOP,
+          runId
+        });
+        const suspendedStepIds = snapshot?.suspendedPaths ? Object.keys(snapshot.suspendedPaths) : [];
+        const steps = suspendedStepIds.length > 0 ? suspendedStepIds : [];
+        await inngest.send({
+          name: eventName,
+          data: {
+            inputData: resumeData,
+            initialState: snapshot?.value ?? {},
+            runId,
+            resourceId: resumeOptions?.resourceId,
+            requestContext: {},
+            stepResults: snapshot?.context,
+            resume: {
+              steps,
+              stepResults: snapshot?.context,
+              resumePayload: resumeData,
+              resumePath: steps[0] ? snapshot?.suspendedPaths?.[steps[0]] : void 0
+            }
+          }
+        });
+      }).catch((error) => {
+        void emitError(runId, error);
+      });
+      return {
+        output,
+        get fullStream() {
+          return output.fullStream;
+        },
+        runId,
+        threadId: resumeOptions?.threadId,
+        resourceId: resumeOptions?.resourceId,
+        cleanup: streamCleanup
+      };
+    },
+    async prepare(messages, prepareOptions) {
+      const preparation = await prepareForDurableExecution({
+        agent,
+        messages,
+        options: prepareOptions,
+        requestContext: prepareOptions?.requestContext
+      });
+      preparation.workflowInput.agentId = agentId;
+      preparation.workflowInput.agentName = agentName;
+      return {
+        runId: preparation.runId,
+        messageId: preparation.messageId,
+        workflowInput: preparation.workflowInput,
+        threadId: preparation.threadId,
+        resourceId: preparation.resourceId
+      };
+    },
+    async observe(runId, observeOptions) {
+      const {
+        output,
+        cleanup: streamCleanup,
+        ready
+      } = createDurableAgentStream({
+        pubsub: getPubsub(),
+        runId,
+        messageId: crypto.randomUUID(),
+        model: {
+          modelId: void 0,
+          provider: void 0,
+          version: "v3"
+        },
+        offset: observeOptions?.offset,
+        onChunk: observeOptions?.onChunk,
+        onStepFinish: observeOptions?.onStepFinish,
+        onFinish: observeOptions?.onFinish,
+        onError: observeOptions?.onError,
+        onSuspended: observeOptions?.onSuspended
+      });
+      await ready;
+      return {
+        output,
+        get fullStream() {
+          return output.fullStream;
+        },
+        runId,
+        cleanup: streamCleanup
+      };
+    },
+    getDurableWorkflows() {
+      return [workflow];
+    },
+    __setMastra(mastraInstance) {
+      mastra = mastraInstance;
+    }
+  };
+  return new Proxy(inngestAgent, {
+    get(target, prop, receiver) {
+      if (prop in target) {
+        return Reflect.get(target, prop, receiver);
+      }
+      const agentValue = agent[prop];
+      if (typeof agentValue === "function") {
+        return agentValue.bind(agent);
+      }
+      return agentValue;
+    },
+    has(target, prop) {
+      return prop in target || prop in agent;
+    }
+  });
+}
+function isInngestAgent(obj) {
+  if (!obj) return false;
+  return typeof obj.id === "string" && typeof obj.name === "string" && "agent" in obj && "inngest" in obj && typeof obj.stream === "function" && typeof obj.getDurableWorkflows === "function";
+}
 
 // src/index.ts
 function isInngestWorkflow(input) {
@@ -2466,6 +3072,6 @@ function init(inngest) {
   };
 }
 
-export { InngestExecutionEngine, InngestPubSub, InngestRun, InngestWorkflow, _compatibilityCheck, createServe, createStep, init, serve };
+export { InngestExecutionEngine, InngestPubSub, InngestRun, InngestWorkflow, _compatibilityCheck, createInngestAgent, createInngestDurableAgenticWorkflow, createServe, createStep, init, isInngestAgent, serve };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map