this works

Author: whoiskatrin

examples/mcp-elicitation-demo/package.json

@@ -5,7 +5,7 @@
     "nanoid": "^5.1.5",
     "react": "^19.1.1",
     "react-dom": "^19.1.1",
-    "zod": "^3.25.67"
+    "zod": "^3.25.76"
   },
   "keywords": [],
   "name": "@cloudflare/agents-mcp-elicitation-demo",

examples/playground/src/agents/chat.ts

@@ -1,24 +1,34 @@
 import { AIChatAgent } from "agents/ai-chat-agent";
-import type { StreamTextOnFinishCallback } from "ai";
-import { createDataStreamResponse, streamText } from "ai";
+import type {
+  StreamTextOnFinishCallback,
+  UIMessage as ChatMessage,
+  LanguageModel
+} from "ai";
+import { streamText, convertToModelMessages } from "ai";
 import { model } from "../model";
 import type { Env } from "../server";
 
 export class Chat extends AIChatAgent<Env> {
-  async onChatMessage(onFinish: StreamTextOnFinishCallback<{}>) {
-    const dataStreamResponse = createDataStreamResponse({
-      execute: async (dataStream) => {
-        const result = streamText({
-          messages: this.messages,
-          model,
-
-          onFinish
-        });
+  async onChatMessage(
+    onFinish: StreamTextOnFinishCallback<{}>,
+    options?: { abortSignal: AbortSignal | undefined },
+    uiMessageOnFinish?: (messages: ChatMessage[]) => Promise<void>
+  ) {
+    const result = streamText({
+      messages: convertToModelMessages(this.messages),
+      model: model as unknown as LanguageModel,
+      onFinish,
+      abortSignal: options?.abortSignal
+    });
 
-        result.mergeIntoDataStream(dataStream);
+    return result.toUIMessageStreamResponse({
+      originalMessages: this.messages,
+      onFinish: ({ messages }) => {
+        // Call the callback provided by AIChatAgent
+        if (uiMessageOnFinish) {
+          uiMessageOnFinish(messages);
+        }
       }
     });
-
-    return dataStreamResponse;
   }
 }

examples/playground/src/agents/scheduler.ts

@@ -4,7 +4,7 @@ import {
   unstable_getSchedulePrompt,
   unstable_scheduleSchema
 } from "agents/schedule";
-import { generateObject } from "ai";
+import { generateObject, type LanguageModel } from "ai";
 import { model } from "../model";
 import type { Env } from "../server";
 import type {
@@ -41,7 +41,7 @@ export class Scheduler extends Agent<Env> {
       const result = await generateObject({
         maxRetries: 5,
         mode: "json",
-        model,
+        model: model as unknown as LanguageModel,
         prompt: `${unstable_getSchedulePrompt({
           date: new Date()
         })} 

examples/tictactoe/src/server.ts

@@ -69,7 +69,7 @@ export class TicTacToe extends Agent<Env, TicTacToeState> {
 
     // now use AI to make a move
     const { object } = await generateObject({
-      model: openai("gpt-4o"),
+      model: openai("gpt-4o") as any,
       prompt: `You are playing Tic-tac-toe as player ${player === "X" ? "O" : "X"}. Here's the current board state:
 
 ${JSON.stringify(board, null, 2)}

guides/anthropic-patterns/src/server.tsx

@@ -8,7 +8,7 @@ import {
   type WSMessage,
   routeAgentRequest
 } from "agents";
-import { generateObject, generateText } from "ai";
+import { generateObject, generateText, type LanguageModel } from "ai";
 import { z } from "zod";
 
 type Env = {
@@ -129,7 +129,7 @@ export const Sequential = createAgent<{ input: string }, { copy: string }>(
     console.log("Sequential", props);
     // This agent uses a prompt chaining workflow, ideal for tasks that can be decomposed into fixed subtasks.
     // It trades off latency for higher accuracy by making each LLM call an easier task.
-    const model = ctx.openai("gpt-4o");
+    const model = ctx.openai("gpt-4o") as unknown as LanguageModel;
 
     // First step: Generate marketing copy
     const { text: copy } = await generateText({
@@ -191,7 +191,7 @@ export const Routing = createAgent<{ query: string }, { response: string }>(
   ) => {
     // This agent uses a routing workflow, which classifies input and directs it to specialized follow-up tasks.
     // It is effective for complex tasks with distinct categories that are better handled separately.
-    const model = ctx.openai("gpt-4o");
+    const model = ctx.openai("gpt-4o") as unknown as LanguageModel;
 
     // First step: Classify the query type
     const { object: classification } = await generateObject({
@@ -205,7 +205,7 @@ export const Routing = createAgent<{ query: string }, { response: string }>(
       3. Brief reasoning for classification`,
       schema: z.object({
         complexity: z.enum(["simple", "complex"]),
-        reasoning: z.string(),
+        reasoningText: z.string(),
         type: z.enum(["general", "refund", "technical"])
       })
     });
@@ -215,8 +215,8 @@ export const Routing = createAgent<{ query: string }, { response: string }>(
     const { text: response } = await generateText({
       model:
         classification.complexity === "simple"
-          ? ctx.openai("gpt-4o-mini")
-          : ctx.openai("o1-mini"),
+          ? (ctx.openai("gpt-4o-mini") as unknown as LanguageModel)
+          : (ctx.openai("o1-mini") as unknown as LanguageModel),
       prompt: props.query,
       system: {
         general:
@@ -244,7 +244,7 @@ export const Parallel = createAgent<
   ) => {
     // This agent uses a parallelization workflow, effective for tasks that can be divided into independent subtasks.
     // It allows for speed and multiple perspectives, improving confidence in results.
-    const model = ctx.openai("gpt-4o");
+    const model = ctx.openai("gpt-4o") as unknown as LanguageModel;
 
     // Run parallel reviews
     const [securityReview, performanceReview, maintainabilityReview] =
@@ -336,7 +336,7 @@ export const Orchestrator = createAgent<
     // This agent uses an orchestrator-workers workflow, suitable for complex tasks where subtasks aren't pre-defined.
     // It dynamically breaks down tasks and delegates them to worker LLMs, synthesizing their results.
     const { object: implementationPlan } = await generateObject({
-      model: ctx.openai("o1"),
+      model: ctx.openai("o1") as unknown as LanguageModel,
       prompt: `Analyze this feature request and create an implementation plan:
       ${props.featureRequest}`,
       schema: z.object({
@@ -367,7 +367,7 @@ export const Orchestrator = createAgent<
         }[file.changeType];
 
         const { object: change } = await generateObject({
-          model: ctx.openai("gpt-4o"),
+          model: ctx.openai("gpt-4o") as unknown as LanguageModel,
           prompt: `Implement the changes for ${file.filePath} to support:
           ${file.purpose}
   
@@ -402,15 +402,15 @@ export const Evaluator = createAgent(
     props: { text: string; targetLanguage: string },
     ctx: { toast: (message: string) => void; openai: OpenAIProvider }
   ) => {
-    const model = ctx.openai("gpt-4o");
+    const model = ctx.openai("gpt-4o") as unknown as LanguageModel;
 
     let currentTranslation = "";
     let iterations = 0;
     const MAX_ITERATIONS = 1;
 
     // Initial translation
     const { text: translation } = await generateText({
-      model: ctx.openai("gpt-4o-mini"), // use small model for first attempt
+      model: ctx.openai("gpt-4o-mini") as unknown as LanguageModel, // use small model for first attempt
       prompt: `Translate this text to ${props.targetLanguage}, preserving tone and cultural nuances:
       ${props.text}`,
       system: "You are an expert literary translator."
@@ -460,7 +460,7 @@ export const Evaluator = createAgent(
 
       // Generate improved translation based on feedback
       const { text: improvedTranslation } = await generateText({
-        model: ctx.openai("gpt-4o"), // use a larger model
+        model: ctx.openai("gpt-4o") as unknown as LanguageModel, // use a larger model
         prompt: `Improve this translation based on the following feedback:
         ${evaluation.specificIssues.join("\n")}
         ${evaluation.improvementSuggestions.join("\n")}

guides/human-in-the-loop/src/server.ts

@@ -3,8 +3,9 @@ import { routeAgentRequest } from "agents";
 import { AIChatAgent } from "agents/ai-chat-agent";
 import {
   type StreamTextOnFinishCallback,
-  createDataStreamResponse,
-  streamText
+  streamText,
+  convertToModelMessages,
+  type UIMessage as ChatMessage
 } from "ai";
 import { tools } from "./tools";
 import { processToolCalls } from "./utils";
@@ -14,40 +15,45 @@ type Env = {
 };
 
 export class HumanInTheLoop extends AIChatAgent<Env> {
-  async onChatMessage(onFinish: StreamTextOnFinishCallback<{}>) {
-    const dataStreamResponse = createDataStreamResponse({
-      execute: async (dataStream) => {
-        // Utility function to handle tools that require human confirmation
-        // Checks for confirmation in last message and then runs associated tool
-        const processedMessages = await processToolCalls(
-          {
-            dataStream,
-            messages: this.messages,
-            tools
-          },
-          {
-            // type-safe object for tools without an execute function
-            getWeatherInformation: async ({ city }) => {
-              const conditions = ["sunny", "cloudy", "rainy", "snowy"];
-              return `The weather in ${city} is ${
-                conditions[Math.floor(Math.random() * conditions.length)]
-              }.`;
-            }
-          }
-        );
+  async onChatMessage(
+    onFinish: StreamTextOnFinishCallback<{}>,
+    options?: { abortSignal: AbortSignal | undefined },
+    uiMessageOnFinish?: (messages: ChatMessage[]) => Promise<void>
+  ) {
+    // Utility function to handle tools that require human confirmation
+    // Checks for confirmation in last message and then runs associated tool
+    const processedMessages = await processToolCalls(
+      {
+        messages: this.messages,
+        tools
+      },
+      {
+        // type-safe object for tools without an execute function
+        getWeatherInformation: async ({ city }) => {
+          const conditions = ["sunny", "cloudy", "rainy", "snowy"];
+          return `The weather in ${city} is ${
+            conditions[Math.floor(Math.random() * conditions.length)]
+          }.`;
+        }
+      }
+    );
 
-        const result = streamText({
-          messages: processedMessages,
-          model: openai("gpt-4o"),
-          onFinish,
-          tools
-        });
+    const result = streamText({
+      messages: convertToModelMessages(processedMessages),
+      model: openai("gpt-4o") as any,
+      onFinish,
+      tools,
+      abortSignal: options?.abortSignal
+    });
 
-        result.mergeIntoDataStream(dataStream);
+    return result.toUIMessageStreamResponse({
+      originalMessages: this.messages,
+      onFinish: ({ messages }) => {
+        if (uiMessageOnFinish) {
+          uiMessageOnFinish(messages);
+        }
       }
     });
-
-    return dataStreamResponse;
   }
 }
 

guides/human-in-the-loop/src/tools.ts

@@ -3,7 +3,7 @@ import { z } from "zod";
 
 const getWeatherInformation = tool({
   description: "show the weather in a given city to the user",
-  parameters: z.object({ city: z.string() })
+  inputSchema: z.object({ city: z.string() })
   // no execute function, we want human in the loop
 });
 
@@ -14,7 +14,7 @@ const getLocalTime = tool({
     console.log(`Getting local time for ${location}`);
     return "10am";
   },
-  parameters: z.object({ location: z.string() })
+  inputSchema: z.object({ location: z.string() })
 });
 
 export const tools = {

guides/human-in-the-loop/src/utils.ts

@@ -1,12 +1,10 @@
-import { type Message, formatDataStreamPart } from "@ai-sdk/ui-utils";
-import {
-  type DataStreamWriter,
-  type ToolExecutionOptions,
-  type ToolSet,
-  convertToCoreMessages
-} from "ai";
+import { type UIMessage, type ToolSet, convertToModelMessages } from "ai";
 import type { z } from "zod";
 
+// Type aliases for v5 compatibility
+type DataStreamWriter = any;
+type ToolExecutionOptions = any;
+
 // Approval string to be shared across frontend and backend
 export const APPROVAL = {
   NO: "No, denied.",
@@ -39,21 +37,20 @@ export async function processToolCalls<
   }
 >(
   {
-    dataStream,
-    messages
+    messages,
+    tools
   }: {
     tools: Tools; // used for type inference
-    dataStream: DataStreamWriter;
-    messages: Message[];
+    messages: UIMessage[];
   },
   executeFunctions: {
     [K in keyof Tools & keyof ExecutableTools]?: (
-      args: z.infer<ExecutableTools[K]["parameters"]>,
+      args: any, // Type cast for v5 compatibility
       context: ToolExecutionOptions
       // biome-ignore lint/suspicious/noExplicitAny: vibes
     ) => Promise<any>;
   }
-): Promise<Message[]> {
+): Promise<UIMessage[]> {
   const lastMessage = messages[messages.length - 1];
   const parts = lastMessage.parts;
   if (!parts) return messages;
@@ -63,7 +60,7 @@ export async function processToolCalls<
       // Only process tool invocations parts
       if (part.type !== "tool-invocation") return part;
 
-      const { toolInvocation } = part;
+      const toolInvocation = (part as any).toolInvocation || part; // v5 compatibility
       const toolName = toolInvocation.toolName;
 
       // Only continue if we have an execute function for the tool (meaning it requires confirmation) and it's in a 'result' state
@@ -82,10 +79,11 @@ export async function processToolCalls<
           return part;
         }
 
-        const toolInstance = executeFunctions[toolName];
+        const toolInstance =
+          executeFunctions[toolName as keyof typeof executeFunctions];
         if (toolInstance) {
           result = await toolInstance(toolInvocation.args, {
-            messages: convertToCoreMessages(messages),
+            messages: convertToModelMessages(messages),
             toolCallId: toolInvocation.toolCallId
           });
         } else {
@@ -99,12 +97,14 @@ export async function processToolCalls<
       }
 
       // Forward updated tool result to the client.
-      dataStream.write(
-        formatDataStreamPart("tool_result", {
-          result,
-          toolCallId: toolInvocation.toolCallId
-        })
-      );
+      // Note: dataStream parameter removed in v5 - this would need to be handled by caller
+      // dataStream.write({
+      //   type: "tool-result",
+      //   value: {
+      //     result,
+      //     toolCallId: toolInvocation.toolCallId
+      //   }
+      // });
 
       // Return updated toolInvocation with the actual result.
       return {