@nestjs-adk/core 0.0.1

package/dist/index.cjs

@@ -0,0 +1,1452 @@
+'use strict';
+
+var common = require('@nestjs/common');
+var node_crypto = require('node:crypto');
+var node_path = require('node:path');
+var promises = require('node:fs/promises');
+var core = require('@nestjs/core');
+var zod = require('zod');
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+function __decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+
+function __param(paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+}
+
+function __metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+const AGENT_METADATA = Symbol("adk:agent");
+const TOOL_METADATA = Symbol("adk:tool");
+const SKILL_METADATA = Symbol("adk:skill");
+const WORKFLOW_METADATA = Symbol("adk:workflow");
+const INLINE_TOOLS_METADATA = Symbol("adk:inline-tools");
+const INLINE_SKILLS_METADATA = Symbol("adk:inline-skills");
+const ADK_OPTIONS = Symbol("adk:options");
+const ADK_RUNNER = Symbol("adk:runner");
+
+class AdkAgent {
+    ask(input) {
+        return this.adkRunner.ask(this.constructor, input);
+    }
+    stream(input) {
+        return this.adkRunner.run(this.constructor, input);
+    }
+    approve(params) {
+        return this.adkRunner.approve(this.constructor, params);
+    }
+    reject(params) {
+        return this.adkRunner.reject(this.constructor, params);
+    }
+}
+__decorate([
+    common.Inject(ADK_RUNNER),
+    __metadata("design:type", Function)
+], AdkAgent.prototype, "adkRunner", void 0);
+
+class AdkEngine {
+    native() {
+        return undefined;
+    }
+}
+
+class AdkSkill {
+}
+
+class AdkTool {
+}
+
+class AdkWorkflow {
+    ask(input) {
+        return this.adkRunner.ask(this.constructor, input);
+    }
+    stream(input) {
+        return this.adkRunner.run(this.constructor, input);
+    }
+}
+__decorate([
+    common.Inject(ADK_RUNNER),
+    __metadata("design:type", Function)
+], AdkWorkflow.prototype, "adkRunner", void 0);
+
+class ArtifactStore {
+}
+
+class AdkError extends Error {
+    constructor(message, options) {
+        super(message, options);
+        this.name = new.target.name;
+    }
+}
+
+class AiEmptyResponseError extends AdkError {
+    constructor(agent) {
+        super(`Agent "${agent}" finished the run with an empty final response.`);
+        this.code = "AI_EMPTY_RESPONSE";
+    }
+}
+class ToolExecutionError extends AdkError {
+    constructor(tool, cause) {
+        super(`Tool "${tool}" threw during execution.`, { cause });
+        this.tool = tool;
+        this.code = "TOOL_EXECUTION_FAILED";
+    }
+}
+class ModelsExhaustedError extends AdkError {
+    constructor(failures) {
+        super(`Model router exhausted all targets (${failures.map((f) => f.target).join(", ")}).`);
+        this.failures = failures;
+        this.code = "MODELS_EXHAUSTED";
+    }
+}
+class SessionNotFoundError extends AdkError {
+    constructor(sessionId) {
+        super(`Session "${sessionId}" was not found.`);
+        this.code = "SESSION_NOT_FOUND";
+    }
+}
+class EmbedderNotConfiguredError extends AdkError {
+    constructor() {
+        super("No Embedder configured. Set AdkModule.forRoot({ embedder: YourEmbedder }) — the lib ships no default.");
+        this.code = "EMBEDDER_NOT_CONFIGURED";
+    }
+}
+class AgentNotFoundError extends AdkError {
+    constructor(agent) {
+        super(`Agent "${agent}" is not registered.`);
+        this.code = "AGENT_NOT_FOUND";
+    }
+}
+class SkillNotFoundError extends AdkError {
+    constructor(skill, agent) {
+        super(`Skill "${skill}" requested via load_skill does not exist on agent "${agent}".`);
+        this.code = "SKILL_NOT_FOUND";
+    }
+}
+class OutputValidationError extends AdkError {
+    constructor(agent, rawOutput, issues) {
+        super(`Agent "${agent}" returned output that does not match its declared schema.`);
+        this.rawOutput = rawOutput;
+        this.issues = issues;
+        this.code = "OUTPUT_VALIDATION_FAILED";
+    }
+}
+class McpConnectionError extends AdkError {
+    constructor(server, cause) {
+        super(`MCP server "${server}" connection failed.`, { cause });
+        this.code = "MCP_CONNECTION_FAILED";
+    }
+}
+class ApprovalNotFoundError extends AdkError {
+    constructor(callId, sessionId) {
+        super(`Pending approval "${callId}" was not found in session "${sessionId}".`);
+        this.code = "APPROVAL_NOT_FOUND";
+    }
+}
+
+class Embedder {
+    static setActive(instance) {
+        Embedder.active = instance;
+    }
+    static getActive() {
+        if (!Embedder.active)
+            throw new EmbedderNotConfiguredError();
+        return Embedder.active;
+    }
+}
+
+exports.Similarity = class Similarity {
+    cosine(a, b) {
+        if (a.length !== b.length || a.length === 0) {
+            throw new Error(`Similarity.cosine: vectors must have the same non-zero length (got ${a.length} and ${b.length}).`);
+        }
+        let dot = 0;
+        let normA = 0;
+        let normB = 0;
+        for (let i = 0; i < a.length; i++) {
+            const x = a[i];
+            const y = b[i];
+            dot += x * y;
+            normA += x * x;
+            normB += y * y;
+        }
+        if (normA === 0 || normB === 0)
+            return 0;
+        return dot / (Math.sqrt(normA) * Math.sqrt(normB));
+    }
+};
+exports.Similarity = __decorate([
+    common.Injectable()
+], exports.Similarity);
+
+class MemoryStore {
+}
+
+class SessionStore {
+}
+
+exports.InMemoryArtifactStore = class InMemoryArtifactStore extends ArtifactStore {
+    constructor() {
+        super(...arguments);
+        this.artifacts = new Map();
+    }
+    async save(ref, part) {
+        let session = this.artifacts.get(ref.sessionId);
+        if (!session) {
+            session = new Map();
+            this.artifacts.set(ref.sessionId, session);
+        }
+        let versions = session.get(ref.name);
+        if (!versions) {
+            versions = [];
+            session.set(ref.name, versions);
+        }
+        versions.push(structuredClone(part));
+        return versions.length - 1;
+    }
+    async load(ref, version) {
+        const versions = this.artifacts.get(ref.sessionId)?.get(ref.name);
+        if (!versions?.length)
+            return null;
+        const part = versions[version ?? versions.length - 1];
+        return part ? structuredClone(part) : null;
+    }
+    async listKeys(scope) {
+        return [...(this.artifacts.get(scope.sessionId)?.keys() ?? [])];
+    }
+    async listVersions(ref) {
+        const versions = this.artifacts.get(ref.sessionId)?.get(ref.name) ?? [];
+        return versions.map((_, index) => index);
+    }
+    async delete(ref) {
+        this.artifacts.get(ref.sessionId)?.delete(ref.name);
+    }
+};
+exports.InMemoryArtifactStore = __decorate([
+    common.Injectable()
+], exports.InMemoryArtifactStore);
+
+exports.InMemorySessionStore = class InMemorySessionStore extends SessionStore {
+    constructor() {
+        super(...arguments);
+        this.sessions = new Map();
+    }
+    async get(id) {
+        const session = this.sessions.get(id);
+        return session ? structuredClone(session) : null;
+    }
+    async create(init) {
+        const now = new Date();
+        const session = {
+            id: init.id ?? node_crypto.randomUUID(),
+            userId: init.userId,
+            state: structuredClone(init.state ?? {}),
+            events: [],
+            createdAt: now,
+            updatedAt: now,
+        };
+        this.sessions.set(session.id, session);
+        return structuredClone(session);
+    }
+    async appendEvent(sessionId, event) {
+        const session = this.require(sessionId);
+        session.events.push(structuredClone(event));
+        session.updatedAt = new Date();
+    }
+    async updateState(sessionId, delta) {
+        const session = this.require(sessionId);
+        session.state = { ...session.state, ...structuredClone(delta) };
+        session.updatedAt = new Date();
+    }
+    async delete(id) {
+        this.sessions.delete(id);
+    }
+    require(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session)
+            throw new SessionNotFoundError(sessionId);
+        return session;
+    }
+};
+exports.InMemorySessionStore = __decorate([
+    common.Injectable()
+], exports.InMemorySessionStore);
+
+exports.AgentSessions = class AgentSessions {
+    constructor(store) {
+        this.store = store;
+    }
+    get(id) {
+        return this.store.get(id);
+    }
+    create(init = {}) {
+        return this.store.create(init);
+    }
+    async append(sessionId, input) {
+        const session = await this.store.get(sessionId);
+        if (!session)
+            throw new SessionNotFoundError(sessionId);
+        const event = {
+            v: 1,
+            id: node_crypto.randomUUID(),
+            at: Date.now(),
+            author: input.author ?? "system",
+            type: input.type,
+            data: input.data,
+        };
+        await this.store.appendEvent(sessionId, event);
+        return event;
+    }
+    delete(id) {
+        return this.store.delete(id);
+    }
+};
+exports.AgentSessions = __decorate([
+    common.Injectable(),
+    __metadata("design:paramtypes", [SessionStore])
+], exports.AgentSessions);
+
+var PromptFiles_1;
+const DEFAULT_PROMPTS_DIR = "./prompts";
+const LIB_FRAMES = ["prompt-files", "adk-prompt", "agent.decorator"];
+exports.PromptFiles = class PromptFiles {
+    static { PromptFiles_1 = this; }
+    static { this.cache = new Map(); }
+    resolvePath(path, promptsDir, callerDir) {
+        if (node_path.isAbsolute(path))
+            return path;
+        if ((path.startsWith("./") || path.startsWith("../")) && callerDir)
+            return node_path.resolve(callerDir, path);
+        return node_path.join(promptsDir ?? DEFAULT_PROMPTS_DIR, path);
+    }
+    async render(path, options = {}) {
+        const absolute = this.resolvePath(path, options.promptsDir, options.callerDir);
+        let template = PromptFiles_1.cache.get(absolute);
+        if (template === undefined) {
+            template = await promises.readFile(absolute, "utf8");
+            PromptFiles_1.cache.set(absolute, template);
+        }
+        return options.vars ? this.interpolate(template, options.vars) : template;
+    }
+    interpolate(template, vars) {
+        return template.replace(/\{\{(\w+)\}\}/g, (_, key) => String(vars[key] ?? ""));
+    }
+    callerDir() {
+        const frames = new Error().stack?.split("\n") ?? [];
+        for (const frame of frames) {
+            const match = frame.match(/\(?([^() ]+?):\d+:\d+\)?$/);
+            const file = match?.[1];
+            if (!file || file.startsWith("node:") || file.includes("node_modules") || file.includes("\0"))
+                continue;
+            if (LIB_FRAMES.some((name) => file.includes(name)))
+                continue;
+            return node_path.dirname(file);
+        }
+        return undefined;
+    }
+};
+exports.PromptFiles = PromptFiles_1 = __decorate([
+    common.Injectable()
+], exports.PromptFiles);
+
+function Agent(options) {
+    return (target) => {
+        let normalized = options;
+        if (options.promptFile?.startsWith("./") || options.promptFile?.startsWith("../")) {
+            const callerDir = new exports.PromptFiles().callerDir();
+            if (callerDir)
+                normalized = { ...options, promptFile: node_path.resolve(callerDir, options.promptFile) };
+        }
+        Reflect.defineMetadata(AGENT_METADATA, normalized, target);
+        common.Injectable()(target);
+    };
+}
+
+function Skill(options) {
+    const normalized = { ...options, mode: options.mode ?? "on-demand" };
+    return (target, propertyKey) => {
+        if (propertyKey !== undefined) {
+            const ctor = target.constructor;
+            const inline = Reflect.getOwnMetadata(INLINE_SKILLS_METADATA, ctor) ?? [];
+            inline.push({ method: String(propertyKey), options: normalized });
+            Reflect.defineMetadata(INLINE_SKILLS_METADATA, inline, ctor);
+            return;
+        }
+        Reflect.defineMetadata(SKILL_METADATA, normalized, target);
+        common.Injectable()(target);
+    };
+}
+
+function Tool(options) {
+    return (target, propertyKey) => {
+        if (propertyKey !== undefined) {
+            const ctor = target.constructor;
+            const inline = Reflect.getOwnMetadata(INLINE_TOOLS_METADATA, ctor) ?? [];
+            inline.push({
+                method: String(propertyKey),
+                options: { ...options, name: options.name ?? String(propertyKey) },
+            });
+            Reflect.defineMetadata(INLINE_TOOLS_METADATA, inline, ctor);
+            return;
+        }
+        Reflect.defineMetadata(TOOL_METADATA, options, target);
+        common.Injectable()(target);
+    };
+}
+
+function WorkflowAgent(options) {
+    return (target) => {
+        Reflect.defineMetadata(WORKFLOW_METADATA, options, target);
+        common.Injectable()(target);
+    };
+}
+
+class AdkPrompt {
+    constructor() {
+        this.files = new exports.PromptFiles();
+    }
+    fromFile(path, vars) {
+        const callerDir = path.startsWith("./") || path.startsWith("../") ? this.files.callerDir() : undefined;
+        return this.files.render(path, { promptsDir: this.adkOptions?.prompts?.dir, callerDir, vars });
+    }
+}
+__decorate([
+    common.Optional(),
+    common.Inject(ADK_OPTIONS),
+    __metadata("design:type", Object)
+], AdkPrompt.prototype, "adkOptions", void 0);
+
+class AdkBootError extends AdkError {
+}
+class DuplicateAgentNameError extends AdkBootError {
+    constructor(name, classes) {
+        super(`Agent name "${name}" is declared by both ${classes[0]} and ${classes[1]}. Agent names must be unique.`);
+        this.code = "DUPLICATE_AGENT_NAME";
+    }
+}
+class ReservedMethodError extends AdkBootError {
+    constructor(agentClass, method) {
+        super(`Agent ${agentClass} declares a method "${method}", which shadows the execution handle inherited from AdkAgent/AdkWorkflow (ask/stream/approve/reject). Rename the method.`);
+        this.code = "RESERVED_METHOD";
+    }
+}
+class UnregisteredToolError extends AdkBootError {
+    constructor(agentClass, toolClass) {
+        super(`Agent ${agentClass} references tool ${toolClass}, but it is not registered as a provider in any module. ` +
+            `Add ${toolClass} to a module's providers.`);
+        this.code = "UNREGISTERED_TOOL";
+    }
+}
+class UnregisteredSkillError extends AdkBootError {
+    constructor(agentClass, skillClass) {
+        super(`Agent ${agentClass} references skill ${skillClass}, but it is not registered as a provider in any module. ` +
+            `Add ${skillClass} to a module's providers.`);
+        this.code = "UNREGISTERED_SKILL";
+    }
+}
+class UnregisteredSubAgentError extends AdkBootError {
+    constructor(agentClass, subAgentClass) {
+        super(`Agent ${agentClass} references sub-agent ${subAgentClass}, but it is not registered as a provider in any module.`);
+        this.code = "UNREGISTERED_SUB_AGENT";
+    }
+}
+class MissingModelError extends AdkBootError {
+    constructor(agentClass) {
+        super(`Agent ${agentClass} has no model and AdkModule.forRoot() has no defaultModel. Set @Agent({ model }) or forRoot({ defaultModel }).`);
+        this.code = "MISSING_MODEL";
+    }
+}
+class InvalidWorkflowError extends AdkBootError {
+    constructor(workflowClass, reason) {
+        super(`Workflow ${workflowClass} is invalid: ${reason}`);
+        this.code = "INVALID_WORKFLOW";
+    }
+}
+class ConflictingPromptError extends AdkBootError {
+    constructor(agentClass) {
+        super(`Agent ${agentClass} declares both "prompt" and "promptFile". Pick exactly one.`);
+        this.code = "CONFLICTING_PROMPT";
+    }
+}
+class UnregisteredPromptError extends AdkBootError {
+    constructor(agentClass, promptClass) {
+        super(`Agent ${agentClass} references prompt ${promptClass}, but it is not registered as a provider in any module. Add ${promptClass} to a module's providers.`);
+        this.code = "UNREGISTERED_PROMPT";
+    }
+}
+class UnresolvedToolsetError extends AdkBootError {
+    constructor(agentClass, toolsetName) {
+        super(`Agent ${agentClass} references toolset "${toolsetName}", but no ToolsetResolver is registered. Import a provider module (e.g. McpModule.forRoot from @nestjs-adk/mcp).`);
+        this.code = "UNRESOLVED_TOOLSET";
+    }
+}
+
+function toolset(name, filter) {
+    return { __adkToolset: name, filter };
+}
+function isToolsetRef(value) {
+    return typeof value === "object" && value !== null && "__adkToolset" in value;
+}
+class ToolsetResolver {
+}
+
+class AgentDefinition {
+    constructor(name, type, instance, options, model, tools, skills, subAgents, promptText, promptFile, promptInstance, workflow, output, outputKey, toolsets = []) {
+        this.name = name;
+        this.type = type;
+        this.instance = instance;
+        this.options = options;
+        this.model = model;
+        this.tools = tools;
+        this.skills = skills;
+        this.subAgents = subAgents;
+        this.promptText = promptText;
+        this.promptFile = promptFile;
+        this.promptInstance = promptInstance;
+        this.workflow = workflow;
+        this.output = output;
+        this.outputKey = outputKey;
+        this.toolsets = toolsets;
+    }
+    get description() {
+        return this.options?.description ?? this.workflow?.description ?? "";
+    }
+}
+
+class AgentRef {
+    constructor(registry, agentType, getRunner) {
+        this.registry = registry;
+        this.agentType = agentType;
+        this.getRunner = getRunner;
+    }
+    get name() {
+        return this.definition.name;
+    }
+    get definition() {
+        return this.registry.getByType(this.agentType);
+    }
+    ask(input) {
+        return this.getRunner().ask(this.agentType, input);
+    }
+    stream(input) {
+        return this.getRunner().run(this.agentType, input);
+    }
+    approve(params) {
+        return this.getRunner().approve(this.agentType, params);
+    }
+    reject(params) {
+        return this.getRunner().reject(this.agentType, params);
+    }
+}
+
+exports.AgentRegistry = class AgentRegistry {
+    constructor(discovery, moduleRef, options) {
+        this.discovery = discovery;
+        this.moduleRef = moduleRef;
+        this.options = options;
+        this.byName = new Map();
+        this.byType = new Map();
+        this.refs = new Map();
+        this.modelOverrides = new Map();
+        this.built = false;
+    }
+    onApplicationBootstrap() {
+        this.build();
+    }
+    list() {
+        this.ensureBuilt();
+        return [...this.byName.values()];
+    }
+    get(name) {
+        this.ensureBuilt();
+        const definition = this.byName.get(name);
+        if (!definition)
+            throw new AgentNotFoundError(name);
+        return definition;
+    }
+    getByType(type) {
+        this.ensureBuilt();
+        const definition = this.byType.get(type);
+        if (!definition)
+            throw new AgentNotFoundError(type.name);
+        return definition;
+    }
+    overrideModel(type, model) {
+        this.modelOverrides.set(type, model);
+    }
+    modelFor(definition) {
+        return this.modelOverrides.get(definition.type) ?? definition.model;
+    }
+    getRef(type) {
+        let ref = this.refs.get(type);
+        if (!ref) {
+            ref = new AgentRef(this, type, () => this.moduleRef.get(ADK_RUNNER, { strict: false }));
+            this.refs.set(type, ref);
+        }
+        return ref;
+    }
+    ensureBuilt() {
+        if (!this.built)
+            this.build();
+    }
+    build() {
+        if (this.built)
+            return;
+        this.built = true;
+        const wrappers = this.discovery
+            .getProviders()
+            .filter((wrapper) => typeof wrapper.metatype === "function" && wrapper.instance);
+        const toolInstances = new Map();
+        const skillInstances = new Map();
+        const agentWrappers = [];
+        for (const wrapper of wrappers) {
+            const type = wrapper.metatype;
+            if (Reflect.getMetadata(TOOL_METADATA, type))
+                toolInstances.set(type, wrapper.instance);
+            if (Reflect.getMetadata(SKILL_METADATA, type))
+                skillInstances.set(type, wrapper.instance);
+            if (Reflect.getMetadata(AGENT_METADATA, type) || Reflect.getMetadata(WORKFLOW_METADATA, type)) {
+                agentWrappers.push({ type, instance: wrapper.instance });
+            }
+        }
+        const agentTypes = new Set(agentWrappers.map((w) => w.type));
+        for (const { type, instance } of agentWrappers) {
+            const definition = this.createDefinition(type, instance, toolInstances, skillInstances, agentTypes);
+            const existing = this.byName.get(definition.name);
+            if (existing)
+                throw new DuplicateAgentNameError(definition.name, [existing.type.name, type.name]);
+            this.byName.set(definition.name, definition);
+            this.byType.set(type, definition);
+        }
+    }
+    createDefinition(type, instance, toolInstances, skillInstances, agentTypes) {
+        const agentOptions = Reflect.getMetadata(AGENT_METADATA, type);
+        const workflow = Reflect.getMetadata(WORKFLOW_METADATA, type);
+        for (const reserved of ["ask", "stream", "approve", "reject"]) {
+            if (Object.getOwnPropertyNames(type.prototype).includes(reserved)) {
+                throw new ReservedMethodError(type.name, reserved);
+            }
+        }
+        if (workflow) {
+            if (workflow.agents.length === 0)
+                throw new InvalidWorkflowError(type.name, "it has no agents");
+            for (const agent of workflow.agents) {
+                if (!agentTypes.has(agent)) {
+                    throw new InvalidWorkflowError(type.name, `agent ${agent.name} is not registered as a provider`);
+                }
+            }
+            return new AgentDefinition(workflow.name, type, instance, undefined, undefined, [], [], [], undefined, undefined, undefined, workflow);
+        }
+        const options = agentOptions;
+        const model = options.model ?? this.options.defaultModel;
+        if (model === undefined)
+            throw new MissingModelError(type.name);
+        const tools = [];
+        const toolsets = [];
+        for (const toolRef of options.tools ?? []) {
+            if (isToolsetRef(toolRef)) {
+                if (!this.hasToolsetResolver())
+                    throw new UnresolvedToolsetError(type.name, toolRef.__adkToolset);
+                toolsets.push(toolRef);
+                continue;
+            }
+            const toolInstance = toolInstances.get(toolRef);
+            if (!toolInstance)
+                throw new UnregisteredToolError(type.name, toolRef.name);
+            const toolOptions = Reflect.getMetadata(TOOL_METADATA, toolRef);
+            tools.push({ kind: "class", type: toolRef, instance: toolInstance, options: toolOptions });
+        }
+        const inlineTools = Reflect.getMetadata(INLINE_TOOLS_METADATA, type) ?? [];
+        for (const inline of inlineTools)
+            tools.push({ kind: "inline", method: inline.method, options: inline.options });
+        const skills = [];
+        for (const skillType of options.skills ?? []) {
+            const skillInstance = skillInstances.get(skillType);
+            if (!skillInstance)
+                throw new UnregisteredSkillError(type.name, skillType.name);
+            const skillOptions = Reflect.getMetadata(SKILL_METADATA, skillType);
+            skills.push({ kind: "class", type: skillType, instance: skillInstance, options: skillOptions });
+        }
+        const inlineSkills = Reflect.getMetadata(INLINE_SKILLS_METADATA, type) ?? [];
+        for (const inline of inlineSkills)
+            skills.push({ kind: "inline", method: inline.method, options: inline.options });
+        if (options.prompt !== undefined && options.promptFile !== undefined)
+            throw new ConflictingPromptError(type.name);
+        let promptText;
+        let promptInstance;
+        if (typeof options.prompt === "string") {
+            promptText = options.prompt;
+        }
+        else if (options.prompt) {
+            try {
+                promptInstance = this.moduleRef.get(options.prompt, { strict: false });
+            }
+            catch {
+                throw new UnregisteredPromptError(type.name, options.prompt.name);
+            }
+        }
+        const subAgents = [];
+        for (const subAgent of options.subAgents ?? []) {
+            if (!agentTypes.has(subAgent))
+                throw new UnregisteredSubAgentError(type.name, subAgent.name);
+            subAgents.push(subAgent);
+        }
+        return new AgentDefinition(options.name, type, instance, options, model, tools, skills, subAgents, promptText, options.promptFile, promptInstance, undefined, options.output, options.outputKey, toolsets);
+    }
+    hasToolsetResolver() {
+        try {
+            return Boolean(this.moduleRef.get(ToolsetResolver, { strict: false }));
+        }
+        catch {
+            return false;
+        }
+    }
+};
+exports.AgentRegistry = __decorate([
+    common.Injectable(),
+    __param(2, common.Inject(ADK_OPTIONS)),
+    __metadata("design:paramtypes", [core.DiscoveryService,
+        core.ModuleRef, Object])
+], exports.AgentRegistry);
+
+function contextPolicy(options) {
+    return { __adkContextPolicy: true, ...options };
+}
+const DEFAULT_OFFLOAD_THRESHOLD = 20_000;
+
+const promptFiles = new exports.PromptFiles();
+async function skillContent(definition, binding) {
+    if (binding.kind === "class")
+        return binding.instance.content();
+    const method = definition.instance[binding.method];
+    return (await method?.call(definition.instance)) ?? "";
+}
+async function resolvePrompt(definition, options, ctx) {
+    if (definition.promptInstance)
+        return definition.promptInstance.build(ctx);
+    if (definition.promptText !== undefined)
+        return definition.promptText;
+    if (definition.promptFile)
+        return promptFiles.render(definition.promptFile, { promptsDir: options.promptsDir });
+    return undefined;
+}
+async function buildInstruction(definition, options = {}, ctx) {
+    const sections = [];
+    const prompt = await resolvePrompt(definition, options, ctx);
+    if (prompt)
+        sections.push(prompt);
+    const catalog = [];
+    for (const skill of definition.skills) {
+        if (skill.options.mode === "always") {
+            sections.push(`## Skill: ${skill.options.name}\n${await skillContent(definition, skill)}`);
+        }
+        else {
+            catalog.push(`- ${skill.options.name}: ${skill.options.description}`);
+        }
+    }
+    if (catalog.length > 0) {
+        sections.push(`## Available skills\nLook up a skill's content with the load_skill(name) tool.\n${catalog.join("\n")}`);
+    }
+    return sections.length > 0 ? sections.join("\n\n") : undefined;
+}
+
+const PREVIEW_LENGTH = 160;
+const LEVEL_WEIGHT = { info: 0, debug: 1, verbose: 2 };
+class RunLogger {
+    static create(option, agentName) {
+        if (!option)
+            return undefined;
+        return new RunLogger(agentName, option === true ? "info" : option);
+    }
+    constructor(agentName, level) {
+        this.level = level;
+        this.startedAt = Date.now();
+        this.logger = new common.Logger(`Adk:${agentName}`);
+    }
+    start(input) {
+        const session = input.sessionId ?? "ephemeral";
+        this.logger.log(`run start session=${session} user=${input.userId ?? "-"} message=${this.preview(input.message)}`);
+    }
+    event(event) {
+        switch (event.type) {
+            case "run_start":
+                return;
+            case "tool_call":
+                if (this.enabled("debug"))
+                    this.logger.debug(`tool call ${event.tool} args=${this.preview(json(event.args))}`);
+                return;
+            case "tool_result":
+                if (this.enabled("debug")) {
+                    this.logger.debug(`tool result ${event.tool} result=${this.preview(json(event.result))}`);
+                }
+                return;
+            case "llm_response":
+                if (this.enabled("verbose") && event.text) {
+                    this.logger.verbose(`llm response text=${this.preview(event.text)}${usageSuffix(event.usage)}`);
+                }
+                return;
+            case "model_rerouted":
+                this.logger.warn(`model rerouted from=${event.from} to=${event.to} reason=${event.reason}`);
+                return;
+            case "approval_required":
+                this.logger.warn(`approval required tool=${event.tool} callId=${event.callId} args=${this.preview(json(event.args))}`);
+                return;
+            case "final":
+                this.logger.log(`run done in ${Date.now() - this.startedAt}ms text=${this.preview(event.text)}${usageSuffix(event.usage)}`);
+                return;
+            default:
+                if (this.enabled("verbose"))
+                    this.logger.verbose(json(event));
+        }
+    }
+    enabled(level) {
+        return LEVEL_WEIGHT[level] <= LEVEL_WEIGHT[this.level];
+    }
+    preview(value) {
+        if (this.level === "verbose" || value.length <= PREVIEW_LENGTH)
+            return value;
+        return `${value.slice(0, PREVIEW_LENGTH)}... (+${value.length - PREVIEW_LENGTH} chars)`;
+    }
+}
+function usageSuffix(usage) {
+    if (!usage)
+        return "";
+    const cached = usage.cachedTokens != null ? ` cached=${usage.cachedTokens}` : "";
+    return ` | tokens in=${usage.promptTokens} out=${usage.outputTokens}${cached} total=${usage.totalTokens}`;
+}
+function json(value) {
+    try {
+        return JSON.stringify(value) ?? "undefined";
+    }
+    catch {
+        return String(value);
+    }
+}
+
+class DeltaStateBag {
+    constructor(initial) {
+        this.initial = initial;
+        this.changes = new Map();
+    }
+    get(key) {
+        if (this.changes.has(key))
+            return this.changes.get(key);
+        return this.initial[key];
+    }
+    set(key, value) {
+        this.changes.set(key, value);
+    }
+    delta() {
+        return Object.fromEntries(this.changes);
+    }
+}
+
+const EMPTY_USAGE = { promptTokens: 0, outputTokens: 0, totalTokens: 0 };
+const HITL_STATE_KEY = "__adk_hitl";
+exports.AgentRunner = class AgentRunner {
+    constructor(engine, registry, store, artifacts, options, toolsets) {
+        this.engine = engine;
+        this.registry = registry;
+        this.store = store;
+        this.artifacts = artifacts;
+        this.options = options;
+        this.toolsets = toolsets;
+    }
+    async *run(agentType, input) {
+        const definition = this.definitionOf(agentType);
+        const log = RunLogger.create(this.options.logging, definition.name);
+        log?.start(input);
+        const session = await this.openSession(input);
+        const state = new DeltaStateBag({ ...(session?.state ?? {}), ...(input.state ?? {}) });
+        const runtime = { scope: input.sessionId ?? node_crypto.randomUUID(), pendings: [] };
+        const ctx = this.createToolContext(definition, input, state);
+        const resolved = await this.resolveAgent(definition, ctx, runtime);
+        const engineInput = { ...input, history: session?.events };
+        if (session)
+            await this.persist(session.id, "user", "message", { text: input.message });
+        for await (const event of this.engine.run(resolved, engineInput)) {
+            log?.event(event);
+            if (session)
+                await this.persistAgentEvent(session.id, event);
+            if (event.type === "final" && definition.output && definition.outputKey) {
+                const parsed = definition.output.safeParse(tryParseJson(event.text));
+                if (parsed.success)
+                    state.set(definition.outputKey, parsed.data);
+            }
+            yield event;
+        }
+        for (const pending of runtime.pendings) {
+            const approval = {
+                type: "approval_required",
+                agent: pending.agent,
+                callId: pending.callId,
+                tool: pending.tool,
+                args: pending.args,
+            };
+            log?.event(approval);
+            yield approval;
+        }
+        if (session) {
+            const delta = state.delta();
+            if (Object.keys(delta).length > 0)
+                await this.store.updateState(session.id, delta);
+        }
+    }
+    async ask(agentType, input) {
+        const events = [];
+        let text = "";
+        let usage = EMPTY_USAGE;
+        let agentName = typeof agentType === "string" ? agentType : agentType.name;
+        for await (const event of this.run(agentType, input)) {
+            events.push(event);
+            if (event.type === "run_start")
+                agentName = event.agent;
+            if (event.type === "final") {
+                text = event.text;
+                usage = event.usage;
+            }
+        }
+        const pending = [];
+        for (const event of events) {
+            if (event.type === "approval_required") {
+                pending.push({ callId: event.callId, tool: event.tool, args: event.args, agent: event.agent });
+            }
+        }
+        if (pending.length > 0)
+            return { text, usage, events, status: "pending_approval", pending };
+        if (!text.trim())
+            throw new AiEmptyResponseError(agentName);
+        const definition = this.definitionOf(agentType);
+        let output;
+        if (definition.output) {
+            const result = definition.output.safeParse(tryParseJson(text));
+            if (!result.success)
+                throw new OutputValidationError(agentName, text, result.error.issues);
+            output = result.data;
+        }
+        return { text, usage, events, status: "completed", output };
+    }
+    async approve(agentType, params) {
+        const definition = this.definitionOf(agentType);
+        const { session, entry, rest } = await this.takePending(params.sessionId, params.callId);
+        const binding = definition.tools.find((candidate) => candidate.options.name === entry.tool);
+        if (!binding)
+            throw new ApprovalNotFoundError(params.callId, params.sessionId);
+        const state = new DeltaStateBag(session.state);
+        const ctx = this.createToolContext(definition, { message: "", sessionId: session.id, userId: session.userId }, state);
+        const result = await this.executeBinding(definition, binding, entry.args, ctx);
+        await this.persist(session.id, "tool", "tool_result", { callId: entry.callId, tool: entry.tool, result });
+        await this.store.updateState(session.id, { [HITL_STATE_KEY]: rest });
+        const message = params.message ??
+            `[system] Action "${entry.tool}" was approved by the user and executed. Result: ${JSON.stringify(result)}. Continue the conversation.`;
+        return this.ask(agentType, { sessionId: session.id, userId: session.userId, message });
+    }
+    async reject(agentType, params) {
+        const { session, entry, rest } = await this.takePending(params.sessionId, params.callId);
+        await this.store.updateState(session.id, { [HITL_STATE_KEY]: rest });
+        const reason = params.reason ? ` (reason: ${params.reason})` : "";
+        const message = `[system] The user rejected action "${entry.tool}"${reason}. The action was NOT executed. Continue the conversation.`;
+        return this.ask(agentType, { sessionId: session.id, userId: session.userId, message });
+    }
+    resolve(agentType, input = { message: "" }) {
+        const definition = this.definitionOf(agentType);
+        const state = new DeltaStateBag({ ...(input.state ?? {}) });
+        return this.resolveAgent(definition, this.createToolContext(definition, input, state), {
+            scope: input.sessionId ?? node_crypto.randomUUID(),
+            pendings: [],
+        });
+    }
+    definitionOf(agentType) {
+        return typeof agentType === "string" ? this.registry.get(agentType) : this.registry.getByType(agentType);
+    }
+    async openSession(input) {
+        if (!input.sessionId)
+            return null;
+        const existing = await this.store.get(input.sessionId);
+        if (existing)
+            return existing;
+        return this.store.create({ id: input.sessionId, userId: input.userId });
+    }
+    async takePending(sessionId, callId) {
+        const session = await this.store.get(sessionId);
+        if (!session)
+            throw new SessionNotFoundError(sessionId);
+        const pendings = session.state[HITL_STATE_KEY] ?? [];
+        const entry = pendings.find((candidate) => candidate.callId === callId);
+        if (!entry)
+            throw new ApprovalNotFoundError(callId, sessionId);
+        return { session, entry, rest: pendings.filter((candidate) => candidate.callId !== callId) };
+    }
+    createToolContext(definition, input, state) {
+        return {
+            agentName: definition.name,
+            sessionId: input.sessionId,
+            userId: input.userId,
+            state,
+            attributes: input.attributes ?? {},
+            signal: input.signal ?? new AbortController().signal,
+            actions: { endRun: () => undefined },
+        };
+    }
+    policyOf(definition) {
+        return definition.options?.context ?? this.options.context;
+    }
+    async resolveAgent(definition, ctx, runtime) {
+        const policy = this.policyOf(definition);
+        const offloadEnabled = policy?.offload !== false;
+        const threshold = (policy?.offload || undefined)?.threshold ?? DEFAULT_OFFLOAD_THRESHOLD;
+        const tools = definition.tools.map((binding) => ({
+            name: binding.options.name ?? "",
+            description: binding.options.description,
+            schema: binding.options.schema,
+            execute: async (input) => {
+                if (await this.needsApproval(definition, binding, input, ctx)) {
+                    const pending = {
+                        callId: node_crypto.randomUUID(),
+                        tool: binding.options.name ?? "",
+                        args: input,
+                        agent: definition.name,
+                    };
+                    runtime.pendings.push(pending);
+                    const existing = ctx.state.get(HITL_STATE_KEY) ?? [];
+                    ctx.state.set(HITL_STATE_KEY, [...existing, pending]);
+                    return {
+                        pending_approval: true,
+                        callId: pending.callId,
+                        note: `Action "${pending.tool}" requires user approval and was NOT executed. Let the user know it is awaiting approval.`,
+                    };
+                }
+                const raw = await this.executeBinding(definition, binding, input, ctx);
+                if (!offloadEnabled || binding.options.offload === false)
+                    return raw;
+                return this.maybeOffload(raw, binding.options.name ?? "", threshold, runtime.scope);
+            },
+        }));
+        for (const ref of definition.toolsets) {
+            const external = (await this.toolsets?.resolve(ref)) ?? [];
+            for (const tool of external) {
+                tools.push({
+                    ...tool,
+                    execute: async (input) => {
+                        const raw = await tool.execute(input);
+                        return offloadEnabled ? this.maybeOffload(raw, tool.name, threshold, runtime.scope) : raw;
+                    },
+                });
+            }
+        }
+        if (offloadEnabled && tools.length > 0)
+            tools.push(this.createReadArtifactTool(runtime.scope));
+        if (definition.skills.some((skill) => skill.options.mode === "on-demand")) {
+            tools.push(this.createLoadSkillTool(definition));
+        }
+        const subAgents = [];
+        for (const subType of definition.subAgents) {
+            const subDefinition = this.registry.getByType(subType);
+            subAgents.push(await this.resolveAgent(subDefinition, { ...ctx, agentName: subDefinition.name }, runtime));
+        }
+        let workflow;
+        if (definition.workflow) {
+            const agents = [];
+            for (const agentType of definition.workflow.agents) {
+                const agentDefinition = this.registry.getByType(agentType);
+                agents.push(await this.resolveAgent(agentDefinition, { ...ctx, agentName: agentDefinition.name }, runtime));
+            }
+            workflow = { mode: definition.workflow.mode, agents, maxIterations: definition.workflow.maxIterations };
+        }
+        return {
+            name: definition.name,
+            description: definition.description,
+            instruction: await buildInstruction(definition, { promptsDir: this.options.prompts?.dir }, ctx),
+            model: this.registry.modelFor(definition),
+            tools,
+            subAgents,
+            workflow,
+            outputSchema: definition.output,
+            context: policy,
+        };
+    }
+    async needsApproval(definition, binding, input, ctx) {
+        const requirement = binding.options.requiresApproval;
+        if (!requirement)
+            return false;
+        if (requirement === true)
+            return true;
+        const self = binding.kind === "class" ? binding.instance : definition.instance;
+        return requirement.call(self, input, ctx);
+    }
+    async executeBinding(definition, binding, input, ctx) {
+        try {
+            if (binding.kind === "class")
+                return await binding.instance.execute(input, ctx);
+            const method = definition.instance[binding.method];
+            return await method?.call(definition.instance, input, ctx);
+        }
+        catch (error) {
+            throw new ToolExecutionError(binding.options.name ?? "unknown", error);
+        }
+    }
+    async maybeOffload(raw, tool, threshold, scope) {
+        if (raw === undefined || raw === null)
+            return raw;
+        const serialized = typeof raw === "string" ? raw : JSON.stringify(raw);
+        if (serialized.length <= threshold)
+            return raw;
+        const name = `tool-results/${tool}-${node_crypto.randomUUID()}`;
+        const version = await this.artifacts.save({ sessionId: scope, name }, { mimeType: "application/json", data: serialized });
+        return {
+            __artifact: {
+                name,
+                version,
+                bytes: serialized.length,
+                preview: serialized.slice(0, 300),
+                note: "Result externalized due to size. Use read_artifact(name) to read the full content.",
+            },
+        };
+    }
+    createReadArtifactTool(scope) {
+        return {
+            name: "read_artifact",
+            description: "Reads the full content of an externalized result (__artifact reference).",
+            schema: zod.z.object({
+                name: zod.z.string().describe("Artifact name (the __artifact.name field)."),
+                version: zod.z.number().optional(),
+            }),
+            execute: async (input) => {
+                const { name, version } = input;
+                const part = await this.artifacts.load({ sessionId: scope, name }, version);
+                if (!part)
+                    return { error: `Artifact "${name}" not found.` };
+                return { name, content: part.data };
+            },
+        };
+    }
+    createLoadSkillTool(definition) {
+        return {
+            name: "load_skill",
+            description: "Loads the full content of a catalog skill by name.",
+            schema: zod.z.object({ name: zod.z.string().describe("Skill name in the catalog.") }),
+            execute: async (input) => {
+                const name = input.name ?? "";
+                const binding = definition.skills.find((skill) => skill.options.name === name);
+                if (!binding) {
+                    const available = definition.skills.map((skill) => skill.options.name).join(", ");
+                    return { error: `Skill "${name}" does not exist. Available: ${available}` };
+                }
+                return { name, content: await skillContent(definition, binding) };
+            },
+        };
+    }
+    async persistAgentEvent(sessionId, event) {
+        switch (event.type) {
+            case "tool_call":
+                return this.persist(sessionId, "agent", "tool_call", {
+                    callId: event.callId,
+                    tool: event.tool,
+                    args: event.args,
+                });
+            case "tool_result":
+                return this.persist(sessionId, "tool", "tool_result", {
+                    callId: event.callId,
+                    tool: event.tool,
+                    result: event.result,
+                });
+            case "final":
+                return this.persist(sessionId, "agent", "message", { text: event.text });
+            default:
+                return;
+        }
+    }
+    async persist(sessionId, author, type, data) {
+        await this.store.appendEvent(sessionId, { v: 1, id: node_crypto.randomUUID(), at: Date.now(), author, type, data });
+    }
+};
+exports.AgentRunner = __decorate([
+    common.Injectable(),
+    __param(4, common.Inject(ADK_OPTIONS)),
+    __param(5, common.Optional()),
+    __metadata("design:paramtypes", [AdkEngine,
+        exports.AgentRegistry,
+        SessionStore,
+        ArtifactStore, Object, ToolsetResolver])
+], exports.AgentRunner);
+function tryParseJson(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        const match = text.match(/\{[\s\S]*\}/);
+        if (!match)
+            return text;
+        try {
+            return JSON.parse(match[0]);
+        }
+        catch {
+            return text;
+        }
+    }
+}
+
+var AdkModule_1;
+async function resolveStore(moduleRef, cls) {
+    try {
+        return moduleRef.get(cls, { strict: false });
+    }
+    catch {
+        return moduleRef.create(cls);
+    }
+}
+exports.AdkModule = AdkModule_1 = class AdkModule {
+    static forRoot(options) {
+        return AdkModule_1.assemble(options.engine, [{ provide: ADK_OPTIONS, useValue: options }]);
+    }
+    static forRootAsync(options) {
+        const optionsProvider = {
+            provide: ADK_OPTIONS,
+            useFactory: async (...args) => ({ ...(await options.useFactory(...args)), engine: options.engine }),
+            inject: options.inject ?? [],
+        };
+        return AdkModule_1.assemble(options.engine, [optionsProvider], options.imports);
+    }
+    static assemble(engine, optionsProviders, imports = []) {
+        const storeProviders = [
+            {
+                provide: SessionStore,
+                useFactory: (options, moduleRef) => resolveStore(moduleRef, options.session ?? exports.InMemorySessionStore),
+                inject: [ADK_OPTIONS, core.ModuleRef],
+            },
+            {
+                provide: ArtifactStore,
+                useFactory: (options, moduleRef) => resolveStore(moduleRef, options.artifacts ?? exports.InMemoryArtifactStore),
+                inject: [ADK_OPTIONS, core.ModuleRef],
+            },
+            {
+                provide: Embedder,
+                useFactory: async (options, moduleRef) => {
+                    const instance = options.embedder ? await resolveStore(moduleRef, options.embedder) : undefined;
+                    Embedder.setActive(instance);
+                    return instance;
+                },
+                inject: [ADK_OPTIONS, core.ModuleRef],
+            },
+        ];
+        return {
+            module: AdkModule_1,
+            global: true,
+            imports: [core.DiscoveryModule, ...(imports ?? [])],
+            providers: [
+                ...optionsProviders,
+                { provide: AdkEngine, useClass: engine },
+                ...storeProviders,
+                exports.Similarity,
+                exports.AgentRegistry,
+                exports.AgentRunner,
+                { provide: ADK_RUNNER, useExisting: exports.AgentRunner },
+                exports.AgentSessions,
+            ],
+            exports: [
+                ADK_OPTIONS,
+                AdkEngine,
+                SessionStore,
+                ArtifactStore,
+                Embedder,
+                exports.Similarity,
+                exports.AgentRegistry,
+                exports.AgentRunner,
+                ADK_RUNNER,
+                exports.AgentSessions,
+            ],
+        };
+    }
+};
+exports.AdkModule = AdkModule_1 = __decorate([
+    common.Module({})
+], exports.AdkModule);
+
+class Gemini {
+    constructor(model, options = {}) {
+        this.model = model;
+        this.__adkModelSpec = "gemini";
+        Object.assign(this, options);
+    }
+}
+class OpenAiLike {
+    constructor(model, options = {}) {
+        this.model = model;
+        this.__adkModelSpec = "openai-like";
+        Object.assign(this, options);
+    }
+}
+class ModelRouter {
+    constructor(options) {
+        this.__adkModelSpec = "router";
+        this.targets = Array.isArray(options.targets)
+            ? Object.fromEntries(options.targets.map((target, index) => [`target_${index}`, target]))
+            : options.targets;
+        this.strategy = options.strategy ?? "failover";
+    }
+}
+function isModelSpec(model) {
+    return typeof model === "object" && model !== null && "__adkModelSpec" in model;
+}
+
+function callTool(tool, args) {
+    return { kind: "tool_call", tool, args };
+}
+function fail(message) {
+    return { kind: "fail", message };
+}
+function text(value, usage) {
+    return {
+        kind: "text",
+        text: value,
+        usage: {
+            promptTokens: usage?.promptTokens ?? 10,
+            outputTokens: usage?.outputTokens ?? 5,
+            totalTokens: usage?.totalTokens ?? 15,
+        },
+    };
+}
+exports.ScriptedEngine = class ScriptedEngine extends AdkEngine {
+    constructor() {
+        super(...arguments);
+        this.scripts = [];
+        this.draft = [];
+    }
+    enqueue(turns) {
+        this.scripts.push(turns);
+    }
+    push(turn) {
+        this.draft.push(turn);
+    }
+    async *run(agent, input) {
+        this.lastAgent = agent;
+        this.lastInput = input;
+        const turns = this.draft.length > 0 ? this.draft.splice(0) : (this.scripts.shift() ?? [text("")]);
+        yield { type: "run_start", agent: agent.name, sessionId: input.sessionId };
+        const total = { promptTokens: 0, outputTokens: 0, totalTokens: 0 };
+        let finalText = "";
+        for (const turn of turns) {
+            if (turn.kind === "fail")
+                throw new Error(turn.message);
+            if (turn.kind === "tool_call") {
+                const tool = agent.tools.find((candidate) => candidate.name === turn.tool);
+                if (!tool)
+                    throw new Error(`ScriptedEngine: tool "${turn.tool}" not found on agent "${agent.name}".`);
+                const callId = node_crypto.randomUUID();
+                yield { type: "tool_call", agent: agent.name, callId, tool: turn.tool, args: turn.args };
+                const result = await tool.execute(turn.args);
+                yield { type: "tool_result", agent: agent.name, callId, tool: turn.tool, result };
+                continue;
+            }
+            total.promptTokens += turn.usage.promptTokens;
+            total.outputTokens += turn.usage.outputTokens;
+            total.totalTokens += turn.usage.totalTokens;
+            finalText = turn.text;
+            yield { type: "llm_response", agent: agent.name, text: turn.text, usage: turn.usage };
+        }
+        yield { type: "final", agent: agent.name, text: finalText, usage: total };
+    }
+};
+exports.ScriptedEngine = __decorate([
+    common.Injectable()
+], exports.ScriptedEngine);
+
+class ScriptedModel {
+    constructor(...scripts) {
+        this.__adkScriptedModel = true;
+        this.scripts = [...scripts];
+    }
+    enqueue(turns) {
+        this.scripts.push(turns);
+        return this;
+    }
+}
+function isScriptedModel(model) {
+    return typeof model === "object" && model !== null && "__adkScriptedModel" in model;
+}
+
+exports.ADK_OPTIONS = ADK_OPTIONS;
+exports.AdkAgent = AdkAgent;
+exports.AdkBootError = AdkBootError;
+exports.AdkEngine = AdkEngine;
+exports.AdkError = AdkError;
+exports.AdkPrompt = AdkPrompt;
+exports.AdkSkill = AdkSkill;
+exports.AdkTool = AdkTool;
+exports.AdkWorkflow = AdkWorkflow;
+exports.Agent = Agent;
+exports.AgentDefinition = AgentDefinition;
+exports.AgentNotFoundError = AgentNotFoundError;
+exports.AgentRef = AgentRef;
+exports.AiEmptyResponseError = AiEmptyResponseError;
+exports.ApprovalNotFoundError = ApprovalNotFoundError;
+exports.ArtifactStore = ArtifactStore;
+exports.ConflictingPromptError = ConflictingPromptError;
+exports.DEFAULT_OFFLOAD_THRESHOLD = DEFAULT_OFFLOAD_THRESHOLD;
+exports.DeltaStateBag = DeltaStateBag;
+exports.DuplicateAgentNameError = DuplicateAgentNameError;
+exports.Embedder = Embedder;
+exports.EmbedderNotConfiguredError = EmbedderNotConfiguredError;
+exports.Gemini = Gemini;
+exports.InvalidWorkflowError = InvalidWorkflowError;
+exports.McpConnectionError = McpConnectionError;
+exports.MemoryStore = MemoryStore;
+exports.MissingModelError = MissingModelError;
+exports.ModelRouter = ModelRouter;
+exports.ModelsExhaustedError = ModelsExhaustedError;
+exports.OpenAiLike = OpenAiLike;
+exports.OutputValidationError = OutputValidationError;
+exports.ReservedMethodError = ReservedMethodError;
+exports.RunLogger = RunLogger;
+exports.ScriptedModel = ScriptedModel;
+exports.SessionNotFoundError = SessionNotFoundError;
+exports.SessionStore = SessionStore;
+exports.Skill = Skill;
+exports.SkillNotFoundError = SkillNotFoundError;
+exports.Tool = Tool;
+exports.ToolExecutionError = ToolExecutionError;
+exports.ToolsetResolver = ToolsetResolver;
+exports.UnregisteredPromptError = UnregisteredPromptError;
+exports.UnregisteredSkillError = UnregisteredSkillError;
+exports.UnregisteredSubAgentError = UnregisteredSubAgentError;
+exports.UnregisteredToolError = UnregisteredToolError;
+exports.UnresolvedToolsetError = UnresolvedToolsetError;
+exports.WorkflowAgent = WorkflowAgent;
+exports.buildInstruction = buildInstruction;
+exports.callTool = callTool;
+exports.contextPolicy = contextPolicy;
+exports.fail = fail;
+exports.isModelSpec = isModelSpec;
+exports.isScriptedModel = isScriptedModel;
+exports.isToolsetRef = isToolsetRef;
+exports.skillContent = skillContent;
+exports.text = text;
+exports.toolset = toolset;