LlmAgent

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

const agent = new LlmAgent({
  name: "assistant",
  description: "A helpful AI assistant",
  model: "gemini-2.5-flash",
  instruction: "You are a helpful assistant that provides accurate information."
});

const llm = agent.canonicalModel;
// Returns BaseLlm instance

const [instruction, isDynamic] = await agent.canonicalInstruction(ctx);

const [globalInst, isDynamic] = await agent.canonicalGlobalInstruction(ctx);

const tools = await agent.canonicalTools(ctx);

type SingleBeforeModelCallback = (args: {
  callbackContext: CallbackContext;
  llmRequest: LlmRequest;
}) => LlmResponse | null | undefined | Promise<LlmResponse | null | undefined>;

type BeforeModelCallback = SingleBeforeModelCallback | SingleBeforeModelCallback[];

const agent = new LlmAgent({
  name: "cached_agent",
  model: "gpt-4",
  beforeModelCallback: async ({ llmRequest, callbackContext }) => {
    // Check cache before calling LLM
    const cached = await cache.get(llmRequest);
    if (cached) {
      return cached; // Skip LLM call
    }
    return null; // Proceed with LLM call
  }
});

type SingleAfterModelCallback = (args: {
  callbackContext: CallbackContext;
  llmResponse: LlmResponse;
}) => LlmResponse | null | undefined | Promise<LlmResponse | null | undefined>;

type AfterModelCallback = SingleAfterModelCallback | SingleAfterModelCallback[];

const agent = new LlmAgent({
  name: "filtered_agent",
  model: "gpt-4",
  afterModelCallback: async ({ llmResponse }) => {
    // Filter or modify response
    const filtered = filterContent(llmResponse);
    return filtered;
  }
});

type SingleBeforeToolCallback = (
  tool: BaseTool,
  args: Record<string, any>,
  toolContext: ToolContext
) => Record<string, any> | null | undefined | Promise<Record<string, any> | null | undefined>;

type BeforeToolCallback = SingleBeforeToolCallback | SingleBeforeToolCallback[];

const agent = new LlmAgent({
  name: "validated_agent",
  model: "gpt-4",
  tools: [apiTool],
  beforeToolCallback: async (tool, args, ctx) => {
    // Validate or modify tool arguments
    console.log(`Calling ${tool.name} with:`, args);
    
    if (tool.name === "api_call") {
      // Add authentication
      return { ...args, apiKey: process.env.API_KEY };
    }
    return null;
  }
});

type SingleAfterToolCallback = (
  tool: BaseTool,
  args: Record<string, any>,
  toolContext: ToolContext,
  toolResponse: Record<string, any>
) => Record<string, any> | null | undefined | Promise<Record<string, any> | null | undefined>;

type AfterToolCallback = SingleAfterToolCallback | SingleAfterToolCallback[];

const agent = new LlmAgent({
  name: "logging_agent",
  model: "gpt-4",
  tools: [searchTool],
  afterToolCallback: async (tool, args, ctx, response) => {
    // Log or modify tool response
    console.log(`${tool.name} returned:`, response);
    
    // Transform response if needed
    if (tool.name === "search") {
      return { ...response, timestamp: Date.now() };
    }
    return null;
  }
});

import { LlmAgent, type ReadonlyContext } from "@iqai/adk";

const agent = new LlmAgent({
  name: "contextual_agent",
  model: "gpt-4",
  instruction: async (ctx: ReadonlyContext) => {
    const userPreferences = ctx.session.state.preferences;
    const timeOfDay = new Date().getHours();
    
    return `You are a helpful assistant.
      User preferences: ${JSON.stringify(userPreferences)}
      Current time: ${timeOfDay < 12 ? 'morning' : 'afternoon'}
      Adjust your responses accordingly.`;
  }
});

import { LlmAgent } from "@iqai/adk";
import { z } from "zod";

const outputSchema = z.object({
  capital: z.string().describe("The capital city"),
  country: z.string().describe("The country name"),
  population: z.number().optional().describe("Population"),
  funFact: z.string().describe("An interesting fact")
});

const agent = new LlmAgent({
  name: "geo_agent",
  model: "gemini-2.5-flash",
  outputSchema
});

// Output will be validated and parsed
const result = await runner.ask("Tell me about Paris");
// result type: { capital: string; country: string; population?: number; funFact: string }

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

const researcher = new LlmAgent({
  name: "researcher",
  description: "Researches topics and gathers information",
  model: "gpt-4",
  tools: [searchTool, scrapeTool]
});

const analyst = new LlmAgent({
  name: "analyst",
  description: "Analyzes data and draws insights",
  model: "gpt-4"
});

const writer = new LlmAgent({
  name: "writer",
  description: "Writes polished reports",
  model: "gpt-4"
});

const coordinator = new LlmAgent({
  name: "coordinator",
  description: "Coordinates the research workflow",
  model: "gpt-4",
  subAgents: [researcher, analyst, writer],
  instruction: "Coordinate the research team to produce comprehensive reports."
});

import { 
  LlmAgent, 
  createTool, 
  MemoryService, 
  InMemoryStorageProvider 
} from "@iqai/adk";
import { z } from "zod";

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

// Define output schema
const outputSchema = z.object({
  answer: z.string(),
  sources: z.array(z.string()),
  confidence: z.number().min(0).max(1)
});

// Create memory service
const memoryService = new MemoryService({
  storage: new InMemoryStorageProvider()
});

// Create agent
const agent = new LlmAgent({
  name: "research_assistant",
  description: "A research assistant that searches and analyzes information",
  model: "gemini-2.5-flash",
  instruction: `You are a thorough research assistant.
    - Search for relevant information
    - Cite your sources
    - Provide confidence scores`,
  tools: [searchTool],
  outputSchema,
  memoryService,
  outputKey: "research_result",
  beforeModelCallback: async ({ llmRequest }) => {
    console.log("Calling LLM with", llmRequest.contents.length, "messages");
    return null;
  },
  afterToolCallback: async (tool, args, ctx, response) => {
    console.log(`${tool.name} completed:`, response);
    return null;
  }
});

// Use with AgentBuilder for easier execution
import { AgentBuilder } from "@iqai/adk";

const { runner, session } = await AgentBuilder
  .withAgent(agent)
  .build();

const result = await runner.ask("What are the latest AI trends?");
console.log(result);
// Type-safe result: { answer: string; sources: string[]; confidence: number }

type InstructionProvider = (
  ctx: ReadonlyContext
) => string | Promise<string>;

type ToolUnion = BaseTool | ((...args: any[]) => any);

interface LlmAgentConfig<T extends BaseLlm = BaseLlm> {
  name: string;
  description: string;
  model?: string | T | LanguageModel;
  instruction?: string | InstructionProvider;
  globalInstruction?: string | InstructionProvider;
  tools?: ToolUnion[];
  codeExecutor?: BaseCodeExecutor;
  planner?: BasePlanner;
  subAgents?: BaseAgent[];
  disallowTransferToParent?: boolean;
  disallowTransferToPeers?: boolean;
  includeContents?: "default" | "none";
  outputKey?: string;
  inputSchema?: ZodSchema;
  outputSchema?: ZodSchema;
  memoryService?: MemoryService;
  sessionService?: BaseSessionService;
  artifactService?: BaseArtifactService;
  plugins?: BasePlugin[];
  beforeAgentCallback?: BeforeAgentCallback;
  afterAgentCallback?: AfterAgentCallback;
  beforeModelCallback?: BeforeModelCallback;
  afterModelCallback?: AfterModelCallback;
  beforeToolCallback?: BeforeToolCallback;
  afterToolCallback?: AfterToolCallback;
  // ... other fields
}