@softactivate/adk 1.1.0

package/dist/types/sessions/session.d.ts

@@ -0,0 +1,46 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Event } from '../events/event.js';
+/**
+ * Represents a session in a conversation between agents and users.
+ */
+export interface Session {
+    /**
+     * The unique identifier of the session.
+     */
+    id: string;
+    /**
+     * The name of the app.
+     */
+    appName: string;
+    /**
+     * The id of the user.
+     */
+    userId: string;
+    /**
+     * The state of the session.
+     */
+    state: Record<string, unknown>;
+    /**
+     * The events of the session, e.g. user input, model response, function
+     * call/response, etc.
+     */
+    events: Event[];
+    /**
+     * The last update time of the session.
+     */
+    lastUpdateTime: number;
+}
+/**
+ * Creates a session from a partial session.
+ *
+ * @param params The partial session to create the session from.
+ * @returns The session.
+ */
+export declare function createSession(params: Partial<Session> & {
+    id: string;
+    appName: string;
+}): Session;

package/dist/types/sessions/state.d.ts

@@ -0,0 +1,57 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * A state mapping that maintains the current value and the pending-commit
+ * delta.
+ */
+export declare class State {
+    /** The current value of the state. */
+    private value;
+    /** The delta change to the current value that hasn't been committed. */
+    private delta;
+    static readonly APP_PREFIX = "app:";
+    static readonly USER_PREFIX = "user:";
+    static readonly TEMP_PREFIX = "temp:";
+    constructor(
+    /** The current value of the state. */
+    value?: Record<string, unknown>, 
+    /** The delta change to the current value that hasn't been committed. */
+    delta?: Record<string, unknown>);
+    /**
+     * Returns the value of the state dict for the given key.
+     *
+     * @param key The key to get the value for.
+     * @param defaultValue The default value to return if the key is not found.
+     * @return The value of the state for the given key, or the default value if
+     *     not found.
+     */
+    get<T>(key: string, defaultValue?: T): T | undefined;
+    /**
+     * Sets the value of the state dict for the given key.
+     *
+     * @param key The key to set the value for.
+     * @param value The value to set.
+     */
+    set(key: string, value: unknown): void;
+    /**
+     * Whether the state has pending delta.
+     */
+    has(key: string): boolean;
+    /**
+     * Whether the state has pending delta.
+     */
+    hasDelta(): boolean;
+    /**
+     * Updates the state dict with the given delta.
+     *
+     * @param delta The delta to update the state with.
+     */
+    update(delta: Record<string, unknown>): void;
+    /**
+     * Returns the state as a plain JSON object.
+     */
+    toRecord(): Record<string, unknown>;
+}

package/dist/types/skills/loader.d.ts

@@ -0,0 +1,38 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Frontmatter, Skill } from './skill.js';
+/**
+ * Parses SKILL.md from a raw content string, extracting the YAML frontmatter and the body.
+ *
+ * @param content - The raw content of the SKILL.md file.
+ * @returns An object containing the parsed frontmatter and the remaining markdown body.
+ * @throws {Error} If the content is not properly formatted with YAML frontmatter.
+ */
+export declare function parseSkillMdContent(content: string): {
+    frontmatter: Frontmatter;
+    body: string;
+};
+/**
+ * Load a complete skill, including its instructions and resources, from a directory.
+ *
+ * @param skillDir - The path to the directory containing the skill definition.
+ * @returns A promise that resolves to the fully loaded Skill object.
+ */
+export declare function loadSkillFromDir(skillDir: string): Promise<Skill>;
+/**
+ * Validates a skill directory structure and frontmatter without fully loading all resources.
+ *
+ * @param skillDir - The path to the skill directory to validate.
+ * @returns A promise that resolves to an array of validation error messages, or an empty array if valid.
+ */
+export declare function validateSkillDir(skillDir: string): Promise<string[]>;
+/**
+ * Loads all skills located within subdirectories of a given base path.
+ *
+ * @param skillsBasePath - The base directory containing individual skill subdirectories.
+ * @returns A promise that resolves to a map of skill names to their corresponding Skill objects.
+ */
+export declare function loadAllSkillsInDir(skillsBasePath: string): Promise<Record<string, Skill>>;

package/dist/types/skills/prompt.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Frontmatter, Skill } from './skill.js';
+/**
+ * Formats available skills into a standard XML string.
+ *
+ * @param skills A list of skill frontmatter or full skill objects.
+ * @returns XML string with <available_skills> block.
+ */
+export declare function formatSkillsAsXml(skills: Array<Skill | Frontmatter>): string;

package/dist/types/skills/skill.d.ts

@@ -0,0 +1,48 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { z } from 'zod';
+export declare const SNAKE_OR_KEBAB_NAME_PATTERN: RegExp;
+/**
+ * Schema and Type for Skill Frontmatter metadata.
+ */
+export declare const FrontmatterSchema: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    license: z.ZodOptional<z.ZodString>;
+    compatibility: z.ZodOptional<z.ZodString>;
+    'allowed-tools': z.ZodOptional<z.ZodString>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, z.core.$loose>>;
+export interface Frontmatter {
+    name: string;
+    description: string;
+    license?: string;
+    compatibility?: string;
+    allowedTools?: string;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Wrapper for script content.
+ */
+export interface Script {
+    src: string;
+}
+/**
+ * L3 skill content: additional instructions, assets, and scripts.
+ */
+export interface Resources {
+    references?: Record<string, string | Buffer>;
+    assets?: Record<string, string | Buffer>;
+    scripts?: Record<string, Script>;
+}
+/**
+ * Complete skill representation including frontmatter, instructions, and resources.
+ */
+export interface Skill {
+    frontmatter: Frontmatter;
+    instructions: string;
+    resources?: Resources;
+}

package/dist/types/telemetry/google_cloud.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Resource } from '@opentelemetry/resources';
+import { OtelExportersConfig, OTelHooks } from './setup.js';
+export declare function getGcpExporters(config?: OtelExportersConfig): Promise<OTelHooks>;
+export declare function getGcpResource(): Resource;

package/dist/types/telemetry/setup.d.ts

@@ -0,0 +1,48 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Resource } from '@opentelemetry/resources';
+import { LogRecordProcessor } from '@opentelemetry/sdk-logs';
+import { MetricReader } from '@opentelemetry/sdk-metrics';
+import { SpanProcessor } from '@opentelemetry/sdk-trace-base';
+export interface OtelExportersConfig {
+    enableTracing?: boolean;
+    enableMetrics?: boolean;
+    enableLogging?: boolean;
+}
+/**
+ * Configuration hooks for OpenTelemetry setup.
+ *
+ * This interface defines the structure for configuring OpenTelemetry
+ * components including span processors, metric readers, and log record processors.
+ */
+export interface OTelHooks {
+    spanProcessors?: SpanProcessor[];
+    metricReaders?: MetricReader[];
+    logRecordProcessors?: LogRecordProcessor[];
+}
+/**
+ * Sets up OTel providers if hooks for a given telemetry type were passed.
+ *
+ * Additionally adds generic OTLP exporters based on following env variables:
+ * OTEL_EXPORTER_OTLP_ENDPOINT
+ * OTEL_EXPORTER_OTLP_TRACES_ENDPOINT
+ * OTEL_EXPORTER_OTLP_METRICS_ENDPOINT
+ * OTEL_EXPORTER_OTLP_LOGS_ENDPOINT
+ * See https://opentelemetry.io/docs/languages/sdk-configuration/otlp-exporter/
+ * for how they are used.
+ *
+ * If a provider for a specific telemetry type was already globally set -
+ * this function will not override it or register more exporters.
+ *
+ * @experimental (Experimental, subject to change)
+ *
+ * @param otelHooksToSetup per-telemetry-type processors and readers to be added
+ * to OTel providers. If no hooks for a specific telemetry type are passed -
+ * provider will not be set.
+ * @param otelResource OTel resource to use in providers.
+ * If empty - default OTel resource detection will be used.
+ */
+export declare function maybeSetOtelProviders(otelHooksToSetup?: OTelHooks[], otelResource?: Resource): void;

package/dist/types/telemetry/tracing.d.ts

@@ -0,0 +1,112 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * NOTE:
+ *
+ *    We expect that the underlying GenAI SDK will provide a certain
+ *    level of tracing and logging telemetry aligned with Open Telemetry
+ *    Semantic Conventions (such as logging prompts, responses,
+ *    request properties, etc.) and so the information that is recorded by the
+ *    Agent Development Kit should be focused on the higher-level
+ *    constructs of the framework that are not observable by the SDK.
+ */
+import { Content } from '@google/genai';
+import { Context } from '@opentelemetry/api';
+import { BaseAgent } from '../agents/base_agent.js';
+import { InvocationContext } from '../agents/invocation_context.js';
+import { Event } from '../events/event.js';
+import { LlmRequest } from '../models/llm_request.js';
+import { LlmResponse } from '../models/llm_response.js';
+import { BaseTool } from '../tools/base_tool.js';
+export declare const tracer: import("@opentelemetry/api").Tracer;
+export interface TraceAgentInvocationParams {
+    agent: BaseAgent;
+    invocationContext: InvocationContext;
+}
+/**
+ * Sets span attributes immediately available on agent invocation according to OTEL semconv version 1.37.
+ *
+ * @param params The parameters object containing agent and invocation context.
+ *
+ * Inference related fields are not set, due to their planned removal from invoke_agent span:
+ * https://github.com/open-telemetry/semantic-conventions/issues/2632
+ *
+ * `gen_ai.agent.id` is not set because currently it's unclear what attributes this field should have, specifically:
+ * - In which scope should it be unique (globally, given project, given agentic flow, given deployment).
+ * - Should it be unchanging between deployments, and how this should this be achieved.
+ *
+ * `gen_ai.data_source.id` is not set because it's not available.
+ * Closest type which could contain this information is types.GroundingMetadata, which does not have an ID.
+ *
+ * `server.*` attributes are not set pending confirmation from aabmass.
+ */
+export declare function traceAgentInvocation({ agent, invocationContext, }: TraceAgentInvocationParams): void;
+export interface TraceToolCallParams {
+    tool: BaseTool;
+    args: Record<string, unknown>;
+    functionResponseEvent: Event;
+}
+/**
+ * Traces tool call.
+ *
+ * @param params The parameters object containing tool, args, and function response event.
+ */
+export declare function traceToolCall({ tool, args, functionResponseEvent, }: TraceToolCallParams): void;
+export interface TraceMergedToolCallsParams {
+    responseEventId: string;
+    functionResponseEvent: Event;
+}
+/**
+ * Traces merged tool call events.
+ *
+ * Calling this function is not needed for telemetry purposes. This is provided
+ * for preventing /debug/trace requests (typically sent by web UI).
+ *
+ * @param params The parameters object containing response event ID and function response event.
+ */
+export declare function traceMergedToolCalls({ responseEventId, functionResponseEvent, }: TraceMergedToolCallsParams): void;
+export interface TraceCallLlmParams {
+    invocationContext: InvocationContext;
+    eventId: string;
+    llmRequest: LlmRequest;
+    llmResponse: LlmResponse;
+}
+/**
+ * Traces a call to the LLM.
+ *
+ * This function records details about the LLM request and response as
+ * attributes on the current OpenTelemetry span.
+ *
+ * @param params The parameters object containing invocationContext, eventId, llmRequest, and llmResponse.
+ */
+export declare function traceCallLlm({ invocationContext, eventId, llmRequest, llmResponse, }: TraceCallLlmParams): void;
+export interface TraceSendDataParams {
+    /** The invocation context for the current agent run. */
+    invocationContext: InvocationContext;
+    /** The ID of the event. */
+    eventId: string;
+    /** A list of content objects. */
+    data: Content[];
+}
+/**
+ * Traces the sending of data to the agent.
+ *
+ * This function records details about the data sent to the agent as
+ * attributes on the current OpenTelemetry span.
+ *
+ * @param params The parameters object containing invocationContext, eventId, and data.
+ */
+export declare function traceSendData({ invocationContext, eventId, data, }: TraceSendDataParams): void;
+/**
+ * Runs an async generator function with both OTEL context and JavaScript 'this' context.
+ *
+ * @param otelContext - The OpenTelemetry context to bind the generator to
+ * @param generatorFnContext - The 'this' context to bind to the generator function
+ * @param generatorFn - The generator function to execute
+ *
+ * @returns A new async generator that executes within both contexts
+ */
+export declare function runAsyncGeneratorWithOtelContext<TThis, T>(otelContext: Context, generatorFnContext: TThis, generatorFn: (this: TThis) => AsyncGenerator<T, void, void>): AsyncGenerator<T, void, void>;

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

@@ -0,0 +1,73 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Content, FunctionDeclaration } from '@google/genai';
+import { BaseAgent } from '../agents/base_agent.js';
+import { Event } from '../events/event.js';
+import { BaseTool, RunAsyncToolRequest } from './base_tool.js';
+/**
+ * The configuration of the agent tool.
+ */
+export interface AgentToolConfig {
+    /**
+     * The reference to the agent instance.
+     */
+    agent: BaseAgent;
+    /**
+     * Whether to skip summarization of the agent output.
+     */
+    skipSummarization?: boolean;
+}
+/**
+ * A unique symbol to identify ADK agent classes.
+ * Defined once and shared by all BaseTool instances.
+ */
+declare const AGENT_TOOL_SIGNATURE_SYMBOL: unique symbol;
+/**
+ * Type guard to check if an object is an instance of BaseTool.
+ * @param obj The object to check.
+ * @returns True if the object is an instance of BaseTool, false otherwise.
+ */
+export declare function isAgentTool(obj: unknown): obj is AgentTool;
+/**
+ * A tool that wraps an agent.
+ *
+ * This tool allows an agent to be called as a tool within a larger
+ * application. The agent's input schema is used to define the tool's input
+ * parameters, and the agent's output is returned as the tool's result.
+ *
+ *  @param config: The configuration of the agent tool.
+ */
+export declare class AgentTool extends BaseTool {
+    /** A unique symbol to identify ADK agent tool class. */
+    readonly [AGENT_TOOL_SIGNATURE_SYMBOL] = true;
+    private readonly agent;
+    private readonly skipSummarization;
+    constructor(config: AgentToolConfig);
+    _getDeclaration(): FunctionDeclaration;
+    /**
+     * Sets up the Runner and Session for sub-agent execution.
+     *
+     * Shared by {@link runAsync} and {@link runAsyncWithEvents}.
+     */
+    private setupRunnerAndSession;
+    /**
+     * Builds the tool result from the last content event of the sub-agent.
+     *
+     * Excludes thought parts and applies the output schema (if any).
+     */
+    buildToolResultFromContent(lastContent: Content | undefined): unknown;
+    runAsync({ args, toolContext, }: RunAsyncToolRequest): Promise<unknown>;
+    /**
+     * Runs the wrapped agent and yields the sub-agent's events as they are
+     * produced, providing real-time visibility into sub-agent progress.
+     *
+     * Counterpart to {@link runAsync}; the caller is responsible for tracking
+     * the last content event and building the final tool result via
+     * {@link buildToolResultFromContent}.
+     */
+    runAsyncWithEvents({ args, toolContext, }: RunAsyncToolRequest): AsyncGenerator<Event>;
+}
+export {};

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

@@ -0,0 +1,98 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { FunctionDeclaration } from '@google/genai';
+import { LlmRequest } from '../models/llm_request.js';
+import { Context } from '../agents/context.js';
+/**
+ * The parameters for `runAsync`.
+ */
+export interface RunAsyncToolRequest {
+    args: Record<string, unknown>;
+    toolContext: Context;
+}
+/**
+ * The parameters for `processLlmRequest`.
+ */
+export interface ToolProcessLlmRequest {
+    toolContext: Context;
+    llmRequest: LlmRequest;
+}
+/**
+ * Parameters for the BaseTool constructor.
+ */
+export interface BaseToolParams {
+    name: string;
+    description: string;
+    isLongRunning?: boolean;
+}
+/**
+ * A unique symbol to identify ADK agent classes.
+ * Defined once and shared by all BaseTool instances.
+ */
+declare const BASE_TOOL_SIGNATURE_SYMBOL: unique symbol;
+/**
+ * Type guard to check if an object is an instance of BaseTool.
+ * @param obj The object to check.
+ * @returns True if the object is an instance of BaseTool, false otherwise.
+ */
+export declare function isBaseTool(obj: unknown): obj is BaseTool;
+/**
+ * The base class for all tools.
+ */
+export declare abstract class BaseTool {
+    /** A unique symbol to identify ADK base tool class. */
+    readonly [BASE_TOOL_SIGNATURE_SYMBOL] = true;
+    readonly name: string;
+    readonly description: string;
+    readonly isLongRunning: boolean;
+    /**
+     * Base constructor for a tool.
+     *
+     * @param params The parameters for `BaseTool`.
+     */
+    constructor(params: BaseToolParams);
+    /**
+     * Gets the OpenAPI specification of this tool in the form of a
+     * FunctionDeclaration.
+     *
+     * NOTE
+     * - Required if subclass uses the default implementation of
+     *   `processLlmRequest` to add function declaration to LLM request.
+     * - Otherwise, can be skipped, e.g. for a built-in GoogleSearch tool for
+     *   Gemini.
+     *
+     * @return The FunctionDeclaration of this tool, or undefined if it doesn't
+     *     need to be added to LlmRequest.config.
+     */
+    _getDeclaration(): FunctionDeclaration | undefined;
+    /**
+     * Runs the tool with the given arguments and context.
+     *
+     * NOTE
+     * - Required if this tool needs to run at the client side.
+     * - Otherwise, can be skipped, e.g. for a built-in GoogleSearch tool for
+     *   Gemini.
+     *
+     * @param request The request to run the tool.
+     * @return A promise that resolves to the tool response.
+     */
+    abstract runAsync(request: RunAsyncToolRequest): Promise<unknown>;
+    /**
+     * Processes the outgoing LLM request for this tool.
+     *
+     * Use cases:
+     * - Most common use case is adding this tool to the LLM request.
+     * - Some tools may just preprocess the LLM request before it's sent out.
+     *
+     * @param request The request to process the LLM request.
+     */
+    processLlmRequest({ llmRequest }: ToolProcessLlmRequest): Promise<void>;
+    /**
+     * The Google API LLM variant to use.
+     */
+    get apiVariant(): import("../utils/variant_utils.js").GoogleLLMVariant;
+}
+export {};

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

@@ -0,0 +1,74 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { ReadonlyContext } from '../agents/readonly_context.js';
+import { LlmRequest } from '../models/llm_request.js';
+import { Context } from '../agents/context.js';
+import { BaseTool } from './base_tool.js';
+/**
+ * Function to decide whether a tool should be exposed to LLM. Toolset
+ * implementer could consider whether to accept such instance in the toolset's
+ * constructor and apply the predicate in getTools method.
+ */
+export type ToolPredicate = (tool: BaseTool, readonlyContext: ReadonlyContext) => boolean;
+/**
+ * A unique symbol to identify ADK agent classes.
+ * Defined once and shared by all BaseTool instances.
+ */
+declare const BASE_TOOLSET_SIGNATURE_SYMBOL: unique symbol;
+export declare function isBaseToolset(obj: unknown): obj is BaseToolset;
+/**
+ * Base class for toolset.
+ *
+ * A toolset is a collection of tools that can be used by an agent.
+ */
+export declare abstract class BaseToolset {
+    readonly toolFilter: ToolPredicate | string[];
+    readonly prefix?: string | undefined;
+    readonly [BASE_TOOLSET_SIGNATURE_SYMBOL] = true;
+    constructor(toolFilter: ToolPredicate | string[], prefix?: string | undefined);
+    /**
+     * Returns the tools that should be exposed to LLM.
+     *
+     * @param context Context used to filter tools available to the agent. If
+     *     not defined, all tools in the toolset are returned.
+     * @return A Promise that resolves to the list of tools.
+     */
+    abstract getTools(context?: ReadonlyContext): Promise<BaseTool[]>;
+    /**
+     * Closes the toolset.
+     *
+     * NOTE: This method is invoked, for example, at the end of an agent server's
+     * lifecycle or when the toolset is no longer needed. Implementations
+     * should ensure that any open connections, files, or other managed
+     * resources are properly released to prevent leaks.
+     *
+     * @return A Promise that resolves when the toolset is closed.
+     */
+    abstract close(): Promise<void>;
+    /**
+     * Returns whether the tool should be exposed to LLM.
+     *
+     * @param tool The tool to check.
+     * @param context Context used to filter tools available to the agent.
+     * @return Whether the tool should be exposed to LLM.
+     */
+    protected isToolSelected(tool: BaseTool, context: ReadonlyContext): boolean;
+    /**
+     * Processes the outgoing LLM request for this toolset. This method will be
+     * called before each tool processes the llm request.
+     *
+     * Use cases:
+     * - Instead of let each tool process the llm request, we can let the toolset
+     *   process the llm request. e.g. ComputerUseToolset can add computer use
+     *   tool to the llm request.
+     *
+     * @param toolContext The context of the tool.
+     * @param llmRequest The outgoing LLM request, mutable this method.
+     */
+    processLlmRequest(toolContext: Context, // eslint-disable-line @typescript-eslint/no-unused-vars
+    llmRequest: LlmRequest): Promise<void>;
+}
+export {};

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

@@ -0,0 +1,24 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { FunctionDeclaration } from '@google/genai';
+import { BaseTool, RunAsyncToolRequest } from './base_tool.js';
+/**
+ * Tool for exiting execution of a {@link LoopAgent}.
+ *
+ * When called by an LLM agent inside a LoopAgent, this tool sets the
+ * `escalate` and `skipSummarization` flags on the event actions,
+ * causing the LoopAgent to stop iterating and exit the loop.
+ *
+ */
+export declare class ExitLoopTool extends BaseTool {
+    constructor();
+    _getDeclaration(): FunctionDeclaration;
+    runAsync({ toolContext, }: RunAsyncToolRequest): Promise<unknown>;
+}
+/**
+ * A global instance of {@link ExitLoopTool}.
+ */
+export declare const EXIT_LOOP: ExitLoopTool;

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

@@ -0,0 +1,23 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Part } from '@google/genai';
+import { ArtifactVersion, BaseArtifactService, DeleteArtifactRequest, ListVersionsRequest, LoadArtifactRequest, SaveArtifactRequest } from '../artifacts/base_artifact_service.js';
+import { Context } from '../agents/context.js';
+/**
+ * Artifact service that forwards to the parent tool context.
+ */
+export declare class ForwardingArtifactService implements BaseArtifactService {
+    private readonly toolContext;
+    private readonly invocationContext;
+    constructor(toolContext: Context);
+    saveArtifact(request: SaveArtifactRequest): Promise<number>;
+    loadArtifact(request: LoadArtifactRequest): Promise<Part | undefined>;
+    listArtifactKeys(): Promise<string[]>;
+    deleteArtifact(request: DeleteArtifactRequest): Promise<void>;
+    listVersions(request: ListVersionsRequest): Promise<number[]>;
+    listArtifactVersions(request: ListVersionsRequest): Promise<ArtifactVersion[]>;
+    getArtifactVersion(request: LoadArtifactRequest): Promise<ArtifactVersion | undefined>;
+}