Vercel AI SDK + Temporal で Agent Loop を回す #LayerX_AI_Agent_ブログリレー

const query = "今日の東京の天気は？"

const stream = streamText({
  model: openai('gpt-4o'),
  prompt: query,
  stopWhen: stepCountIs(5),
  tools: {
    weather: tool({
      description: 'Get the weather in a location (fahrenheit)',
      inputSchema: z.object({
        location: z.string().describe('The location to get the weather for'),
      }),
      execute: async ({ location }) => {
        const temperature = Math.round(Math.random() * (90 - 32) + 32);
        return {
          location,
          temperature,
        };
      },
    }),
  },
});

const getWeatherTool = tool({
  description: "Get the weather in a location (fahrenheit)",
  inputSchema: z.object({
    location: z.string().describe("The location to get the weather for"),
  }),
  outputSchema: z.object({
    temperature: z.number().describe("The temperature in fahrenheit"),
  }),
  
});


async function getWeatherInformation({
  location,
}: InferToolInputtypeof getWeatherTool>) {
  const temperature = Math.round(Math.random() * (90 - 32) + 32);
  return {
    location,
    temperature,
  };
}

const tools = { weather: getWeatherTool };
export type MyUITools = InferUIToolstypeof tools>;
export type MyUIMessage = UIMessageunknown, {}, MyUITools>;

const messages: MyUIMessage[] = [
  {
    id: generateId(),
    role: "user",
    parts: [{ type: "text", text: "今日の東京の天気は？" }],
  },
];

let step = 0;
const maxSteps = 10;

while (step  maxSteps) {
  
  const stream = streamText({
    model: openai("gpt-4o"),
    
    messages,
    tools,
  });

  
  const newMsgs: MyUIMessage[] = [];
  for await (const msg of readUIMessageStreamMyUIMessage>({
    stream: stream.toUIMessageStream(),
  })) {
    if (newMsgs.at(-1)?.id === msg.id) {
      newMsgs[newMsgs.length - 1] = msg;
    } else {
      newMsgs.push(msg);
    }
  }

  
  let hasUnprocessedToolResults = false;

  
  for (const uiMsg of uiMessages) {
    const parts: typeof uiMsg.parts = [];
    for (const part of uiMsg.parts) {
      let newPart = part;
      switch (part.type) {
        case "tool-weather": {
          if (part.state === "input-available") {
            const output = await getWeatherInformation(content.input);
            
            newPart = {
              ...part,
              state: "output-available",
              output,
            }
            
            hasUnprocessedToolResults = true;
          }
          break;
        }
      }
      parts.push(newPart);
    }
    messages.push({ ...uiMsg, parts });
  }

  
  if (!hasUnprocessedToolResults) break
  step++;
}

export async function processLLM(inputMessages: MyUIMessage[]) {
  const stream = streamText({
    model: openai("gpt-4o"),
    messages: convertToModelMessages(inputMessages),
    tools,
  });
  const newMsgs: MyUIMessage[] = [];
  for await (const msg of readUIMessageStreamMyUIMessage>({
    stream: stream.toUIMessageStream(),
  })) {
    if (newMsgs.at(-1)?.id === msg.id) {
      newMsgs[newMsgs.length - 1] = msg;
    } else {
      newMsgs.push(msg);
    }
  }
  return newMsgs;
}


export async function executeToolCall(
  part: ToolUIPartMyUITools>
): PromiseToolUIPartMyUITools>> {
  if (part.state !== "input-available") return part;
  switch (part.type) {
    case "tool-weather": {
      const output = await getWeatherInformation(part.input);
      return {
        ...part,
        state: "output-available",
        output,
      };
      break;
    }
    default: {
      throw new Error(`Unknown tool: ${part.type}`);
    }
  }
}

import { proxyActivities } from '@temporalio/workflow';
import type * as activities from './activities';

const { processLLM, executeToolCall } = proxyActivitiestypeof activities>();

export async function runAgent() {
  const messages: MyUIMessage[] = [
    {
      id: generateId(),
      role: "user",
      parts: [{ type: "text", text: "今日の東京の天気は？" }],
    },
  ];

  let step = 0;
  const maxSteps = 10;

  while (step  maxSteps) {
    
    const uiMessages = await processLLM(messages);

    
    let hasUnprocessedToolResults = false;

    
    for (const uiMsg of uiMessages) {
      const parts: typeof uiMsg.parts = [];
      for (const part of uiMsg.parts) {
        let newPart = part;
        if (part.type.startsWith("tool-")) {
          newPart = await executeToolCall(part as ToolUIPartMyUITools>);
          hasUnprocessedToolResults = true;
        }
        parts.push(newPart);
      }
      messages.push({ ...uiMsg, parts });
    }

    
    if (!hasUnprocessedToolResults) break;
    step++;
  }

  
}