Planning

import { BasePlanner } from '@iqai/adk';
import type { ReadonlyContext, CallbackContext } from '@iqai/adk';

export abstract class BasePlanner {
  // Build system instruction for planning
  abstract buildPlanningInstruction(
    readonlyContext: ReadonlyContext,
    llmRequest: LlmRequest,
  ): string | undefined;
  
  // Process LLM response for planning
  abstract processPlanningResponse(
    callbackContext: CallbackContext,
    responseParts: Part[],
  ): Part[] | undefined;
}

import { BuiltInPlanner, AgentBuilder } from '@iqai/adk';

const planner = new BuiltInPlanner({
  thinkingConfig: {
    type: 'enabled',
    budget: 10000, // Token budget for thinking
  }
});

const agent = new AgentBuilder()
  .withName('ThinkingAgent')
  .withModel('claude-sonnet-4-20250514')
  .withPlanner(planner)
  .buildLoop(); // Loop agents support planning

import { PlanReActPlanner, AgentBuilder } from '@iqai/adk';

const planner = new PlanReActPlanner();

const agent = new AgentBuilder()
  .withName('PlanningAgent')
  .withModel('gpt-4')
  .withTools([searchTool, calculatorTool])
  .withPlanner(planner)
  .buildLoop();

// Planning tags
/*PLANNING*/
1. Use search tool to find current price of Bitcoin
2. Use calculator to compute 5 BTC in USD
3. Format and return the result

/*ACTION*/
search("Bitcoin price USD")

/*REASONING*/
The search returned $42,000 per BTC. Now I'll calculate 5 * 42,000.

/*ACTION*/
calculate("5 * 42000")

/*FINAL_ANSWER*/
The value of 5 Bitcoin is $210,000 USD.

/*PLANNING*/
1. Fetch user data from API
2. Process and analyze

/*ACTION*/
fetchUserData(userId)

/*REASONING*/
The API returned an error. I need to revise my plan.

/*REPLANNING*/
1. Check if user exists in local cache
2. Use cached data if available
3. Otherwise inform user of API issue

import { AgentBuilder, PlanReActPlanner } from '@iqai/adk';

const agent = new AgentBuilder()
  .withName('ResearchAgent')
  .withModel('gpt-4')
  .withInstruction(`
    You are a research assistant. Use available tools to gather
    information and provide comprehensive answers.
  `)
  .withTools([webSearchTool, calculatorTool, noteTakingTool])
  .withPlanner(new PlanReActPlanner())
  .buildLoop(); // Important: Use buildLoop() for planning

const response = await agent.ask(
  'What is the current market cap of Tesla and how does it compare to Ford?'
);

for await (const event of agent.runAsync(context)) {
  // Check for planning/reasoning parts
  if (event.content?.parts) {
    for (const part of event.content.parts) {
      if (part.thought) {
        console.log('Agent thinking:', part.text);
      } else if (part.text) {
        console.log('Agent output:', part.text);
      }
    }
  }
}

import { BasePlanner } from '@iqai/adk';
import type { Part } from '@google/genai';

export class TreeOfThoughtsPlanner extends BasePlanner {
  buildPlanningInstruction(readonlyContext, llmRequest): string {
    return `
      Generate multiple potential approaches to solve this problem.
      For each approach:
      1. Outline the steps
      2. Evaluate feasibility
      3. Score the approach (1-10)
      
      Then, select the highest-scoring approach and execute it.
      
      Use the tag /*APPROACHES*/ for listing options.
      Use the tag /*SELECTED_APPROACH*/ for your choice.
      Use the tag /*EXECUTION*/ for implementation.
    `;
  }
  
  processPlanningResponse(callbackContext, responseParts): Part[] {
    const processedParts: Part[] = [];
    
    for (const part of responseParts) {
      if (part.text?.includes('/*APPROACHES*/') || 
          part.text?.includes('/*SELECTED_APPROACH*/')) {
        // Mark as thought/reasoning
        part.thought = true;
      }
      
      if (part.functionCall) {
        // Allow function calls through
        processedParts.push(part);
      } else if (part.text?.includes('/*EXECUTION*/')) {
        // Include execution text
        processedParts.push(part);
      }
    }
    
    return processedParts;
  }
}

const customPlanner = new TreeOfThoughtsPlanner();

const agent = new AgentBuilder()
  .withName('ComplexProblemSolver')
  .withModel('gpt-4')
  .withPlanner(customPlanner)
  .buildLoop();

import { AgentBuilder, PlanReActPlanner, BaseTool } from '@iqai/adk';

class DatabaseTool extends BaseTool {
  name = 'database_query';
  description = 'Execute SQL queries against the database';
  
  async execute(context, args) {
    return await this.db.query(args.sql);
  }
}

const agent = new AgentBuilder()
  .withModel('gpt-4')
  .withTools([
    new DatabaseTool(),
    new APITool(),
    new VisualizationTool(),
  ])
  .withPlanner(new PlanReActPlanner())
  .withInstruction(`
    Plan your approach before using tools.
    Consider which tools to use and in what order.
  `)
  .buildLoop();

interface ThinkingConfig {
  type: 'enabled' | 'disabled';
  budget?: number;        // Token budget for thinking
  allowPartial?: boolean; // Allow incomplete thinking
}

const planner = new BuiltInPlanner({
  thinkingConfig: {
    type: 'enabled',
    budget: 5000,
    allowPartial: false,
  }
});

class ContextAwarePlanner extends BasePlanner {
  buildPlanningInstruction(readonlyContext, llmRequest): string {
    const availableTools = llmRequest.config?.tools || [];
    const toolNames = availableTools.map(t => t.name).join(', ');
    
    return `
      You have access to these tools: ${toolNames}
      
      Plan your approach using only these tools.
      Break down complex tasks into tool invocations.
    `;
  }
}