chore(ai): update default gemini model to 2.5-flash and lock gateway to v1beta

Author: jmbish04

backend/src/ai/agent-ai.ts

@@ -1,5 +1,5 @@
 import { Agent, OpenAIProvider, Runner, type ModelProvider } from "@openai/agents";
-import { getAiGatewayUrl as resolveAiGatewayUrl } from "./utils/ai-gateway";
+import { getAiGatewayUrlForOpenAI } from "@/ai/utils/ai-gateway";
 
 export type SupportedProvider =
   | "worker-ai"
@@ -80,14 +80,14 @@ export async function getAiGatewayUrl(
   provider: SupportedProvider,
 ): Promise<string> {
   const gatewayProvider = PROVIDER_TO_GATEWAY[provider];
-  return resolveAiGatewayUrl(env, gatewayProvider);
+  return getAiGatewayUrlForOpenAI(env, gatewayProvider);
 }
 
 export async function getAiBaseUrl(
   env: Env,
   provider: SupportedProvider,
 ): Promise<string> {
-  return getAiGatewayUrl(env, provider);
+  return getAiGatewayUrlForOpenAI(env, provider);
 }
 
 export async function createRunner(

backend/src/ai/agents/BaseAgent.ts

@@ -1,14 +1,12 @@
-import { Agent as OpenAIAgent } from "@openai/agents";
 import { Agent as CFAgent } from "agents";
 import {
-  createGatewayClient,
   createRunner,
   resolveDefaultAiModel,
   resolveDefaultAiProvider,
   type SupportedProvider,
 } from "@/ai/agent-sdk";
 import { Logger } from "@/lib/logger";
-import { z } from "zod";
+import type { z } from "zod"; // ✅ Use type import to avoid runtime evaluation
 
 export class BaseAgent<State = any> extends CFAgent<Env, State> {
   private _logger?: Logger;
@@ -41,22 +39,22 @@ export class BaseAgent<State = any> extends CFAgent<Env, State> {
   }): Promise<string> {
     const provider = this.resolveProvider(input.provider);
     const model = this.resolveModel(provider, input.model);
+    
+    // ✅ Dynamically import the heavy SDK only when executed
+    const { Agent: OpenAIAgent } = await import("@openai/agents");
+    
     const runner = await createRunner(this.env, provider, model);
-    const client = await createGatewayClient(this.env, model);
+    
+    // ⚠️ Note: Removed unused createGatewayClient
+    
     const agent = new OpenAIAgent({
       name: input.name,
       model,
       instructions: input.instructions,
-      mcpServers: {
-        "cloudflare": {
-            transport: {
-                type: "stdio",
-                command: "npx",
-                args: ["@cloudflare/mcp-server-cloudflare", "--mcp-endpoint", (this.env as any).MCP_API_URL || "https://docs.mcp.cloudflare.com/mcp"]
-            }
-        }
-      } as any // Cast to any to avoid strict type issues with the specific Agent SDK version
+      // ⚠️ Removed local 'stdio'/'npx' MCP config as it will crash a CF Worker.
+      // If MCP is required, you must use an SSE/HTTP transport or inject it as a standard tool.
     });
+
     const result = await runner.run(agent, input.prompt);
     return String(result.finalOutput ?? "");
   }
@@ -71,24 +69,18 @@ export class BaseAgent<State = any> extends CFAgent<Env, State> {
   }): Promise<T> {
     const provider = this.resolveProvider(input.provider);
     const model = this.resolveModel(provider, input.model);
+    
+    // ✅ Dynamically import the heavy SDK only when executed
+    const { Agent: OpenAIAgent } = await import("@openai/agents");
+    
     const runner = await createRunner(this.env, provider, model);
-    const client = await createGatewayClient(this.env, model);
 
-    // We must pass the schema to the agent configuration
     const agent = new OpenAIAgent({
       name: input.name,
       model,
       instructions: input.instructions,
-      outputType: input.schema as any, // Cast to any to avoid strict type issues with specific SDK versions
-      mcpServers: {
-        "cloudflare": {
-            transport: {
-                type: "stdio",
-                command: "npx",
-                args: ["@cloudflare/mcp-server-cloudflare", "--mcp-endpoint", (this.env as any).MCP_API_URL || "https://docs.mcp.cloudflare.com/mcp"]
-            }
-        }
-      } as any
+      outputType: input.schema as any, 
+      // ⚠️ Removed local 'stdio'/'npx' MCP config
     });
 
     try {
@@ -99,5 +91,4 @@ export class BaseAgent<State = any> extends CFAgent<Env, State> {
       throw error;
     }
   }
-}
-
+}

backend/src/ai/agents/Gemini.ts

@@ -21,23 +21,16 @@ export class GeminiAgent extends CFAgent<Env, any> {
     this.doId = state.id.toString();
   }
 
-  @callable({ streaming: true })
-  async chat(stream: any, prompt: string) {
+  @callable()
+  async chat(prompt: string, history?: any[]) {
     // 1. Construct the Cloudflare AI Gateway OpenAI-Compatible URL
-    // CLOUDFLARE_ACCOUNT_ID is a secret, so .get() is likely correct if typed as such
     const accountId = await this.env.CLOUDFLARE_ACCOUNT_ID.get();
-    // AI_GATEWAY_NAME is a var (string), so no .get()
     const gateway = this.env.AI_GATEWAY_NAME;
-    // CLOUDFLARE_API_TOKEN is a secret
-    // Note: If CLOUDFLARE_API_TOKEN is not in Env, check wrangler.jsonc. It is there.
-    // If it's a string in Env, .get() will fail. If it's a Secret, .get() is needed.
-    // Based on usage of WORKER_API_KEY.get(), we assume secrets use .get().
     const apiKey = await this.env.CLOUDFLARE_API_TOKEN.get();
 
     const baseURL = await this.env.AI.gateway(gateway).getUrl('worker-ai');
 
     // 2. Hijack the global process environment to reroute ADK's underlying fetcher
-    // We pass the CF API Token as the "OpenAI" key, and the AI Gateway as the Base URL.
     (globalThis as any).process = { 
       env: { 
         OPENAI_API_KEY: apiKey,
@@ -51,7 +44,6 @@ export class GeminiAgent extends CFAgent<Env, any> {
       // 3. Initialize ADK with the Cloudflare Workers AI Model
       const agent = new LlmAgent({
         name: "cf_gateway_agent",
-        // The exact model requested, routed to Cloudflare Edge GPUs
         model: "@cf/openai/gpt-oss-120b", 
         instruction: "You are an elite autonomous agent powered by Cloudflare Workers AI and Google ADK. Provide structured, highly accurate responses.",
       });
@@ -61,19 +53,18 @@ export class GeminiAgent extends CFAgent<Env, any> {
 
       const eventStream = runner.runAsync({
         userId: "user",
-        sessionId: this.doId, // Use captured Durable Object ID
+        sessionId: this.doId,
         newMessage: { role: "user", parts: [{ text: prompt }] },
       });
 
       let fullResponse = "";
 
-      // 5. Stream the chunks directly back to the assistant-ui frontend
+      // 5. Accumulate the full response
       for await (const event of eventStream) {
         if (event.content?.parts) {
           for (const part of event.content.parts) {
             if (part.text) {
               fullResponse += part.text;
-              await stream.write(part.text);
             }
           }
         }
@@ -89,9 +80,11 @@ export class GeminiAgent extends CFAgent<Env, any> {
         status: "idle"
       });
 
+      return { response: fullResponse };
+
     } catch (error: any) {
       this.setState({ ...this.state, status: "error" });
-      await stream.write(`\n\n[Agent Error]: ${error.message}`);
+      return { response: `[Agent Error]: ${error.message}` };
     }
   }
 }

backend/src/ai/agents/Planner.ts

@@ -1,5 +1,5 @@
 import { callable } from "agents";
-import { Agent as OpenAIAgent } from "@openai/agents";
+import type { Agent } from "@openai/agents";
 import { z } from "zod";
 import { resolveDefaultAiModel, resolveDefaultAiProvider, createGatewayClient } from "@/ai/agent-sdk";
 import { BaseAgent, BaseAgentState } from "@/ai/agent-sdk";
@@ -58,6 +58,7 @@ export class PlannerAgent extends BaseAgent<Env, BaseAgentState> {
       this.logger.info("Generating plan", { goalLength: goal.length, provider, model });
 
       const client = await createGatewayClient(this.env, model);
+      const { Agent: OpenAIAgent } = await import("@openai/agents");
       const planner = new OpenAIAgent({
         name: "PlannerAgent",
         model,

backend/src/ai/agents/Research.ts

@@ -7,7 +7,7 @@
 import { callable } from "agents";
 import { BaseAgent, BaseAgentState } from "@/ai/agent-sdk";
 import { Logger } from "@logging";
-import { Agent } from "@openai/agents";
+import type { Agent } from "@openai/agents";
 import { getAgentModelName } from "@/ai/utils/model-config";
 import { getOctokit } from "@services/octokit/core";
 import { z } from "zod";
@@ -117,8 +117,9 @@ export class ResearchAgent extends BaseAgent<Env, ResearchState> {
       }
     };
 
+    const { Agent: OpenAIAgent } = await import("@openai/agents");
     // Initialize agent WITH tools
-    this.agent = new Agent({
+    this.agent = new OpenAIAgent({
       name: "ResearchAgent",
       model: getAgentModelName('ResearchAgent'), // Cost-optimized: gpt-4o
       instructions: `You are a senior research analyst specializing in GitHub repository analysis.

backend/src/ai/agents/SoftwareEngineer.ts

@@ -1,4 +1,4 @@
-import { Agent as OpenAIAgent } from "@openai/agents";
+import type { Agent } from "@openai/agents";
 import { z } from "zod";
 import {
   createRunner,
@@ -36,6 +36,7 @@ export class CodeGeneratorAgent {
       resolveDefaultAiModel(this.env, provider);
     const runner = await createRunner(this.env, provider, model);
 
+    const { Agent: OpenAIAgent } = await import("@openai/agents");
     const agent = new OpenAIAgent({
       name: "CodeGeneratorAgent",
       model,

backend/src/ai/agents/base/patterns/evaluator-optimizer.ts

@@ -1,4 +1,4 @@
-import { Agent, run, type AgentInputItem, withTrace } from "@openai/agents";
+import type { AgentInputItem } from "@openai/agents";
 import { Agent as CFAgent, callable } from "agents";
 import { z } from "zod";
 
@@ -26,21 +26,23 @@ export class EvaluatorOptimizerAgent extends CFAgent<Env, EvaluatorState> {
     status: "idle"
   };
 
-  // 1. Generator Agent (The "Writer")
-  generator = new Agent({
-    name: "Generator",
-    instructions: "You are a helpful assistant. Improve your previous response based on feedback if provided."
-  });
-
-  // 2. Evaluator Agent (The "Judge")
-  evaluator = new Agent({
-    name: "Evaluator",
-    instructions: "Evaluate the content for accuracy and clarity. Provide constructive feedback.",
-    outputType: EvaluationSchema
-  });
-
   @callable()
   async execute(input: string) {
+    const { Agent, run, withTrace } = await import("@openai/agents");
+    
+    // 1. Generator Agent (The "Writer")
+    const generator = new Agent({
+      name: "Generator",
+      instructions: "You are a helpful assistant. Improve your previous response based on feedback if provided."
+    });
+
+    // 2. Evaluator Agent (The "Judge")
+    const evaluator = new Agent({
+      name: "Evaluator",
+      instructions: "Evaluate the content for accuracy and clarity. Provide constructive feedback.",
+      outputType: EvaluationSchema
+    });
+
     await withTrace("Evaluator-Optimizer Loop", async () => {
       let currentInput: AgentInputItem[] = [{ role: "user", content: input }];
       let attempts = 0;
@@ -51,14 +53,14 @@ export class EvaluatorOptimizerAgent extends CFAgent<Env, EvaluatorState> {
       while (attempts < MAX_ATTEMPTS) {
         // --- Generate ---
         console.log(`[Optimizer] Iteration ${attempts + 1}: Generating...`);
-        const genResult = await run(this.generator, currentInput);
+        const genResult = await run(generator, currentInput);
         const content = genResult.finalOutput;
 
         if (!content) throw new Error("No content generated");
 
         // --- Evaluate ---
         console.log(`[Optimizer] Iteration ${attempts + 1}: Evaluating...`);
-        const evalResult = await run(this.evaluator, [
+        const evalResult = await run(evaluator, [
           { role: "user", content: `Original Request: ${input}\nGenerated Content: ${content}` }
         ]);
 

backend/src/ai/agents/base/patterns/orchestrator-workers.ts

@@ -1,4 +1,4 @@
-import { Agent, run, withTrace } from "@openai/agents";
+// Dynamic imports used instead of static
 import { Agent as CFAgent, callable } from "agents";
 import { z } from "zod";
 
@@ -22,30 +22,32 @@ type OrchestratorState = {
 export class OrchestratorAgent extends CFAgent<Env, OrchestratorState> {
   initialState: OrchestratorState = { results: {} };
 
-  // 1. Planner Agent
-  planner = new Agent({
-    name: "Planner",
-    instructions: "Break the user request into smaller, distinct tasks.",
-    outputType: PlanSchema
-  });
+  @callable()
+  async processRequest(objective: string) {
+    const { Agent, run, withTrace } = await import("@openai/agents");
+    
+    // 1. Planner Agent
+    const planner = new Agent({
+      name: "Planner",
+      instructions: "Break the user request into smaller, distinct tasks.",
+      outputType: PlanSchema
+    });
 
-  // 2. Worker Agents
-  researcher = new Agent({
-    name: "Researcher",
-    instructions: "You are a research assistant. Find information and summarize."
-  });
+    // 2. Worker Agents
+    const researcher = new Agent({
+      name: "Researcher",
+      instructions: "You are a research assistant. Find information and summarize."
+    });
 
-  coder = new Agent({
-    name: "Coder",
-    instructions: "You are a software engineer. Write code snippets based on instructions."
-  });
+    const coder = new Agent({
+      name: "Coder",
+      instructions: "You are a software engineer. Write code snippets based on instructions."
+    });
 
-  @callable()
-  async processRequest(objective: string) {
     return await withTrace("Orchestrator Workflow", async () => {
 
       // Step 1: Create Plan
-      const planResult = await run(this.planner, objective);
+      const planResult = await run(planner, objective);
       const plan = planResult.finalOutput;
 
       if (!plan) return "Failed to generate plan";
@@ -59,8 +61,8 @@ export class OrchestratorAgent extends CFAgent<Env, OrchestratorState> {
         console.log(`[Orchestrator] Executing task: ${task.id}`);
 
         let workerAgent;
-        if (task.workerType === "researcher") workerAgent = this.researcher;
-        else workerAgent = this.coder;
+        if (task.workerType === "researcher") workerAgent = researcher;
+        else workerAgent = coder;
 
         // Run worker with context
         const result = await run(workerAgent, [