@google/adk 0.5.0 → 0.6.0

package/dist/types/a2a/a2a_remote_agent_utils.d.ts

@@ -0,0 +1,38 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Part as A2APart } from '@a2a-js/sdk';
+import { InvocationContext } from '../agents/invocation_context.js';
+import { Event as AdkEvent } from '../events/event.js';
+import { Session } from '../sessions/session.js';
+export interface UserFunctionCall {
+    response: AdkEvent;
+    taskId: string;
+    contextId: string;
+}
+/**
+ * Returns a UserFunctionCall when the event at index has a FunctionResponse.
+ */
+export declare function getUserFunctionCallAt(session: Session, index: number): UserFunctionCall | undefined;
+/**
+ * Checks if an event contains a function call with the given ID.
+ */
+export declare function isFunctionCallEvent(event: AdkEvent, callId: string): boolean;
+/**
+ * Finds the first part with a FunctionResponse and returns the call ID.
+ */
+export declare function getFunctionResponseCallId(event: AdkEvent): string | undefined;
+/**
+ * Returns content parts for all events not present in the remote session
+ * and a2a contextId if found in a remote agent event metadata.
+ */
+export declare function toMissingRemoteSessionParts(ctx: InvocationContext, session: Session): {
+    parts: A2APart[];
+    contextId?: string;
+};
+/**
+ * Wraps an agent event as a user message for context.
+ */
+export declare function presentAsUserMessage(ctx: InvocationContext, agentEvent: AdkEvent): AdkEvent;

package/dist/types/a2a/agent_card.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { AgentCard, AgentInterface, AgentSkill } from '@a2a-js/sdk';
+import { BaseAgent } from '../agents/base_agent.js';
+/**
+ * Resolves the AgentCard from the provided source.
+ */
+export declare function resolveAgentCard(agentCard: AgentCard | string): Promise<AgentCard>;
+/**
+ * Converts an ADK agent to an A2A AgentCard.
+ */
+export declare function getA2AAgentCard(agent: BaseAgent, transports: AgentInterface[]): Promise<AgentCard>;
+/**
+ * Builds a list of AgentSkills based on agent descriptions and types.
+ * This information can be used in AgentCard to help clients understand agent capabilities.
+ *
+ * @param agent The agent to build skills for.
+ * @returns A promise resolving to a list of AgentSkills.
+ */
+export declare function buildAgentSkills(agent: BaseAgent): Promise<AgentSkill[]>;

package/dist/types/a2a/agent_executor.d.ts

@@ -0,0 +1,52 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { TaskArtifactUpdateEvent, TaskStatusUpdateEvent } from '@a2a-js/sdk';
+import { AgentExecutor, ExecutionEventBus, RequestContext } from '@a2a-js/sdk/server';
+import { RunConfig } from '../agents/run_config.js';
+import { Event as AdkEvent } from '../events/event.js';
+import { Runner, RunnerConfig } from '../runner/runner.js';
+import { ExecutorContext } from './executor_context.js';
+/**
+ * Represents a runner or a configuration for a runner.
+ */
+export type RunnerOrRunnerConfig = Runner | RunnerConfig | (() => Runner | RunnerConfig) | (() => Promise<Runner | RunnerConfig>);
+/**
+ * Callback called before execution starts.
+ */
+export type BeforeExecuteCallback = (reqCtx: RequestContext) => Promise<void>;
+/**
+ * Callback called after an ADK event is converted to an A2A event.
+ */
+export type AfterEventCallback = (ctx: ExecutorContext, adkEvent: AdkEvent, a2aEvent?: TaskArtifactUpdateEvent) => Promise<void>;
+/**
+ * Callback called after execution resolved into a completed or failed task.
+ */
+export type AfterExecuteCallback = (ctx: ExecutorContext, finalA2aEvent: TaskStatusUpdateEvent, err?: Error) => Promise<void>;
+/**
+ * Configuration for the Executor.
+ */
+export interface AgentExecutorConfig {
+    runner: RunnerOrRunnerConfig;
+    runConfig?: RunConfig;
+    beforeExecuteCallback?: BeforeExecuteCallback;
+    afterEventCallback?: AfterEventCallback;
+    afterExecuteCallback?: AfterExecuteCallback;
+}
+/**
+ * AgentExecutor invokes an ADK agent and translates session events to A2A events.
+ */
+export declare class A2AAgentExecutor implements AgentExecutor {
+    private readonly config;
+    private agentPartialArtifactIdsMap;
+    constructor(config: AgentExecutorConfig);
+    execute(ctx: RequestContext, eventBus: ExecutionEventBus): Promise<void>;
+    cancelTask(_taskId: string): Promise<void>;
+    private convertAdkEventToA2AEvent;
+    /**
+     * Writes the final status event to the queue.
+     */
+    private publishFinalTaskStatus;
+}

package/dist/types/a2a/agent_to_a2a.d.ts

@@ -0,0 +1,45 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { AgentCard } from '@a2a-js/sdk';
+import express from 'express';
+import { BaseAgent } from '../agents/base_agent.js';
+import { BaseArtifactService } from '../artifacts/base_artifact_service.js';
+import { BaseMemoryService } from '../memory/base_memory_service.js';
+import { Runner } from '../runner/runner.js';
+import { BaseSessionService } from '../sessions/base_session_service.js';
+/**
+ * Options for the `toA2a` function.
+ */
+export interface ToA2aOptions {
+    /** The host for the A2A RPC URL (default: "localhost") */
+    host?: string;
+    /** The port for the A2A RPC URL (default: 8000) */
+    port?: number;
+    /** The protocol for the A2A RPC URL (default: "http") */
+    protocol?: string;
+    /** The base path for the A2A RPC URL (default: "a2a") */
+    basePath?: string;
+    /** Optional pre-built AgentCard object or path to agent card JSON */
+    agentCard?: AgentCard | string;
+    /** Optional pre-built Runner object */
+    runner?: Runner;
+    /** Optional session service */
+    sessionService?: BaseSessionService;
+    /** Optional memory service */
+    memoryService?: BaseMemoryService;
+    /** Optional artifact service */
+    artifactService?: BaseArtifactService;
+    /** Optional existing express application */
+    app?: express.Application;
+}
+/**
+ * Converts an ADK agent to an Express application with A2A handlers.
+ *
+ * @param agent The ADK agent to convert
+ * @param options Configuration options
+ * @returns An Express application
+ */
+export declare function toA2a(agent: BaseAgent, options?: ToA2aOptions): Promise<express.Application>;

package/dist/types/a2a/event_processor_utils.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Task, TaskStatusUpdateEvent } from '@a2a-js/sdk';
+import { Content as GenAIContent } from '@google/genai';
+import { Event as AdkEvent } from '../events/event.js';
+import { ExecutorContext } from './executor_context.js';
+/**
+ * Processes a list of ADK events and determines the final task status update event.
+ * If any of the ADK events contain an error, a TaskFailedEvent is returned immediately.
+ * If there are no errors, it checks for any input required events. If found, it returns a TaskInputRequiredEvent.
+ * If there are no input required events, it returns a TaskCompletedEvent.
+ *
+ * @param adkEvents - The list of ADK events to process.
+ * @param context - The executor context containing relevant information for processing the events.
+ * @returns A TaskStatusUpdateEvent representing the final status of the task after processing the ADK events.
+ */
+export declare function getFinalTaskStatusUpdate(adkEvents: AdkEvent[], context: ExecutorContext): TaskStatusUpdateEvent;
+/**
+ * Returns input required task status update events if the provided user request does not contain responses for all function calls in the task status.
+ */
+export declare function getTaskInputRequiredEvent(task: Task, genAIContent: GenAIContent): TaskStatusUpdateEvent | undefined;

package/dist/types/a2a/executor_context.d.ts

@@ -13,7 +13,7 @@ import { Session } from '../sessions/session.js';
 export interface ExecutorContext {
     userId: string;
     sessionId: string;
-    agentName: string;
+    appName: string;
     readonlyState: Record<string, unknown>;
     events: Event[];
     userContent: Content;

package/dist/types/a2a/metadata_converter_utils.d.ts

@@ -27,7 +27,8 @@ export declare enum A2AMetadataKeys {
     CITATION_METADATA = "adk_citation_metadata",
     GROUNDING_METADATA = "adk_grounding_metadata",
     USAGE_METADATA = "adk_usage_metadata",
-    CUSTOM_METADATA = "adk_custom_metadata"
+    CUSTOM_METADATA = "adk_custom_metadata",
+    VIDEO_METADATA = "adk_video_metadata"
 }
 /**
  * Keys for metadata that will be stored in ADK event metadata and related to A2A messages.

package/dist/types/agents/llm_agent.d.ts

@@ -18,6 +18,7 @@ import { BaseToolset } from '../tools/base_toolset.js';
 import { Context } from './context.js';
 import { BaseAgent, BaseAgentConfig } from './base_agent.js';
 import { BaseLlmRequestProcessor, BaseLlmResponseProcessor } from './processors/base_llm_processor.js';
+import { BaseContextCompactor } from '../context/base_context_compactor.js';
 import { InvocationContext } from './invocation_context.js';
 import { ReadonlyContext } from './readonly_context.js';
 /**
@@ -199,6 +200,11 @@ export interface LlmAgentConfig extends BaseAgentConfig {
      * Processors to run after the LLM response is received.
      */
     responseProcessors?: BaseLlmResponseProcessor[];
+    /**
+     * A list of context compactors to evaluate in priority order.
+     * Modifies the session history to keep context overhead within limits.
+     */
+    contextCompactors?: BaseContextCompactor[];
     /**
      * Instructs the agent to make a plan and execute it step by step.
      */

package/dist/types/agents/loop_agent.d.ts

@@ -39,7 +39,7 @@ export declare class LoopAgent extends BaseAgent {
      * A unique symbol to identify ADK loop agent class.
      */
     readonly [LOOP_AGENT_SIGNATURE_SYMBOL] = true;
-    private readonly maxIterations;
+    readonly maxIterations: number;
     constructor(config: LoopAgentConfig);
     protected runAsyncImpl(context: InvocationContext): AsyncGenerator<Event, void, void>;
     protected runLiveImpl(_context: InvocationContext): AsyncGenerator<Event, void, void>;

package/dist/types/agents/{content_processor_utils.d.ts → processors/content_processor_utils.d.ts}

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { Content } from '@google/genai';
-import { Event } from '../events/event.js';
+import { Event } from '../../events/event.js';
 /**
  * Get the contents for the LLM request.
  *

package/dist/types/agents/processors/context_compactor_request_processor.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { BaseContextCompactor } from '../../context/base_context_compactor.js';
+import { Event } from '../../events/event.js';
+import { LlmRequest } from '../../models/llm_request.js';
+import { InvocationContext } from '../invocation_context.js';
+import { BaseLlmRequestProcessor } from './base_llm_processor.js';
+/**
+ * A processor that evaluates a set of compactors to optionally compact
+ * the conversation history (events) prior to generating an LLM request.
+ *
+ * It evaluates each compactor in priority order. The first one that indicates
+ * it should compact will perform the compaction and iteration stops.
+ */
+export declare class ContextCompactorRequestProcessor implements BaseLlmRequestProcessor {
+    private compactors;
+    constructor(compactors: BaseContextCompactor[]);
+    runAsync(invocationContext: InvocationContext, _llmRequest: LlmRequest): AsyncGenerator<Event, void, void>;
+}

package/dist/types/artifacts/file_artifact_service.d.ts

@@ -41,3 +41,7 @@ export declare class FileArtifactService implements BaseArtifactService {
     listArtifactVersions({ userId, sessionId, filename, }: ListVersionsRequest): Promise<ArtifactVersion[]>;
     getArtifactVersion({ userId, sessionId, filename, version, }: LoadArtifactRequest): Promise<ArtifactVersion | undefined>;
 }
+export declare function assertSafeSegment(value: string, label: string): void;
+export declare function assertInsideRoot(resolvedPath: string, rootDir: string, label: string): void;
+export declare function getUserRoot(rootDir: string, userId: string): string;
+export declare function getSessionArtifactsDir(baseRoot: string, sessionId: string): string;

package/dist/types/common.d.ts

@@ -19,6 +19,8 @@ export { LoopAgent, isLoopAgent } from './agents/loop_agent.js';
 export type { LoopAgentConfig } from './agents/loop_agent.js';
 export { ParallelAgent, isParallelAgent } from './agents/parallel_agent.js';
 export { BaseLlmRequestProcessor, BaseLlmResponseProcessor, } from './agents/processors/base_llm_processor.js';
+export { CONTENT_REQUEST_PROCESSOR, ContentRequestProcessor, } from './agents/processors/content_request_processor.js';
+export { ContextCompactorRequestProcessor } from './agents/processors/context_compactor_request_processor.js';
 export { ReadonlyContext } from './agents/readonly_context.js';
 export { StreamingMode } from './agents/run_config.js';
 export type { RunConfig } from './agents/run_config.js';
@@ -35,6 +37,16 @@ export { BaseCodeExecutor } from './code_executors/base_code_executor.js';
 export type { ExecuteCodeParams } from './code_executors/base_code_executor.js';
 export { BuiltInCodeExecutor } from './code_executors/built_in_code_executor.js';
 export type { CodeExecutionInput, CodeExecutionResult, File, } from './code_executors/code_execution_utils.js';
+export type { BaseContextCompactor } from './context/base_context_compactor.js';
+export type { BaseSummarizer } from './context/summarizers/base_summarizer.js';
+export { LlmSummarizer } from './context/summarizers/llm_summarizer.js';
+export type { LlmSummarizerOptions } from './context/summarizers/llm_summarizer.js';
+export { TokenBasedContextCompactor } from './context/token_based_context_compactor.js';
+export type { TokenBasedContextCompactorOptions } from './context/token_based_context_compactor.js';
+export { TruncatingContextCompactor } from './context/truncating_context_compactor.js';
+export type { TruncatingContextCompactorOptions } from './context/truncating_context_compactor.js';
+export { isCompactedEvent } from './events/compacted_event.js';
+export type { CompactedEvent } from './events/compacted_event.js';
 export { createEvent, getFunctionCalls, getFunctionResponses, hasTrailingCodeExecutionResult, isFinalResponse, stringifyContent, } from './events/event.js';
 export type { Event } from './events/event.js';
 export { createEventActions } from './events/event_actions.js';
@@ -62,7 +74,7 @@ export { PluginManager } from './plugins/plugin_manager.js';
 export { InMemoryPolicyEngine, PolicyOutcome, REQUEST_CONFIRMATION_FUNCTION_CALL_NAME, SecurityPlugin, getAskUserConfirmationFunctionCalls, } from './plugins/security_plugin.js';
 export type { BasePolicyEngine, PolicyCheckResult, ToolCallPolicyContext, } from './plugins/security_plugin.js';
 export { InMemoryRunner } from './runner/in_memory_runner.js';
-export { Runner } from './runner/runner.js';
+export { Runner, isRunner } from './runner/runner.js';
 export type { RunnerConfig } from './runner/runner.js';
 export { BaseSessionService } from './sessions/base_session_service.js';
 export type { AppendEventRequest, CreateSessionRequest, DeleteSessionRequest, GetSessionConfig, GetSessionRequest, ListSessionsRequest, ListSessionsResponse, } from './sessions/base_session_service.js';
@@ -80,7 +92,10 @@ export { EXIT_LOOP, ExitLoopTool } from './tools/exit_loop_tool.js';
 export { FunctionTool, isFunctionTool } from './tools/function_tool.js';
 export type { ToolExecuteArgument, ToolExecuteFunction, ToolInputParameters, ToolOptions, } from './tools/function_tool.js';
 export { GOOGLE_SEARCH, GoogleSearchTool } from './tools/google_search_tool.js';
+export { LOAD_ARTIFACTS, LoadArtifactsTool, } from './tools/load_artifacts_tool.js';
+export { LOAD_MEMORY, LoadMemoryTool } from './tools/load_memory_tool.js';
 export { LongRunningFunctionTool } from './tools/long_running_tool.js';
+export { PRELOAD_MEMORY, PreloadMemoryTool, } from './tools/preload_memory_tool.js';
 export { ToolConfirmation } from './tools/tool_confirmation.js';
 export { LogLevel, getLogger, setLogLevel, setLogger } from './utils/logger.js';
 export type { Logger } from './utils/logger.js';

package/dist/types/context/base_context_compactor.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { InvocationContext } from '../agents/invocation_context.js';
+/**
+ * Interface for compacting the context history in an agent session.
+ */
+export interface BaseContextCompactor {
+    /**
+     * Determines whether the context should be compacted.
+     *
+     * @param invocationContext The current invocation context.
+     * @returns A boolean or a promise resolving to a boolean indicating if compaction should occur.
+     */
+    shouldCompact(invocationContext: InvocationContext): boolean | Promise<boolean>;
+    /**
+     * Compacts the context in place.
+     *
+     * @param invocationContext The current invocation context.
+     */
+    compact(invocationContext: InvocationContext): void | Promise<void>;
+}

package/dist/types/context/summarizers/base_summarizer.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Event } from '../../events/event.js';
+import { CompactedEvent } from '../../events/compacted_event.js';
+/**
+ * Interface for summarizing a list of events into a single CompactedEvent.
+ */
+export interface BaseSummarizer {
+    /**
+     * Summarizes the given events into a CompactedEvent.
+     *
+     * @param events The events to summarize.
+     * @returns A promise resolving to the CompactedEvent representation of the events.
+     */
+    summarize(events: Event[]): Promise<CompactedEvent>;
+}

package/dist/types/context/summarizers/llm_summarizer.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { CompactedEvent } from '../../events/compacted_event.js';
+import { Event } from '../../events/event.js';
+import { BaseLlm } from '../../models/base_llm.js';
+import { BaseSummarizer } from './base_summarizer.js';
+export interface LlmSummarizerOptions {
+    llm: BaseLlm;
+    prompt?: string;
+}
+/**
+ * A summarizer that uses an LLM to generate a compacted representation
+ * of existing events.
+ */
+export declare class LlmSummarizer implements BaseSummarizer {
+    private readonly llm;
+    private readonly prompt;
+    constructor(options: LlmSummarizerOptions);
+    summarize(events: Event[]): Promise<CompactedEvent>;
+}

package/dist/types/context/token_based_context_compactor.d.ts

@@ -0,0 +1,33 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { InvocationContext } from '../agents/invocation_context.js';
+import { BaseContextCompactor } from './base_context_compactor.js';
+import { BaseSummarizer } from './summarizers/base_summarizer.js';
+export interface TokenBasedContextCompactorOptions {
+    /** The maximum number of tokens to retain in the session history before compaction. */
+    tokenThreshold: number;
+    /**
+     * The minimum number of raw events to keep at the end of the session.
+     * Compaction will not affect these tail events (unless needed for tool splits).
+     */
+    eventRetentionSize: number;
+    /** The summarizer used to create the compacted event content. */
+    summarizer: BaseSummarizer;
+}
+/**
+ * A context compactor that uses token count to determine when to compact events.
+ * Oldest events are summarized into a CompactedEvent when the session
+ * history exceeds the token threshold.
+ */
+export declare class TokenBasedContextCompactor implements BaseContextCompactor {
+    private readonly tokenThreshold;
+    private readonly eventRetentionSize;
+    private readonly summarizer;
+    constructor(options: TokenBasedContextCompactorOptions);
+    private getActiveEvents;
+    shouldCompact(invocationContext: InvocationContext): boolean | Promise<boolean>;
+    compact(invocationContext: InvocationContext): Promise<void>;
+}

package/dist/types/context/truncating_context_compactor.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { InvocationContext } from '../agents/invocation_context.js';
+import { BaseContextCompactor } from './base_context_compactor.js';
+export interface TruncatingContextCompactorOptions {
+    /** The maximum number of events to retain in the session history. */
+    threshold: number;
+    /** Keep the first X events in the history, which often act as the initial grounding prompt. */
+    preserveLeadingEvents?: number;
+}
+/**
+ * A simple context compactor that truncates the oldest events to get under
+ * the given threshold limit.
+ */
+export declare class TruncatingContextCompactor implements BaseContextCompactor {
+    private readonly threshold;
+    private readonly preserveLeadingEvents;
+    constructor(options: TruncatingContextCompactorOptions);
+    shouldCompact(invocationContext: InvocationContext): boolean;
+    compact(invocationContext: InvocationContext): void;
+}

package/dist/types/events/compacted_event.d.ts

@@ -0,0 +1,33 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Event } from './event.js';
+/**
+ * A specialized Event type that represents a synthesized summary of past events.
+ * This is used to compress session history without losing critical context.
+ */
+export interface CompactedEvent extends Event {
+    /**
+     * Identifies this event as a compacted event.
+     */
+    readonly isCompacted: true;
+    /**
+     * The start time of the context that was compacted.
+     */
+    startTime: number;
+    /**
+     * The end time of the context that was compacted.
+     */
+    endTime: number;
+    /**
+     * The summarized content of the compacted events.
+     */
+    compactedContent: string;
+}
+/**
+ * Type guard to check if an event is a CompactedEvent.
+ */
+export declare function isCompactedEvent(event: Event): event is CompactedEvent;
+export declare function createCompactedEvent(params?: Partial<CompactedEvent>): CompactedEvent;

package/dist/types/index.d.ts

@@ -3,6 +3,14 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+export { AGENT_CARD_PATH, RemoteA2AAgent } from './a2a/a2a_remote_agent.js';
+export type { A2AStreamEventData, AfterA2ARequestCallback, BeforeA2ARequestCallback, RemoteA2AAgentConfig, } from './a2a/a2a_remote_agent.js';
+export { getA2AAgentCard } from './a2a/agent_card.js';
+export { A2AAgentExecutor } from './a2a/agent_executor.js';
+export type { AfterEventCallback, AfterExecuteCallback, AgentExecutorConfig, BeforeExecuteCallback, RunnerOrRunnerConfig, } from './a2a/agent_executor.js';
+export { toA2a } from './a2a/agent_to_a2a.js';
+export type { ToA2aOptions } from './a2a/agent_to_a2a.js';
+export type { ExecutorContext } from './a2a/executor_context.js';
 export { FileArtifactService } from './artifacts/file_artifact_service.js';
 export { GcsArtifactService } from './artifacts/gcs_artifact_service.js';
 export { getArtifactServiceFromUri } from './artifacts/registry.js';

package/dist/types/runner/runner.d.ts

@@ -31,7 +31,19 @@ export interface RunnerConfig {
     memoryService?: BaseMemoryService;
     credentialService?: BaseCredentialService;
 }
+/**
+ * A unique symbol to identify ADK agent classes.
+ * Defined once and shared by all Runner instances.
+ */
+declare const RUNNER_SIGNATURE_SYMBOL: unique symbol;
+/**
+ * Type guard to check if an object is an instance of Runner.
+ * @param obj The object to check.
+ * @returns True if the object is an instance of Runner, false otherwise.
+ */
+export declare function isRunner(obj: unknown): obj is Runner;
 export declare class Runner {
+    readonly [RUNNER_SIGNATURE_SYMBOL] = true;
     readonly appName: string;
     readonly agent: BaseAgent;
     readonly pluginManager: PluginManager;
@@ -101,3 +113,4 @@ export declare class Runner {
      */
     private isRoutableLlmAgent;
 }
+export {};

package/dist/types/sessions/db/operations.d.ts

@@ -15,11 +15,10 @@ export declare function getConnectionOptionsFromUri(uri: string): Promise<MikroO
 /**
  * Creates a database and tables if they don't exist.
  *
- * @param url The database connection URI (e.g., "postgres://user:password@host:port/database")
+ * @param orm The MikroORM instance.
  * @returns Promise<void>
- * @throws Error if the URI is invalid or unsupported
  */
-export declare function ensureDatabaseCreated(ormOrUrlOrOptions: MikroORM | MikroORMOptions | string): Promise<void>;
+export declare function ensureDatabaseCreated(orm: MikroORM): Promise<void>;
 /**
  * Validates the schema version.
  *

package/dist/types/tools/load_artifacts_tool.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { FunctionDeclaration } from '@google/genai';
+import { BaseTool, RunAsyncToolRequest, ToolProcessLlmRequest } from './base_tool.js';
+/**
+ * A tool that loads the artifacts and adds them to the session.
+ */
+export declare class LoadArtifactsTool extends BaseTool {
+    constructor();
+    _getDeclaration(): FunctionDeclaration | undefined;
+    runAsync({ args }: RunAsyncToolRequest): Promise<unknown>;
+    processLlmRequest(request: ToolProcessLlmRequest): Promise<void>;
+    private appendArtifactsToLlmRequest;
+}
+/**
+ * A global instance of {@link LoadArtifactsTool}.
+ */
+export declare const LOAD_ARTIFACTS: LoadArtifactsTool;

package/dist/types/tools/load_memory_tool.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { FunctionDeclaration } from '@google/genai';
+import { BaseTool, RunAsyncToolRequest, ToolProcessLlmRequest } from './base_tool.js';
+/**
+ * A tool that loads the memory for the current user.
+ *
+ * NOTE: Currently this tool only uses text part from the memory.
+ */
+export declare class LoadMemoryTool extends BaseTool {
+    constructor();
+    _getDeclaration(): FunctionDeclaration | undefined;
+    runAsync({ args, toolContext, }: RunAsyncToolRequest): Promise<unknown>;
+    processLlmRequest(request: ToolProcessLlmRequest): Promise<void>;
+}
+/**
+ * A global instance of {@link LoadMemoryTool}.
+ */
+export declare const LOAD_MEMORY: LoadMemoryTool;

package/dist/types/tools/preload_memory_tool.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { BaseTool, RunAsyncToolRequest, ToolProcessLlmRequest } from './base_tool.js';
+/**
+ * A tool that preloads the memory for the current user.
+ *
+ * This tool will be automatically executed for each llm_request, and it won't be
+ * called by the model.
+ *
+ * NOTE: Currently this tool only uses text part from the memory.
+ */
+export declare class PreloadMemoryTool extends BaseTool {
+    constructor();
+    runAsync({ args, toolContext, }: RunAsyncToolRequest): Promise<unknown>;
+    processLlmRequest(request: ToolProcessLlmRequest): Promise<void>;
+}
+/**
+ * A global instance of {@link PreloadMemoryTool}.
+ */
+export declare const PRELOAD_MEMORY: PreloadMemoryTool;

package/dist/types/version.d.ts

@@ -3,4 +3,4 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-export declare const version = "0.5.0";
+export declare const version = "0.6.0";