@sctg/cline-core 3.84.0-beta.20260524130712

package/dist/services/llms/cline-recommended-models.d.ts

@@ -0,0 +1,19 @@
+import { ProviderSettingsManager } from "../storage/provider-settings-manager";
+export interface ClineRecommendedModel {
+    id: string;
+    name: string;
+    description: string;
+    tags: string[];
+}
+export interface ClineRecommendedModelsData {
+    recommended: ClineRecommendedModel[];
+    free: ClineRecommendedModel[];
+}
+export interface FetchClineRecommendedModelsOptions {
+    baseUrl?: string;
+    fetchImpl?: typeof fetch;
+    providerSettingsManager?: Pick<ProviderSettingsManager, "getProviderSettings">;
+    timeoutMs?: number;
+}
+export declare const FALLBACK_CLINE_RECOMMENDED_MODELS: ClineRecommendedModelsData;
+export declare function fetchClineRecommendedModels(options?: FetchClineRecommendedModelsOptions): Promise<ClineRecommendedModelsData>;

package/dist/services/llms/configured-provider-registry.d.ts

@@ -0,0 +1,27 @@
+import type { ProviderConfig } from "./provider-settings";
+import type { BuiltInProviderSummary, CreateHandlerInput, ProviderConfigDefaults, ProviderSelectionConfig, RegisteredProviderSummary } from "./runtime-types";
+interface RegisterConfiguredProviderInput {
+    id: string;
+    models: readonly string[];
+    defaultModel?: string;
+    defaults?: ProviderConfigDefaults;
+}
+export declare function toBuiltInProviderSummary(input: {
+    collection: BuiltInProviderSummary["id"] extends string ? {
+        provider: Pick<import("@cline/llms").ProviderInfo, "id" | "name" | "description" | "protocol" | "baseUrl" | "capabilities" | "env" | "defaultModelId">;
+        models: Record<string, unknown>;
+    } : never;
+}): BuiltInProviderSummary;
+export declare class ConfiguredProviderRegistry {
+    private readonly providers;
+    register(input: RegisterConfiguredProviderInput): void;
+    registerSelectionConfig(provider: ProviderSelectionConfig): void;
+    registerModel(providerId: string, modelId: string): void;
+    createHandlerConfig(input: CreateHandlerInput): ProviderConfig;
+    list(): RegisteredProviderSummary[];
+    getModels(providerId: string): string[];
+    hasProvider(providerId: string): boolean;
+    hasModel(providerId: string, modelId: string): boolean;
+    private require;
+}
+export {};

package/dist/services/llms/handler-factory.d.ts

@@ -0,0 +1,3 @@
+import type { AgentConfig, AgentModel, BasicLogger, ITelemetryService, ModelInfo } from "@cline/shared";
+export declare function resolveKnownModelsFromConfig(config: AgentConfig): Record<string, ModelInfo> | undefined;
+export declare function createAgentModelFromConfig(config: AgentConfig, logger: BasicLogger | undefined, telemetry?: ITelemetryService): AgentModel;

package/dist/services/llms/provider-defaults.d.ts

@@ -0,0 +1,28 @@
+/** biome-ignore-all lint/style/noNonNullAssertion: static */
+import * as Llms from "@cline/llms";
+import type { ModelCatalogConfig, ModelInfo, ProviderCapability, ProviderConfig } from "./provider-settings";
+export interface BuiltInProviderManifest {
+    id: string;
+    baseUrl: string;
+    modelsSourceUrl?: string;
+    modelId: string;
+    knownModels?: Record<string, ModelInfo>;
+    capabilities?: Llms.CatalogProviderCapability[];
+    env?: readonly string[];
+    client: Llms.ProviderClient;
+    protocol?: Llms.ProviderProtocol;
+}
+export interface ProviderDefaults {
+    baseUrl?: string;
+    modelId: string;
+    knownModels?: Record<string, ModelInfo>;
+    capabilities?: ProviderCapability[];
+}
+export declare const DEFAULT_MODELS_CATALOG_URL = "https://models.dev/api.json";
+export declare function clearPublicModelsCatalogCache(): void;
+export declare function getLiveModelsCatalog(options?: Pick<ModelCatalogConfig, "url" | "cacheTtlMs">): Promise<Record<string, Record<string, ModelInfo>>>;
+export declare function clearLiveModelsCatalogCache(url?: string): void;
+export declare function clearPrivateModelsCatalogCache(): void;
+export declare const OPENAI_COMPATIBLE_PROVIDERS: Record<string, ProviderDefaults>;
+export declare function getProviderConfig(providerId: string): ProviderDefaults | undefined;
+export declare function resolveProviderConfig(providerId: string, modelCatalog?: ModelCatalogConfig, config?: ProviderConfig): Promise<ProviderDefaults | undefined>;

package/dist/services/llms/provider-settings.d.ts

@@ -0,0 +1,250 @@
+import * as Llms from "@cline/llms";
+import { z } from "zod";
+import { type ProviderDefaults } from "./provider-defaults";
+export type ModelInfo = Llms.ModelInfo;
+export type ProviderClient = Llms.ProviderClient;
+export type ProviderProtocol = Llms.ProviderProtocol;
+export type ProviderId = Llms.ProviderId;
+export type ProviderCapability = Llms.ProviderCapability;
+export type ProviderConfig = Llms.ProviderConfig;
+export type BuiltInProviderId = Llms.BuiltInProviderId;
+export declare const BUILT_IN_PROVIDER: typeof Llms.BUILT_IN_PROVIDER;
+export declare const BUILT_IN_PROVIDER_IDS: [Llms.BUILT_IN_PROVIDER, ...Llms.BUILT_IN_PROVIDER[]];
+export declare const isBuiltInProviderId: typeof Llms.isBuiltInProviderId;
+export declare const normalizeProviderId: typeof Llms.normalizeProviderId;
+export type ProviderDefaultsConfig = ProviderDefaults;
+export declare const ProviderIdSchema: z.ZodString;
+export declare const ProviderProtocolSchema: z.ZodEnum<{
+    "openai-responses": "openai-responses";
+    anthropic: "anthropic";
+    gemini: "gemini";
+    "openai-r1": "openai-r1";
+    "ai-sdk": "ai-sdk";
+    "openai-chat": "openai-chat";
+}>;
+export declare const ProviderClientSchema: z.ZodEnum<{
+    custom: "custom";
+    anthropic: "anthropic";
+    bedrock: "bedrock";
+    gemini: "gemini";
+    vertex: "vertex";
+    openai: "openai";
+    "openai-r1": "openai-r1";
+    "ai-sdk": "ai-sdk";
+    "ai-sdk-community": "ai-sdk-community";
+    "openai-compatible": "openai-compatible";
+    fetch: "fetch";
+}>;
+export declare const AuthSettingsSchema: z.ZodObject<{
+    apiKey: z.ZodOptional<z.ZodString>;
+    accessToken: z.ZodOptional<z.ZodString>;
+    refreshToken: z.ZodOptional<z.ZodString>;
+    expiresAt: z.ZodOptional<z.ZodNumber>;
+    accountId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type AuthSettings = z.infer<typeof AuthSettingsSchema>;
+export declare const ReasoningSettingsSchema: z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    effort: z.ZodOptional<z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+        xhigh: "xhigh";
+        none: "none";
+    }>>;
+    budgetTokens: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type ReasoningSettings = z.infer<typeof ReasoningSettingsSchema>;
+export declare const AwsSettingsSchema: z.ZodObject<{
+    accessKey: z.ZodOptional<z.ZodString>;
+    secretKey: z.ZodOptional<z.ZodString>;
+    sessionToken: z.ZodOptional<z.ZodString>;
+    region: z.ZodOptional<z.ZodString>;
+    profile: z.ZodOptional<z.ZodString>;
+    authentication: z.ZodOptional<z.ZodEnum<{
+        "api-key": "api-key";
+        profile: "profile";
+        iam: "iam";
+        apikey: "apikey";
+    }>>;
+    usePromptCache: z.ZodOptional<z.ZodBoolean>;
+    useCrossRegionInference: z.ZodOptional<z.ZodBoolean>;
+    useGlobalInference: z.ZodOptional<z.ZodBoolean>;
+    endpoint: z.ZodOptional<z.ZodString>;
+    customModelBaseId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type AwsSettings = z.infer<typeof AwsSettingsSchema>;
+export declare const GcpSettingsSchema: z.ZodObject<{
+    projectId: z.ZodOptional<z.ZodString>;
+    region: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type GcpSettings = z.infer<typeof GcpSettingsSchema>;
+export declare const AzureSettingsSchema: z.ZodObject<{
+    apiVersion: z.ZodOptional<z.ZodString>;
+    useIdentity: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type AzureSettings = z.infer<typeof AzureSettingsSchema>;
+export declare const SapSettingsSchema: z.ZodObject<{
+    clientId: z.ZodOptional<z.ZodString>;
+    clientSecret: z.ZodOptional<z.ZodString>;
+    tokenUrl: z.ZodOptional<z.ZodString>;
+    resourceGroup: z.ZodOptional<z.ZodString>;
+    deploymentId: z.ZodOptional<z.ZodString>;
+    useOrchestrationMode: z.ZodOptional<z.ZodBoolean>;
+    api: z.ZodOptional<z.ZodEnum<{
+        orchestration: "orchestration";
+        "foundation-models": "foundation-models";
+    }>>;
+    defaultSettings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type SapSettings = z.infer<typeof SapSettingsSchema>;
+export declare const OcaSettingsSchema: z.ZodObject<{
+    mode: z.ZodOptional<z.ZodEnum<{
+        internal: "internal";
+        external: "external";
+    }>>;
+    usePromptCache: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type OcaSettings = z.infer<typeof OcaSettingsSchema>;
+export declare const ModelCatalogSettingsSchema: z.ZodObject<{
+    loadLatestOnInit: z.ZodOptional<z.ZodBoolean>;
+    loadPrivateOnAuth: z.ZodOptional<z.ZodBoolean>;
+    url: z.ZodOptional<z.ZodString>;
+    cacheTtlMs: z.ZodOptional<z.ZodNumber>;
+    failOnError: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type ModelCatalogSettings = z.infer<typeof ModelCatalogSettingsSchema>;
+export type ModelCatalogConfig = ModelCatalogSettings;
+export declare const ProviderSettingsSchema: z.ZodObject<{
+    provider: z.ZodString;
+    apiKey: z.ZodOptional<z.ZodString>;
+    auth: z.ZodOptional<z.ZodObject<{
+        apiKey: z.ZodOptional<z.ZodString>;
+        accessToken: z.ZodOptional<z.ZodString>;
+        refreshToken: z.ZodOptional<z.ZodString>;
+        expiresAt: z.ZodOptional<z.ZodNumber>;
+        accountId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    model: z.ZodOptional<z.ZodString>;
+    protocol: z.ZodOptional<z.ZodEnum<{
+        "openai-responses": "openai-responses";
+        anthropic: "anthropic";
+        gemini: "gemini";
+        "openai-r1": "openai-r1";
+        "ai-sdk": "ai-sdk";
+        "openai-chat": "openai-chat";
+    }>>;
+    client: z.ZodOptional<z.ZodEnum<{
+        custom: "custom";
+        anthropic: "anthropic";
+        bedrock: "bedrock";
+        gemini: "gemini";
+        vertex: "vertex";
+        openai: "openai";
+        "openai-r1": "openai-r1";
+        "ai-sdk": "ai-sdk";
+        "ai-sdk-community": "ai-sdk-community";
+        "openai-compatible": "openai-compatible";
+        fetch: "fetch";
+    }>>;
+    routingProviderId: z.ZodOptional<z.ZodString>;
+    maxTokens: z.ZodOptional<z.ZodNumber>;
+    contextWindow: z.ZodOptional<z.ZodNumber>;
+    baseUrl: z.ZodOptional<z.ZodString>;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    timeout: z.ZodOptional<z.ZodNumber>;
+    reasoning: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        effort: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            xhigh: "xhigh";
+            none: "none";
+        }>>;
+        budgetTokens: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    aws: z.ZodOptional<z.ZodObject<{
+        accessKey: z.ZodOptional<z.ZodString>;
+        secretKey: z.ZodOptional<z.ZodString>;
+        sessionToken: z.ZodOptional<z.ZodString>;
+        region: z.ZodOptional<z.ZodString>;
+        profile: z.ZodOptional<z.ZodString>;
+        authentication: z.ZodOptional<z.ZodEnum<{
+            "api-key": "api-key";
+            profile: "profile";
+            iam: "iam";
+            apikey: "apikey";
+        }>>;
+        usePromptCache: z.ZodOptional<z.ZodBoolean>;
+        useCrossRegionInference: z.ZodOptional<z.ZodBoolean>;
+        useGlobalInference: z.ZodOptional<z.ZodBoolean>;
+        endpoint: z.ZodOptional<z.ZodString>;
+        customModelBaseId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    gcp: z.ZodOptional<z.ZodObject<{
+        projectId: z.ZodOptional<z.ZodString>;
+        region: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    azure: z.ZodOptional<z.ZodObject<{
+        apiVersion: z.ZodOptional<z.ZodString>;
+        useIdentity: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    sap: z.ZodOptional<z.ZodObject<{
+        clientId: z.ZodOptional<z.ZodString>;
+        clientSecret: z.ZodOptional<z.ZodString>;
+        tokenUrl: z.ZodOptional<z.ZodString>;
+        resourceGroup: z.ZodOptional<z.ZodString>;
+        deploymentId: z.ZodOptional<z.ZodString>;
+        useOrchestrationMode: z.ZodOptional<z.ZodBoolean>;
+        api: z.ZodOptional<z.ZodEnum<{
+            orchestration: "orchestration";
+            "foundation-models": "foundation-models";
+        }>>;
+        defaultSettings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>;
+    oca: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodOptional<z.ZodEnum<{
+            internal: "internal";
+            external: "external";
+        }>>;
+        usePromptCache: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    region: z.ZodOptional<z.ZodString>;
+    apiLine: z.ZodOptional<z.ZodEnum<{
+        china: "china";
+        international: "international";
+    }>>;
+    capabilities: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        tools: "tools";
+        reasoning: "reasoning";
+        streaming: "streaming";
+        "prompt-cache": "prompt-cache";
+        "computer-use": "computer-use";
+        oauth: "oauth";
+        vision: "vision";
+        popular: "popular";
+    }>>>;
+    modelCatalog: z.ZodOptional<z.ZodObject<{
+        loadLatestOnInit: z.ZodOptional<z.ZodBoolean>;
+        loadPrivateOnAuth: z.ZodOptional<z.ZodBoolean>;
+        url: z.ZodOptional<z.ZodString>;
+        cacheTtlMs: z.ZodOptional<z.ZodNumber>;
+        failOnError: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ProviderSettings = z.infer<typeof ProviderSettingsSchema>;
+export interface ToProviderConfigOptions {
+    includeKnownModels?: boolean;
+}
+export declare function parseSettings(input: unknown): ProviderSettings;
+export declare function safeParseSettings(input: unknown): ReturnType<typeof ProviderSettingsSchema.safeParse>;
+export declare function toProviderConfig(settings: ProviderSettings, options?: ToProviderConfigOptions): ProviderConfig;
+export declare function createProviderConfig(input: unknown): ProviderConfig;
+export declare function safeCreateProviderConfig(input: unknown): {
+    success: true;
+    config: ProviderConfig;
+} | {
+    success: false;
+    error: z.ZodError;
+};

package/dist/services/llms/runtime-config.d.ts

@@ -0,0 +1,3 @@
+import type { LlmsConfig } from "./runtime-types";
+export declare function defineLlmsConfig(config: LlmsConfig): LlmsConfig;
+export declare function loadLlmsConfigFromFile(configPath: string): Promise<LlmsConfig>;

package/dist/services/llms/runtime-registry.d.ts

@@ -0,0 +1,19 @@
+import type { ApiHandler } from "@cline/llms";
+import type { BuiltInProviderSummary, CreateHandlerInput, LlmsConfig, LlmsSdk, RegisterBuiltinProviderInput, RegisteredProviderSummary, RegisterModelInput, RegisterProviderInput } from "./runtime-types";
+export declare class DefaultLlmsSdk implements LlmsSdk {
+    private readonly configuredProviders;
+    constructor(config: LlmsConfig);
+    createHandler(input: CreateHandlerInput): ApiHandler;
+    createHandlerAsync(input: CreateHandlerInput): Promise<ApiHandler>;
+    registerProvider(input: RegisterProviderInput): void;
+    registerBuiltinProvider(input: RegisterBuiltinProviderInput): void;
+    registerModel(input: RegisterModelInput): void;
+    getProviders(): RegisteredProviderSummary[];
+    getBuiltInProviderIds(): import("@cline/llms").BUILT_IN_PROVIDER[];
+    getBuiltInProviders(): Promise<BuiltInProviderSummary[]>;
+    getModels(providerId: string): string[];
+    isProviderConfigured(providerId: string): boolean;
+    isModelConfigured(providerId: string, modelId: string): boolean;
+    private applyConfig;
+}
+export declare function createLlmsSdk(config: LlmsConfig): LlmsSdk;

package/dist/services/llms/runtime-types.d.ts

@@ -0,0 +1,84 @@
+import type { ApiHandler, BuiltInProviderId, HandlerFactory, LazyHandlerFactory, ModelCollection, ModelInfo, CatalogProviderCapability as ModelProviderCapability, ProviderClient, ProviderConfig, ProviderInfo, ProviderProtocol } from "@cline/llms";
+import type { ProviderCapability } from "./provider-settings";
+export type ProviderConfigDefaults = Omit<ProviderConfig, "providerId" | "modelId">;
+export interface ProviderSelectionConfig {
+    id: string;
+    models: string[];
+    defaultModel?: string;
+    builtinProviderId?: BuiltInProviderId;
+    apiKey?: string;
+    apiKeyEnv?: string;
+    baseUrl?: string;
+    headers?: Record<string, string>;
+    timeoutMs?: number;
+    capabilities?: ProviderCapability[];
+    settings?: ProviderConfigDefaults;
+}
+export interface AdditionalModelConfig {
+    providerId: string;
+    modelId: string;
+    info: ModelInfo;
+}
+export interface CustomProviderConfig {
+    collection: ModelCollection;
+    defaults?: ProviderConfigDefaults;
+    handlerFactory?: HandlerFactory;
+    asyncHandlerFactory?: LazyHandlerFactory;
+}
+export interface LlmsConfig {
+    providers: ProviderSelectionConfig[];
+    models?: AdditionalModelConfig[];
+    customProviders?: CustomProviderConfig[];
+}
+export interface CreateHandlerInput {
+    providerId: string;
+    modelId?: string;
+    overrides?: ProviderConfigDefaults;
+}
+export interface RegisteredProviderSummary {
+    id: string;
+    models: string[];
+    defaultModel: string;
+}
+export interface BuiltInProviderSummary extends Pick<ProviderInfo, "id" | "name" | "description" | "protocol" | "baseUrl" | "capabilities" | "env"> {
+    models: string[];
+    defaultModel: string;
+    modelCount: number;
+}
+export interface RegisterBuiltinProviderInput {
+    id: string;
+    builtinProviderId: BuiltInProviderId;
+    models: Record<string, ModelInfo>;
+    name?: string;
+    description?: string;
+    protocol?: ProviderProtocol;
+    baseUrl?: string;
+    client?: ProviderClient;
+    capabilities?: ModelProviderCapability[];
+    env?: string[];
+    defaultModel?: string;
+    defaults?: ProviderConfigDefaults;
+    exposeModels?: string[];
+}
+export interface RegisterProviderInput extends CustomProviderConfig {
+    exposeModels?: string[];
+    defaultModel?: string;
+}
+export interface RegisterModelInput {
+    providerId: string;
+    modelId: string;
+    info: ModelInfo;
+}
+export interface LlmsSdk {
+    createHandler(input: CreateHandlerInput): ApiHandler;
+    createHandlerAsync(input: CreateHandlerInput): Promise<ApiHandler>;
+    registerProvider(input: RegisterProviderInput): void;
+    registerBuiltinProvider(input: RegisterBuiltinProviderInput): void;
+    registerModel(input: RegisterModelInput): void;
+    getProviders(): RegisteredProviderSummary[];
+    getBuiltInProviderIds(): BuiltInProviderId[];
+    getBuiltInProviders(): Promise<BuiltInProviderSummary[]>;
+    getModels(providerId: string): string[];
+    isProviderConfigured(providerId: string): boolean;
+    isModelConfigured(providerId: string, modelId: string): boolean;
+}

package/dist/services/local-runtime-bootstrap.d.ts

@@ -0,0 +1,45 @@
+import type { AgentConfig, AgentHooks, AgentTool, ITelemetryService, ToolApprovalRequest, ToolApprovalResult, WorkspaceInfo } from "@cline/shared";
+import type { TeamEvent } from "../extensions/tools/team";
+import type { RuntimeCapabilities } from "../runtime/capabilities";
+import type { LocalRuntimeStartOptions, StartSessionInput } from "../runtime/host/runtime-host";
+import type { RuntimeBuilderInput } from "../runtime/orchestration/session-runtime";
+import type { CoreSessionConfig } from "../types/config";
+import { type ProviderConfig } from "../types/provider-settings";
+import type { ProviderSettingsManager } from "./storage/provider-settings-manager";
+export interface PrepareLocalRuntimeBootstrapOptions {
+    input: StartSessionInput;
+    localRuntime?: LocalRuntimeStartOptions;
+    sessionId: string;
+    providerSettingsManager: ProviderSettingsManager;
+    defaultTelemetry?: ITelemetryService;
+    defaultCapabilities?: RuntimeCapabilities;
+    defaultToolPolicies?: AgentConfig["toolPolicies"];
+    /**
+     * Host-level default `fetch` threaded into `ProviderConfig.fetch` so the
+     * AI gateway providers can use a custom HTTP implementation.
+     */
+    defaultFetch?: typeof fetch;
+    onPluginEvent: (event: {
+        name: string;
+        payload?: unknown;
+    }) => void;
+    onTeamEvent: (event: TeamEvent) => void;
+    createSpawnTool: () => AgentTool;
+    readSessionMetadata: () => Promise<Record<string, unknown> | undefined>;
+    writeSessionMetadata: (metadata: Record<string, unknown>) => Promise<void> | void;
+}
+export interface LocalRuntimeBootstrap {
+    effectiveInput: StartSessionInput;
+    config: CoreSessionConfig;
+    providerConfig: ProviderConfig;
+    workspaceMetadata: string;
+    /** Structured git + path metadata generated alongside workspaceMetadata. */
+    workspaceInfo: WorkspaceInfo;
+    extensions: AgentConfig["extensions"];
+    hooks: AgentHooks | undefined;
+    toolPolicies: AgentConfig["toolPolicies"];
+    requestToolApproval?: (request: ToolApprovalRequest) => Promise<ToolApprovalResult> | ToolApprovalResult;
+    pluginSandboxShutdown?: () => Promise<void>;
+    runtimeBuilderInput: RuntimeBuilderInput;
+}
+export declare function prepareLocalRuntimeBootstrap(options: PrepareLocalRuntimeBootstrapOptions): Promise<LocalRuntimeBootstrap>;

package/dist/services/plugin-tools.d.ts

@@ -0,0 +1,28 @@
+import type { PluginInitializationFailure, PluginInitializationWarning } from "../extensions/plugin/plugin-load-report";
+export interface PluginToolSummary {
+    name: string;
+    pluginName: string;
+    path: string;
+    source: "workspace-plugin" | "global-plugin";
+    enabled: boolean;
+    description?: string;
+}
+export interface ListPluginToolsResult {
+    tools: PluginToolSummary[];
+    failures: PluginInitializationFailure[];
+    warnings: PluginInitializationWarning[];
+}
+export declare function listPluginToolsWithDiagnostics(input: {
+    workspacePath: string;
+    cwd?: string;
+    disabledToolNames?: ReadonlyArray<string>;
+    providerId?: string;
+    modelId?: string;
+}): Promise<ListPluginToolsResult>;
+export declare function listPluginTools(input: {
+    workspacePath: string;
+    cwd?: string;
+    disabledToolNames?: ReadonlyArray<string>;
+    providerId?: string;
+    modelId?: string;
+}): Promise<PluginToolSummary[]>;