AgentBuilder

const builder = AgentBuilder.create("research-agent");

const builder = AgentBuilder.withModel("gemini-2.5-flash");

const existingAgent = new LlmAgent({ name: "my-agent", model: "gpt-4" });
const builder = AgentBuilder.withAgent(existingAgent);

builder.withModel("gemini-2.5-flash");

builder.withDescription("A research assistant that can search and analyze information");

builder.withInstruction("You are a helpful research assistant. Always cite sources.");

import { createTool } from "@iqai/adk";

const searchTool = createTool({
  name: "search",
  description: "Search for information",
  fn: async (query: string) => {
    // Search implementation
    return results;
  }
});

builder.withTools(searchTool, anotherTool);

builder.withPlanner(new MyPlanner());

import { LocalCodeExecutor } from "@iqai/adk";

builder.withCodeExecutor(new LocalCodeExecutor());

const agent1 = new LlmAgent({ name: "writer", model: "gpt-4" });
const agent2 = new LlmAgent({ name: "editor", model: "gpt-4" });

builder.withSubAgents([agent1, agent2]);

import { LoggingPlugin, MetricsPlugin } from "@iqai/adk";

builder.withPlugins(
  new LoggingPlugin(),
  new MetricsPlugin()
);

builder
  .withModel("gpt-4o")
  .withFallbackModels("gpt-3.5-turbo", "gemini-2.0-flash");

import { z } from "zod";

const inputSchema = z.object({
  query: z.string(),
  maxResults: z.number().optional()
});

builder.withInputSchema(inputSchema);

import { z } from "zod";

const outputSchema = z.object({
  capital: z.string(),
  country: z.string(),
  population: z.number().optional(),
  funFact: z.string()
});

const { runner } = await AgentBuilder
  .withModel("gemini-2.5-flash")
  .withOutputSchema(outputSchema)
  .build();

const result = await runner.ask("What is the capital of France?");
// result is typed as { capital: string; country: string; ... }

builder.withOutputKey("research_results");

import { InMemorySessionService } from "@iqai/adk";

const sessionService = new InMemorySessionService();

builder.withSessionService(sessionService, {
  userId: "user-123",
  appName: "my-app"
});

const session = await sessionService.createSession("app", "user-123");
builder.withSession(session);

builder.withQuickSession({
  userId: "test-user",
  appName: "test-app"
});

import { MemoryService, InMemoryStorageProvider } from "@iqai/adk";

const memoryService = new MemoryService({
  storage: new InMemoryStorageProvider()
});

builder.withMemory(memoryService);

import { InMemoryArtifactService } from "@iqai/adk";

builder.withArtifactService(new InMemoryArtifactService());

import { RunConfig } from "@iqai/adk";

builder.withRunConfig(new RunConfig({
  maxLlmCalls: 10
}));

builder.withEventsCompaction({
  compactionInterval: 10,
  overlapSize: 2
});

import { ContextCacheConfig } from "@iqai/adk";

builder.withContextCacheConfig(new ContextCacheConfig());

const agent = await AgentBuilder
  .create("workflow")
  .asSequential([researchAgent, writerAgent, editorAgent])
  .build();

const agent = await AgentBuilder
  .create("multi-search")
  .asParallel([searchAgent1, searchAgent2, searchAgent3])
  .build();

const agent = await AgentBuilder
  .create("iterative-refiner")
  .asLoop([generatorAgent, reviewerAgent], 5)
  .build();

const nodes = [
  { name: "start", agent: startAgent, next: "process" },
  { name: "process", agent: processAgent, next: "end" },
  { name: "end", agent: endAgent }
];

const agent = await AgentBuilder
  .create("graph-workflow")
  .asLangGraph(nodes, "start")
  .build();

builder.withBeforeAgentCallback(async (ctx) => {
  console.log("Agent starting:", ctx.agent.name);
  // Return undefined to continue, or Content to skip agent run
  return undefined;
});

builder.withAfterAgentCallback(async (ctx) => {
  console.log("Agent completed:", ctx.agent.name);
  return undefined;
});

builder.withBeforeModelCallback(async ({ llmRequest }) => {
  console.log("Calling LLM with:", llmRequest);
  // Return LlmResponse to override, null/undefined to continue
  return null;
});

builder.withAfterModelCallback(async ({ llmResponse }) => {
  console.log("LLM responded:", llmResponse);
  return null;
});

builder.withBeforeToolCallback(async (tool, args, ctx) => {
  console.log(`Calling tool ${tool.name} with:`, args);
  // Return modified args, null, or undefined
  return null;
});

builder.withAfterToolCallback(async (tool, args, ctx, response) => {
  console.log(`Tool ${tool.name} returned:`, response);
  // Return modified response, null, or undefined
  return null;
});

const { agent, runner, session } = await AgentBuilder
  .withModel("gemini-2.5-flash")
  .withTools(searchTool)
  .build();

const response = await runner.ask("Search for AI news");

const outputSchema = z.object({
  answer: z.string(),
  confidence: z.number()
});

const { runner } = await AgentBuilder
  .withModel("gpt-4")
  .withOutputSchema(outputSchema)
  .buildWithSchema<z.infer<typeof outputSchema>>();

const result = await runner.ask("What is 2+2?");
// result is fully typed

for await (const event of runner.runAsync({
  userId: session.userId,
  sessionId: session.id,
  newMessage: { parts: [{ text: "Hello" }] }
})) {
  console.log(event);
}

type AgentType = "llm" | "sequential" | "parallel" | "loop" | "langgraph";

type MultiAgentResponse = { agent: string; response: string }[];

type RunnerAskReturn<T, M extends boolean> = M extends true
  ? MultiAgentResponse
  : T;

interface BuiltAgent<T = string, M extends boolean = false> {
  agent: BaseAgent;
  runner: EnhancedRunner<T, M>;
  session: Session;
  sessionService: BaseSessionService;
  memoryService?: MemoryService;
}

interface SessionOptions {
  userId?: string;
  appName?: string;
  state?: Record<string, any>;
  sessionId?: string;
}