ワークフローの変数によるデータマッピング

const workflow = new Workflow({
  name: "data-mapping-workflow",
  triggerSchema: z.object({
    inputData: z.string(),
  }),
});
 
workflow
  .step(step1, {
    variables: {
      // トリガーデータをステップ入力にマッピング
      inputData: { step: "trigger", path: "inputData" },
    },
  })
  .then(step2, {
    variables: {
      // step1の出力をstep2の入力にマッピング
      previousValue: { step: step1, path: "outputField" },
    },
  })
  .commit();
 
// ワークフローをMastraに登録
export const mastra = new Mastra({
  workflows: { workflow },
});

workflow
  .step(step1)
  .then(step2, {
    variables: {
      // step1の出力からネストされたプロパティにアクセス
      nestedValue: { step: step1, path: "nested.deeply.value" },
    },
  })
  .commit();

workflow
  .step(step1, {
    variables: {
      // トリガーデータオブジェクト全体をマッピング
      triggerData: { step: "trigger", path: "." },
    },
  })
  .commit();

// カウンターをインクリメントするステップ
const incrementStep = new Step({
  id: "increment",
  inputSchema: z.object({
    // 前回の反復からの値
    prevValue: z.number().optional(),
  }),
  outputSchema: z.object({
    // 更新されたカウンター値
    updatedCounter: z.number(),
  }),
  execute: async ({ context }) => {
    const { prevValue = 0 } = context.inputData;
    return { updatedCounter: prevValue + 1 };
  },
});
 
const workflow = new Workflow({
  name: "counter",
});
 
workflow.step(incrementStep).while(
  async ({ context }) => {
    // カウンターが10未満の間続ける
    const result = context.getStepResult(incrementStep);
    return (result?.updatedCounter ?? 0) < 10;
  },
  incrementStep,
  {
    // 前の値を次の反復に渡す
    prevValue: {
      step: incrementStep,
      path: "updatedCounter",
    },
  },
);

import { Step, Workflow, Mastra } from "@mastra/core";
import { z } from "zod";
 
// Define a step that needs user input
const processUserInput = new Step({
  id: "processUserInput",
  execute: async ({ context }) => {
    // The inputData will be available in context because of the variable mapping
    const { inputData } = context.inputData;
 
    return {
      processedData: `Processed: ${inputData}`,
    };
  },
});
 
// Create the workflow
const workflow = new Workflow({
  name: "trigger-mapping",
  triggerSchema: z.object({
    inputData: z.string(),
  }),
});
 
// Map the trigger data to the step
workflow
  .step(processUserInput, {
    variables: {
      inputData: { step: "trigger", path: "inputData" },
    },
  })
  .commit();
 
// Register the workflow with Mastra
export const mastra = new Mastra({
  workflows: { workflow },
});

import { Step, Workflow, Mastra } from "@mastra/core";
import { z } from "zod";
 
// Step 1: Generate data
const generateData = new Step({
  id: "generateData",
  outputSchema: z.object({
    nested: z.object({
      value: z.string(),
    }),
  }),
  execute: async () => {
    return {
      nested: {
        value: "step1-data",
      },
    };
  },
});
 
// Step 2: Process the data from step 1
const processData = new Step({
  id: "processData",
  inputSchema: z.object({
    previousValue: z.string(),
  }),
  execute: async ({ context }) => {
    // previousValue will be available because of the variable mapping
    const { previousValue } = context.inputData;
 
    return {
      result: `Processed: ${previousValue}`,
    };
  },
});
 
// Create the workflow
const workflow = new Workflow({
  name: "step-mapping",
});
 
// Map data from step1 to step2
workflow
  .step(generateData)
  .then(processData, {
    variables: {
      // Map the nested.value property from generateData's output
      previousValue: { step: generateData, path: "nested.value" },
    },
  })
  .commit();
 
// Register the workflow with Mastra
export const mastra = new Mastra({
  workflows: { workflow },
});

import { Step, Workflow, Mastra } from "@mastra/core";
import { z } from "zod";
 
// Define schemas for better type safety
const triggerSchema = z.object({
  inputValue: z.string(),
});
 
type TriggerType = z.infer<typeof triggerSchema>;
 
// Step with typed context
const step1 = new Step({
  id: "step1",
  outputSchema: z.object({
    nested: z.object({
      value: z.string(),
    }),
  }),
  execute: async ({ context }) => {
    // TypeScript knows the shape of triggerData
    const triggerData = context.getStepResult<TriggerType>("trigger");
 
    return {
      nested: {
        value: `processed-${triggerData?.inputValue}`,
      },
    };
  },
});
 
// Create the workflow with the schema
const workflow = new Workflow({
  name: "type-safe-workflow",
  triggerSchema,
});
 
workflow.step(step1).commit();
 
// Register the workflow with Mastra
export const mastra = new Mastra({
  workflows: { workflow },
});