@nestjs-adk/core 0.0.1

package/dist/lib/abstracts/adk-agent.d.ts

@@ -0,0 +1,17 @@
+import type { AgentEvent, RunInput, RunResult } from "../types/events";
+export declare abstract class AdkAgent<TOutput = unknown> {
+    readonly __adkOutput?: TOutput;
+    private readonly adkRunner;
+    ask(input: RunInput): Promise<RunResult<TOutput>>;
+    stream(input: RunInput): AsyncGenerator<AgentEvent>;
+    approve(params: {
+        sessionId: string;
+        callId: string;
+        message?: string;
+    }): Promise<RunResult>;
+    reject(params: {
+        sessionId: string;
+        callId: string;
+        reason?: string;
+    }): Promise<RunResult>;
+}

package/dist/lib/abstracts/adk-engine.d.ts

@@ -0,0 +1,6 @@
+import type { AgentEvent, RunInput } from "../types/events";
+import type { ResolvedAgent } from "../types/resolved-agent";
+export declare abstract class AdkEngine {
+    abstract run(agent: ResolvedAgent, input: RunInput): AsyncIterable<AgentEvent>;
+    native(): unknown;
+}

package/dist/lib/abstracts/adk-skill.d.ts

@@ -0,0 +1,3 @@
+export declare abstract class AdkSkill {
+    abstract content(): string | Promise<string>;
+}

package/dist/lib/abstracts/adk-tool.d.ts

@@ -0,0 +1,6 @@
+import type { z } from "zod";
+import type { AnyZodObject } from "../types/options";
+import type { ToolContext } from "../types/tool-context";
+export declare abstract class AdkTool<S extends AnyZodObject = AnyZodObject> {
+    abstract execute(input: z.infer<S>, ctx?: ToolContext): unknown | Promise<unknown>;
+}

package/dist/lib/abstracts/adk-workflow.d.ts

@@ -0,0 +1,6 @@
+import type { AgentEvent, RunInput, RunResult } from "../types/events";
+export declare abstract class AdkWorkflow {
+    private readonly adkRunner;
+    ask(input: RunInput): Promise<RunResult>;
+    stream(input: RunInput): AsyncGenerator<AgentEvent>;
+}

package/dist/lib/abstracts/artifact-store.d.ts

@@ -0,0 +1,10 @@
+import type { ArtifactPart, ArtifactRef } from "../types/events";
+export declare abstract class ArtifactStore {
+    abstract save(ref: ArtifactRef, part: ArtifactPart): Promise<number>;
+    abstract load(ref: ArtifactRef, version?: number): Promise<ArtifactPart | null>;
+    abstract listKeys(scope: {
+        sessionId: string;
+    }): Promise<string[]>;
+    abstract listVersions(ref: ArtifactRef): Promise<number[]>;
+    abstract delete(ref: ArtifactRef): Promise<void>;
+}

package/dist/lib/abstracts/embedder.d.ts

@@ -0,0 +1,13 @@
+export interface EmbeddingUsage {
+    promptTokens: number;
+}
+export interface EmbeddingResult {
+    embeddings: number[][];
+    usage: EmbeddingUsage;
+}
+export declare abstract class Embedder {
+    private static active?;
+    static setActive(instance: Embedder | undefined): void;
+    static getActive(): Embedder;
+    abstract embed(texts: string[]): Promise<EmbeddingResult>;
+}

package/dist/lib/abstracts/memory-store.d.ts

@@ -0,0 +1,13 @@
+export declare abstract class MemoryStore {
+    abstract ingest(entry: {
+        sessionId: string;
+        content: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<void>;
+    abstract search(query: string, scope?: {
+        userId?: string;
+    }): Promise<Array<{
+        content: string;
+        score: number;
+    }>>;
+}

package/dist/lib/abstracts/session-store.d.ts

@@ -0,0 +1,8 @@
+import type { Session, SessionEvent, SessionInit } from "../types/events";
+export declare abstract class SessionStore {
+    abstract get(id: string): Promise<Session | null>;
+    abstract create(init: SessionInit): Promise<Session>;
+    abstract appendEvent(sessionId: string, event: SessionEvent): Promise<void>;
+    abstract updateState(sessionId: string, delta: Record<string, unknown>): Promise<void>;
+    abstract delete(id: string): Promise<void>;
+}

package/dist/lib/constants.d.ts

@@ -0,0 +1,8 @@
+export declare const AGENT_METADATA: unique symbol;
+export declare const TOOL_METADATA: unique symbol;
+export declare const SKILL_METADATA: unique symbol;
+export declare const WORKFLOW_METADATA: unique symbol;
+export declare const INLINE_TOOLS_METADATA: unique symbol;
+export declare const INLINE_SKILLS_METADATA: unique symbol;
+export declare const ADK_OPTIONS: unique symbol;
+export declare const ADK_RUNNER: unique symbol;

package/dist/lib/decorators/agent.decorator.d.ts

@@ -0,0 +1,2 @@
+import type { AgentOptions } from "../types/options";
+export declare function Agent(options: AgentOptions): ClassDecorator;

package/dist/lib/decorators/skill.decorator.d.ts

@@ -0,0 +1,6 @@
+import type { SkillOptions } from "../types/options";
+export interface InlineSkillMetadata {
+    method: string;
+    options: Required<Pick<SkillOptions, "name" | "description" | "mode">>;
+}
+export declare function Skill(options: SkillOptions): (target: object, propertyKey?: string | symbol) => void;

package/dist/lib/decorators/tool.decorator.d.ts

@@ -0,0 +1,6 @@
+import type { AnyZodObject, ToolOptions } from "../types/options";
+export interface InlineToolMetadata {
+    method: string;
+    options: ToolOptions;
+}
+export declare function Tool<S extends AnyZodObject>(options: ToolOptions<S>): (target: object, propertyKey?: string | symbol) => void;

package/dist/lib/decorators/workflow-agent.decorator.d.ts

@@ -0,0 +1,2 @@
+import type { WorkflowOptions } from "../types/options";
+export declare function WorkflowAgent(options: WorkflowOptions): ClassDecorator;

package/dist/lib/embeddings/similarity.d.ts

@@ -0,0 +1,3 @@
+export declare class Similarity {
+    cosine(a: number[], b: number[]): number;
+}

package/dist/lib/errors/adk.error.d.ts

@@ -0,0 +1,4 @@
+export declare abstract class AdkError extends Error {
+    abstract readonly code: string;
+    constructor(message: string, options?: ErrorOptions);
+}

package/dist/lib/errors/boot.errors.d.ts

@@ -0,0 +1,43 @@
+import { AdkError } from "./adk.error";
+export declare abstract class AdkBootError extends AdkError {
+}
+export declare class DuplicateAgentNameError extends AdkBootError {
+    readonly code = "DUPLICATE_AGENT_NAME";
+    constructor(name: string, classes: [string, string]);
+}
+export declare class ReservedMethodError extends AdkBootError {
+    readonly code = "RESERVED_METHOD";
+    constructor(agentClass: string, method: string);
+}
+export declare class UnregisteredToolError extends AdkBootError {
+    readonly code = "UNREGISTERED_TOOL";
+    constructor(agentClass: string, toolClass: string);
+}
+export declare class UnregisteredSkillError extends AdkBootError {
+    readonly code = "UNREGISTERED_SKILL";
+    constructor(agentClass: string, skillClass: string);
+}
+export declare class UnregisteredSubAgentError extends AdkBootError {
+    readonly code = "UNREGISTERED_SUB_AGENT";
+    constructor(agentClass: string, subAgentClass: string);
+}
+export declare class MissingModelError extends AdkBootError {
+    readonly code = "MISSING_MODEL";
+    constructor(agentClass: string);
+}
+export declare class InvalidWorkflowError extends AdkBootError {
+    readonly code = "INVALID_WORKFLOW";
+    constructor(workflowClass: string, reason: string);
+}
+export declare class ConflictingPromptError extends AdkBootError {
+    readonly code = "CONFLICTING_PROMPT";
+    constructor(agentClass: string);
+}
+export declare class UnregisteredPromptError extends AdkBootError {
+    readonly code = "UNREGISTERED_PROMPT";
+    constructor(agentClass: string, promptClass: string);
+}
+export declare class UnresolvedToolsetError extends AdkBootError {
+    readonly code = "UNRESOLVED_TOOLSET";
+    constructor(agentClass: string, toolsetName: string);
+}

package/dist/lib/errors/index.d.ts

@@ -0,0 +1,3 @@
+export { AdkError } from "./adk.error";
+export { AdkBootError, DuplicateAgentNameError, ConflictingPromptError, InvalidWorkflowError, MissingModelError, ReservedMethodError, UnregisteredPromptError, UnregisteredSkillError, UnregisteredSubAgentError, UnregisteredToolError, UnresolvedToolsetError, } from "./boot.errors";
+export { AgentNotFoundError, ApprovalNotFoundError, EmbedderNotConfiguredError, AiEmptyResponseError, McpConnectionError, ModelsExhaustedError, OutputValidationError, SessionNotFoundError, SkillNotFoundError, ToolExecutionError, } from "./runtime.errors";

package/dist/lib/errors/runtime.errors.d.ts

@@ -0,0 +1,51 @@
+import { AdkError } from "./adk.error";
+export declare class AiEmptyResponseError extends AdkError {
+    readonly code = "AI_EMPTY_RESPONSE";
+    constructor(agent: string);
+}
+export declare class ToolExecutionError extends AdkError {
+    readonly tool: string;
+    readonly code = "TOOL_EXECUTION_FAILED";
+    constructor(tool: string, cause: unknown);
+}
+export declare class ModelsExhaustedError extends AdkError {
+    readonly failures: Array<{
+        target: string;
+        error: unknown;
+    }>;
+    readonly code = "MODELS_EXHAUSTED";
+    constructor(failures: Array<{
+        target: string;
+        error: unknown;
+    }>);
+}
+export declare class SessionNotFoundError extends AdkError {
+    readonly code = "SESSION_NOT_FOUND";
+    constructor(sessionId: string);
+}
+export declare class EmbedderNotConfiguredError extends AdkError {
+    readonly code = "EMBEDDER_NOT_CONFIGURED";
+    constructor();
+}
+export declare class AgentNotFoundError extends AdkError {
+    readonly code = "AGENT_NOT_FOUND";
+    constructor(agent: string);
+}
+export declare class SkillNotFoundError extends AdkError {
+    readonly code = "SKILL_NOT_FOUND";
+    constructor(skill: string, agent: string);
+}
+export declare class OutputValidationError extends AdkError {
+    readonly rawOutput: unknown;
+    readonly issues: unknown;
+    readonly code = "OUTPUT_VALIDATION_FAILED";
+    constructor(agent: string, rawOutput: unknown, issues: unknown);
+}
+export declare class McpConnectionError extends AdkError {
+    readonly code = "MCP_CONNECTION_FAILED";
+    constructor(server: string, cause: unknown);
+}
+export declare class ApprovalNotFoundError extends AdkError {
+    readonly code = "APPROVAL_NOT_FOUND";
+    constructor(callId: string, sessionId: string);
+}

package/dist/lib/models/context-policy.d.ts

@@ -0,0 +1,16 @@
+import type { ModelInput } from "../types/options";
+export interface CompactionPolicy {
+    maxTokens: number;
+    targetTokens?: number;
+    keepRecent?: number;
+    summarizer?: ModelInput;
+}
+export interface ContextPolicy {
+    readonly __adkContextPolicy: true;
+    compaction?: CompactionPolicy;
+    offload?: {
+        threshold?: number;
+    } | false;
+}
+export declare function contextPolicy(options: Omit<ContextPolicy, "__adkContextPolicy">): ContextPolicy;
+export declare const DEFAULT_OFFLOAD_THRESHOLD = 20000;

package/dist/lib/models/model-specs.d.ts

@@ -0,0 +1,48 @@
+export interface GeminiOptions {
+    apiKey?: string;
+    vertexai?: boolean;
+    project?: string;
+    location?: string;
+    labels?: Record<string, string>;
+    cache?: {
+        content: string;
+    };
+    config?: Record<string, unknown>;
+}
+export declare class Gemini implements GeminiOptions {
+    readonly model: string;
+    readonly __adkModelSpec: "gemini";
+    readonly apiKey?: string;
+    readonly vertexai?: boolean;
+    readonly project?: string;
+    readonly location?: string;
+    readonly labels?: Record<string, string>;
+    readonly cache?: {
+        content: string;
+    };
+    readonly config?: Record<string, unknown>;
+    constructor(model: string, options?: GeminiOptions);
+}
+export interface OpenAiLikeOptions {
+    baseUrl?: string;
+    apiKeyEnv?: string;
+}
+export declare class OpenAiLike implements OpenAiLikeOptions {
+    readonly model: string;
+    readonly __adkModelSpec: "openai-like";
+    readonly baseUrl?: string;
+    readonly apiKeyEnv?: string;
+    constructor(model: string, options?: OpenAiLikeOptions);
+}
+export type RouterTarget = string | Gemini | OpenAiLike | object;
+export declare class ModelRouter {
+    readonly __adkModelSpec: "router";
+    readonly targets: Record<string, RouterTarget>;
+    readonly strategy: "failover";
+    constructor(options: {
+        targets: Record<string, RouterTarget> | RouterTarget[];
+        strategy?: "failover";
+    });
+}
+export type ModelSpec = Gemini | OpenAiLike | ModelRouter;
+export declare function isModelSpec(model: unknown): model is ModelSpec;

package/dist/lib/module/adk-options.d.ts

@@ -0,0 +1,24 @@
+import type { InjectionToken, ModuleMetadata, Type } from "@nestjs/common";
+import type { AdkEngine } from "../abstracts/adk-engine";
+import type { ArtifactStore } from "../abstracts/artifact-store";
+import type { MemoryStore } from "../abstracts/memory-store";
+import type { SessionStore } from "../abstracts/session-store";
+import type { ModelInput } from "../types/options";
+export interface AdkModuleOptions {
+    engine: Type<AdkEngine>;
+    defaultModel?: ModelInput;
+    session?: Type<SessionStore>;
+    memory?: Type<MemoryStore>;
+    artifacts?: Type<ArtifactStore>;
+    embedder?: Type<import("../abstracts/embedder").Embedder>;
+    prompts?: {
+        dir?: string;
+    };
+    logging?: import("../runner/run-logger").LoggingOption;
+    context?: import("../models/context-policy").ContextPolicy;
+}
+export interface AdkModuleAsyncOptions extends Pick<ModuleMetadata, "imports"> {
+    engine: Type<AdkEngine>;
+    useFactory: (...args: never[]) => Omit<AdkModuleOptions, "engine"> | Promise<Omit<AdkModuleOptions, "engine">>;
+    inject?: InjectionToken[];
+}

package/dist/lib/module/adk.module.d.ts

@@ -0,0 +1,8 @@
+import { type DynamicModule } from "@nestjs/common";
+import type { AdkModuleAsyncOptions, AdkModuleOptions } from "./adk-options";
+export declare class AdkModule {
+    static forRoot(options: AdkModuleOptions): DynamicModule;
+    static forRootAsync(options: AdkModuleAsyncOptions): DynamicModule;
+    private static assemble;
+}
+export type { AdkModuleAsyncOptions, AdkModuleOptions } from "./adk-options";

package/dist/lib/prompts/adk-prompt.d.ts

@@ -0,0 +1,8 @@
+import type { ToolContext } from "../types/tool-context";
+export type PromptContext = ToolContext;
+export declare abstract class AdkPrompt {
+    private readonly adkOptions?;
+    private readonly files;
+    abstract build(ctx: PromptContext): string | Promise<string>;
+    protected fromFile(path: string, vars?: Record<string, unknown>): Promise<string>;
+}

package/dist/lib/prompts/prompt-files.d.ts

@@ -0,0 +1,11 @@
+export declare class PromptFiles {
+    private static readonly cache;
+    resolvePath(path: string, promptsDir?: string, callerDir?: string): string;
+    render(path: string, options?: {
+        promptsDir?: string;
+        callerDir?: string;
+        vars?: Record<string, unknown>;
+    }): Promise<string>;
+    interpolate(template: string, vars: Record<string, unknown>): string;
+    callerDir(): string | undefined;
+}

package/dist/lib/registry/agent-definition.d.ts

@@ -0,0 +1,44 @@
+import type { Type } from "@nestjs/common";
+import type { AdkSkill } from "../abstracts/adk-skill";
+import type { AdkTool } from "../abstracts/adk-tool";
+import type { AdkPrompt } from "../prompts/adk-prompt";
+import type { AgentOptions, ModelInput, SkillOptions, ToolOptions, WorkflowOptions } from "../types/options";
+export type ToolBinding = {
+    kind: "class";
+    type: Type<AdkTool>;
+    instance: AdkTool;
+    options: ToolOptions;
+} | {
+    kind: "inline";
+    method: string;
+    options: ToolOptions;
+};
+export type SkillBinding = {
+    kind: "class";
+    type: Type<AdkSkill>;
+    instance: AdkSkill;
+    options: Required<SkillOptions>;
+} | {
+    kind: "inline";
+    method: string;
+    options: Required<SkillOptions>;
+};
+export declare class AgentDefinition {
+    readonly name: string;
+    readonly type: Type;
+    readonly instance: object;
+    readonly options: AgentOptions | undefined;
+    readonly model: ModelInput | undefined;
+    readonly tools: ToolBinding[];
+    readonly skills: SkillBinding[];
+    readonly subAgents: Type[];
+    readonly promptText: string | undefined;
+    readonly promptFile: string | undefined;
+    readonly promptInstance: AdkPrompt | undefined;
+    readonly workflow: WorkflowOptions | undefined;
+    readonly output?: import("../types/options").AnyZodObject | undefined;
+    readonly outputKey?: string | undefined;
+    readonly toolsets: import("../types/toolset").ToolsetRef[];
+    constructor(name: string, type: Type, instance: object, options: AgentOptions | undefined, model: ModelInput | undefined, tools: ToolBinding[], skills: SkillBinding[], subAgents: Type[], promptText: string | undefined, promptFile: string | undefined, promptInstance: AdkPrompt | undefined, workflow: WorkflowOptions | undefined, output?: import("../types/options").AnyZodObject | undefined, outputKey?: string | undefined, toolsets?: import("../types/toolset").ToolsetRef[]);
+    get description(): string;
+}

package/dist/lib/registry/agent-ref.d.ts

@@ -0,0 +1,26 @@
+import type { Type } from "@nestjs/common";
+import type { AgentRunner } from "../runner/agent-runner";
+import type { AgentEvent, RunInput, RunResult } from "../types/events";
+import type { AgentDefinition } from "./agent-definition";
+import type { AgentRegistry } from "./agent-registry";
+export declare class AgentRef<TAgent = unknown> {
+    private readonly registry;
+    private readonly agentType;
+    private readonly getRunner;
+    readonly __adkAgent?: TAgent;
+    constructor(registry: AgentRegistry, agentType: Type, getRunner: () => AgentRunner);
+    get name(): string;
+    get definition(): AgentDefinition;
+    ask(input: RunInput): Promise<RunResult>;
+    stream(input: RunInput): AsyncGenerator<AgentEvent>;
+    approve(params: {
+        sessionId: string;
+        callId: string;
+        message?: string;
+    }): Promise<RunResult>;
+    reject(params: {
+        sessionId: string;
+        callId: string;
+        reason?: string;
+    }): Promise<RunResult>;
+}

package/dist/lib/registry/agent-registry.d.ts

@@ -0,0 +1,28 @@
+import { type OnApplicationBootstrap, type Type } from "@nestjs/common";
+import { DiscoveryService, ModuleRef } from "@nestjs/core";
+import type { AdkModuleOptions } from "../module/adk-options";
+import type { ModelInput } from "../types/options";
+import { AgentDefinition } from "./agent-definition";
+import { AgentRef } from "./agent-ref";
+export declare class AgentRegistry implements OnApplicationBootstrap {
+    private readonly discovery;
+    private readonly moduleRef;
+    private readonly options;
+    private readonly byName;
+    private readonly byType;
+    private readonly refs;
+    private readonly modelOverrides;
+    private built;
+    constructor(discovery: DiscoveryService, moduleRef: ModuleRef, options: AdkModuleOptions);
+    onApplicationBootstrap(): void;
+    list(): AgentDefinition[];
+    get(name: string): AgentDefinition;
+    getByType(type: Type): AgentDefinition;
+    overrideModel(type: Type, model: ModelInput): void;
+    modelFor(definition: AgentDefinition): ModelInput | undefined;
+    getRef(type: Type): AgentRef;
+    private ensureBuilt;
+    private build;
+    private createDefinition;
+    private hasToolsetResolver;
+}

package/dist/lib/runner/agent-runner.d.ts

@@ -0,0 +1,44 @@
+import { type Type } from "@nestjs/common";
+import { AdkEngine } from "../abstracts/adk-engine";
+import { ArtifactStore } from "../abstracts/artifact-store";
+import { SessionStore } from "../abstracts/session-store";
+import type { AdkModuleOptions } from "../module/adk-options";
+import { AgentRegistry } from "../registry/agent-registry";
+import type { AgentEvent, RunInput, RunResult } from "../types/events";
+import type { ResolvedAgent } from "../types/resolved-agent";
+import { ToolsetResolver } from "../types/toolset";
+export declare class AgentRunner {
+    private readonly engine;
+    private readonly registry;
+    private readonly store;
+    private readonly artifacts;
+    private readonly options;
+    private readonly toolsets?;
+    constructor(engine: AdkEngine, registry: AgentRegistry, store: SessionStore, artifacts: ArtifactStore, options: AdkModuleOptions, toolsets?: ToolsetResolver | undefined);
+    run(agentType: Type | string, input: RunInput): AsyncGenerator<AgentEvent>;
+    ask<TOutput = unknown>(agentType: Type | string, input: RunInput): Promise<RunResult<TOutput>>;
+    approve(agentType: Type | string, params: {
+        sessionId: string;
+        callId: string;
+        message?: string;
+    }): Promise<RunResult>;
+    reject(agentType: Type | string, params: {
+        sessionId: string;
+        callId: string;
+        reason?: string;
+    }): Promise<RunResult>;
+    resolve(agentType: Type | string, input?: RunInput): Promise<ResolvedAgent>;
+    private definitionOf;
+    private openSession;
+    private takePending;
+    private createToolContext;
+    private policyOf;
+    private resolveAgent;
+    private needsApproval;
+    private executeBinding;
+    private maybeOffload;
+    private createReadArtifactTool;
+    private createLoadSkillTool;
+    private persistAgentEvent;
+    private persist;
+}

package/dist/lib/runner/instruction-builder.d.ts

@@ -0,0 +1,7 @@
+import type { AgentDefinition, SkillBinding } from "../registry/agent-definition";
+import type { ToolContext } from "../types/tool-context";
+export interface InstructionOptions {
+    promptsDir?: string;
+}
+export declare function skillContent(definition: AgentDefinition, binding: SkillBinding): Promise<string>;
+export declare function buildInstruction(definition: AgentDefinition, options?: InstructionOptions, ctx?: ToolContext): Promise<string | undefined>;

package/dist/lib/runner/run-logger.d.ts

@@ -0,0 +1,13 @@
+import type { AgentEvent, RunInput } from "../types/events";
+export type LoggingOption = boolean | "info" | "debug" | "verbose" | undefined;
+export declare class RunLogger {
+    private readonly level;
+    static create(option: LoggingOption, agentName: string): RunLogger | undefined;
+    private readonly logger;
+    private readonly startedAt;
+    private constructor();
+    start(input: RunInput): void;
+    event(event: AgentEvent): void;
+    private enabled;
+    private preview;
+}

package/dist/lib/runner/state-bag.d.ts

@@ -0,0 +1,9 @@
+import type { StateBag } from "../types/tool-context";
+export declare class DeltaStateBag implements StateBag {
+    private readonly initial;
+    private readonly changes;
+    constructor(initial: Record<string, unknown>);
+    get<T = unknown>(key: string): T | undefined;
+    set(key: string, value: unknown): void;
+    delta(): Record<string, unknown>;
+}

package/dist/lib/sessions/agent-sessions.d.ts

@@ -0,0 +1,15 @@
+import { SessionStore } from "../abstracts/session-store";
+import type { Session, SessionEvent, SessionInit } from "../types/events";
+export interface AppendSliceInput {
+    type: string;
+    data: Record<string, unknown>;
+    author?: SessionEvent["author"];
+}
+export declare class AgentSessions {
+    private readonly store;
+    constructor(store: SessionStore);
+    get(id: string): Promise<Session | null>;
+    create(init?: SessionInit): Promise<Session>;
+    append(sessionId: string, input: AppendSliceInput): Promise<SessionEvent>;
+    delete(id: string): Promise<void>;
+}

package/dist/lib/stores/in-memory-artifact-store.d.ts

@@ -0,0 +1,12 @@
+import { ArtifactStore } from "../abstracts/artifact-store";
+import type { ArtifactPart, ArtifactRef } from "../types/events";
+export declare class InMemoryArtifactStore extends ArtifactStore {
+    private readonly artifacts;
+    save(ref: ArtifactRef, part: ArtifactPart): Promise<number>;
+    load(ref: ArtifactRef, version?: number): Promise<ArtifactPart | null>;
+    listKeys(scope: {
+        sessionId: string;
+    }): Promise<string[]>;
+    listVersions(ref: ArtifactRef): Promise<number[]>;
+    delete(ref: ArtifactRef): Promise<void>;
+}

package/dist/lib/stores/in-memory-session-store.d.ts

@@ -0,0 +1,11 @@
+import { SessionStore } from "../abstracts/session-store";
+import type { Session, SessionEvent, SessionInit } from "../types/events";
+export declare class InMemorySessionStore extends SessionStore {
+    private readonly sessions;
+    get(id: string): Promise<Session | null>;
+    create(init: SessionInit): Promise<Session>;
+    appendEvent(sessionId: string, event: SessionEvent): Promise<void>;
+    updateState(sessionId: string, delta: Record<string, unknown>): Promise<void>;
+    delete(id: string): Promise<void>;
+    private require;
+}

package/dist/lib/testing/scripted-engine.d.ts

@@ -0,0 +1,27 @@
+import { AdkEngine } from "../abstracts/adk-engine";
+import type { AgentEvent, RunInput, TokenUsage } from "../types/events";
+import type { ResolvedAgent } from "../types/resolved-agent";
+export type ScriptTurn = {
+    kind: "tool_call";
+    tool: string;
+    args: unknown;
+} | {
+    kind: "text";
+    text: string;
+    usage: TokenUsage;
+} | {
+    kind: "fail";
+    message: string;
+};
+export declare function callTool(tool: string, args: unknown): ScriptTurn;
+export declare function fail(message: string): ScriptTurn;
+export declare function text(value: string, usage?: Partial<TokenUsage>): ScriptTurn;
+export declare class ScriptedEngine extends AdkEngine {
+    private readonly scripts;
+    private readonly draft;
+    lastAgent?: ResolvedAgent;
+    lastInput?: RunInput;
+    enqueue(turns: ScriptTurn[]): void;
+    push(turn: ScriptTurn): void;
+    run(agent: ResolvedAgent, input: RunInput): AsyncGenerator<AgentEvent>;
+}

package/dist/lib/testing/scripted-model.d.ts

@@ -0,0 +1,8 @@
+import type { ScriptTurn } from "./scripted-engine";
+export declare class ScriptedModel {
+    readonly __adkScriptedModel = true;
+    readonly scripts: ScriptTurn[][];
+    constructor(...scripts: ScriptTurn[][]);
+    enqueue(turns: ScriptTurn[]): this;
+}
+export declare function isScriptedModel(model: unknown): model is ScriptedModel;