export const chefAgent = new Agent({
  name: "chef-agent",
  instructions:
    "You are Michel, a practical and experienced home chef" +
    "You help people cook with whatever ingredients they have available.",
  model: openai("gpt-4o-mini"),
});

// このツールはAgentに組み込まれる
export const stockPrices = createTool({
  id: "Get Stock Price",
  inputSchema: z.object({
    symbol: z.string(),
  }),
  description: `Fetches the last day's closing stock price for a given symbol`,
  execute: async ({ context: { symbol } }) => {
    console.log("Using tool to fetch stock price for", symbol);
    return {
      symbol,
      currentPrice: await getStockPrice(symbol),
    };
  },
});

// こんな感じに
export const stockAgent = new Agent<typeof tools>({
  name: "Stock Agent",
  instructions:
    "You are a helpful assistant that provides current stock prices. When asked about a stock, use the stock price tool to fetch the stock price.",
  model: openai("gpt-4o-mini"),
  tools: {
    stockPrices: tools.stockPrices, //ココ
  },
});

myWorkflow
  .step(stepA)
    .then(stepB)
    .then(stepD)
  .after(stepA)
    .step(stepC)
    .then(stepE)
  .after([stepD, stepE])
    .step(stepF);

import { Agent } from "@mastra/core/agent";
import { openai } from "@ai-sdk/openai";
 
const agent = new Agent({
  name: "Project Manager",
  instructions:
    "You are a project manager. You are responsible for managing the project and the team.",
  model: openai("gpt-4o-mini"),
});
 
await agent.stream("When will the project be completed?", {
  threadId: "project_123",
  resourceId: "user_123",
});

import { MCPConfiguration } from "@mastra/mcp";
import { Agent } from "@mastra/core/agent";
import { openai } from "@ai-sdk/openai";
 
const mcp = new MCPConfiguration({
  servers: {
    // stdio example
    sequential: {
      name: "sequential-thinking",
      server: {
        command: "npx",
        args: ["-y", "@modelcontextprotocol/server-sequential-thinking"],
      },
    },
    // SSE example
    weather: {
      url: new URL("http://localhost:8080/sse"),
      requestInit: {
        headers: {
          Authorization: "Bearer your-token",
        },
      },
    },
  },
});

import { Mastra } from '@mastra/core';
 
export const mastra = new Mastra({
  // Other configuration options
  serverMiddleware: [
    {
      handler: async (c, next) => {
        // Example: Add authentication check
        const authHeader = c.req.header('Authorization');
        if (!authHeader) {
          return new Response('Unauthorized', { status: 401 });
        }
        
        // Continue to the next middleware or route handler
        await next();
      },
      path: '/api/*', // Optional: defaults to '/api/*' if not specified
    },
    {
      handler: async (c, next) => {
        // Example: Add request logging
        console.log(`${c.req.method} ${c.req.url}`);
        await next();
      },
      // This middleware will apply to all routes since no path is specified
    }
  ]
});

const stream = await myAgent.stream([
  { role: "user", content: "Tell me a story." },
]);
 
console.log("Agent:");
 
for await (const chunk of stream.textStream) {
  process.stdout.write(chunk);
}

import { z } from "zod";
 
// Define the Zod schema
const schema = z.object({
  summary: z.string(),
  keywords: z.array(z.string()),
});
 
// Use the schema with the agent
const response = await myAgent.generate(
  [
    {
      role: "user",
      content:
        "Please provide a summary and keywords for the following text: ...",
    },
  ],
  {
    output: schema,
  },
);
 
console.log("Structured Output:", response.object);

import { mastra } from '@/src/mastra';
 
export async function POST(req: Request) {
  const { messages } = await req.json();
  const myAgent = mastra.getAgent('weatherAgent');
  const stream = await myAgent.stream(messages);
 
  return stream.toDataStreamResponse();
}

'use client';

import { useCompletion } from '@ai-sdk/react';

export default function Page() {
  const { completion, input, handleInputChange, handleSubmit } = useCompletion({
    streamProtocol: 'text',
  });

  return (
    <form onSubmit={handleSubmit}>
      <input name="prompt" value={input} onChange={handleInputChange} />
      <button type="submit">Submit</button>
      <div>{completion}</div>
    </form>
  );
}

f:{"messageId":"msg-P55Bgxd2L54SciutpqxZSjqP"}
9:{"toolCallId":"call_kGtM9Xq70JfvkQbXmIx2QYYk","toolName":"weatherTool","args":{"location":"Tokyo"}}
a:{"toolCallId":"call_kGtM9Xq70JfvkQbXmIx2QYYk","result":{"temperature":15.1,"feelsLike":13.1,"humidity":57,"windSpeed":7.4,"windGust":29.9,"conditions":"Clear sky","location":"Tokyo"}}
e:{"finishReason":"tool-calls","usage":{"promptTokens":181,"completionTokens":15},"isContinued":false}
f:{"messageId":"msg-SWWUe7t3jajdHgOyvcuPpXJt"}
0:"The"
0:" current"
0:" weather"
0:" in"
0:" Tokyo"
0:" is"
0:" clear"
0:" with"
0:" a"
0:" temperature"
0:" of"
0:" "
0:"15"
0:"."
0:"1"
0:"°C"
0:","
0:" though"
0:" it"
0:" feels"
0:" like"
0:" "
0:"13"
0:"."
0:"1"
0:"°C"
0:"."
0:" The"
0:" humidity"
0:" is"
0:" at"
0:" "
0:"57"
0:"%,"
0:" and"
0:" there's"
0:" a"
0:" wind"
0:" speed"
0:" of"
0:" "
0:"7"
0:"."
0:"4"
0:" km"
0:"/h"
0:" with"
0:" gust"
0:"s"
0:" up"
0:" to"
0:" "
0:"29"
0:"."
0:"9"
0:" km"
0:"/h"
0:"."
e:{"finishReason":"stop","usage":{"promptTokens":246,"completionTokens":60},"isContinued":false}
d:{"finishReason":"stop","usage":{"promptTokens":427,"completionTokens":75}}

f:{"messageId":"msg-..."}

9:{"toolCallId":"call_...","toolName":"weatherTool","args":{"location":"Tokyo"}}

a:{"toolCallId":"call_...","result":{...}}

e:{"finishReason":"tool-calls", ...}

0:"The"
0:" current"
0:" weather"

  const { messages, input, handleInputChange, handleSubmit, isLoading } = useChat({
    api: '/api/weather',
    onToolCall: (toolCallPayload) => {
      const toolName = toolCallPayload.toolCall.toolName
      const args = toolCallPayload.toolCall.args as { location: string }
      if (toolName === 'weatherTool') {
        setToolStatus(`🔧 ${toolName} で${args.location}の天気を取得中...`)
      } else {
        setToolStatus(`🌦️ 天気情報を取得中...`)
      }
    },
    onFinish: () => {
      setToolStatus('')
    },
  })

9:{"toolCallId":"call_...","toolName":"weatherTool","args":{"location":"Tokyo"}}

import { Hono } from 'hono'
import { mastra } from '@/server/mastra'

export const getWeather = new Hono()

const route = getWeather.post('/', async (c) => {
  try {
    const body = await c.req.json()
    const { messages } = weatherRequestSchema.parse(body)

    const agent = mastra.getAgent('weatherAgent')
    const lastMessage = messages[messages.length - 1]
    const city = lastMessage.content
    const stream = await agent.stream(`What's the weather like in ${city}?`)
   // ここがhonoを介したstreamの実装
    return c.newResponse(stream.toDataStreamResponse().body, {
      headers: {
        'Content-Type': 'text/event-stream',
        'Cache-Control': 'no-cache',
        Connection: 'keep-alive',
      },
    })
  } catch (error) {
    console.error('API Error:', error)
    return c.json(
      {
        error: {
          message: '天気情報の取得に失敗しました',
          details: error instanceof Error ? error.message : undefined,
        },
      },
      500,
    )
  }
})

export type GetWeatherRoute = typeof route

pnpm mastra dev -d server/mastra     

    console.log('Low confidence in generated content, suspending for human guidance', { guidance })

    // If confidence is low, suspend for human guidance
    if (!guidance) {
      // only suspend if no guidance is provided
      await suspend()
      return undefined
    }