@openagentpack/sdk 0.0.2-beta.0

package/dist/index.d.ts

@@ -0,0 +1,1145 @@
+import { R as ResourceAddress, a as ResourceType, C as CloudAgent, b as CloudEnvironment, c as CloudVault, E as EventStreamOptions, P as ProviderSessionEvent, d as EventListOptions, e as ProviderSessionEventList, f as PlannedAction, D as Diagnostic, A as AgentDefinition, g as AgentWithReadiness, h as AgentSyncRun } from './session-event-CmiO8Gqv.js';
+export { i as ActionType, j as ActionTypeSchema, k as AgentDefinitionSchema, l as AgentDriftSeverity, m as AgentDriftSeveritySchema, n as AgentModel, o as AgentModelSchema, p as AgentReadiness, q as AgentReadinessSchema, r as AgentReadinessStatus, s as AgentReadinessStatusSchema, t as AgentRecoveryAction, u as AgentRecoveryActionSchema, v as AgentSkillRef, w as AgentSkillRefSchema, x as AgentSyncResult, y as AgentSyncResultSchema, z as AgentSyncRunSchema, B as AgentSyncStatus, F as AgentSyncStatusSchema, G as AgentWithReadinessSchema, H as CloudAgentSchema, I as CloudEnvironmentSchema, J as CloudVaultSchema, K as CreateSessionRequest, L as CreateSessionRequestSchema, M as CreateSessionResponse, N as CreateSessionResponseSchema, O as DiagnosticSchema, Q as DiagnosticSeverity, S as DiagnosticSeveritySchema, T as DriftKind, U as DriftKindSchema, V as GetSessionRequest, W as GetSessionRequestSchema, X as KNOWN_SESSION_EVENT_TYPES, Y as KnownSessionEventType, Z as ListCloudAgentsResponse, _ as ListCloudAgentsResponseSchema, $ as ListCloudEnvironmentsResponse, a0 as ListCloudEnvironmentsResponseSchema, a1 as ListSessionEventsRequest, a2 as ListSessionEventsRequestSchema, a3 as ListSessionEventsResponse, a4 as ListSessionEventsResponseSchema, a5 as ListSessionsRequest, a6 as ListSessionsRequestSchema, a7 as ListSessionsResponse, a8 as ListSessionsResponseSchema, a9 as PlannedActionSchema, aa as ResourceAddressSchema, ab as ResourceTypeSchema, ac as SendEventRequest, ad as SendEventRequestSchema, ae as SendEventResponse, af as SendEventResponseSchema, ag as Session, ah as SessionAgent, ai as SessionAgentSchema, aj as SessionContentBlock, ak as SessionContentBlockSchema, al as SessionEvent, am as SessionEventSchema, an as SessionEventType, ao as SessionEventTypeName, ap as SessionEventTypeSchema, aq as SessionSchema } from './session-event-CmiO8Gqv.js';
+import { P as ProviderFileInfo } from './file-URqwlxLf.js';
+import 'zod';
+
+declare class UserError extends Error {
+    constructor(message: string);
+}
+
+type ProviderName = string;
+interface ProjectConfig {
+    version: string;
+    providers: Record<string, unknown>;
+    defaults?: DefaultsConfig;
+    environments?: Record<string, EnvironmentDecl>;
+    vaults?: Record<string, VaultDecl>;
+    memory_stores?: Record<string, MemoryStoreDecl>;
+    skills?: Record<string, SkillDecl>;
+    files?: Record<string, FileDecl>;
+    agents?: Record<string, AgentDecl>;
+    deployments?: Record<string, DeploymentDecl>;
+}
+interface DefaultsConfig {
+    provider?: string;
+}
+interface EnvironmentDecl {
+    name?: string;
+    description?: string;
+    provider?: ProviderName;
+    config: EnvironmentConfig;
+    metadata?: Record<string, string>;
+}
+interface EnvironmentConfig {
+    type: "cloud";
+    networking?: NetworkingConfig;
+    packages?: PackagesConfig;
+}
+interface NetworkingConfig {
+    type: "unrestricted" | "limited";
+    allow_mcp_servers?: boolean;
+    allow_package_managers?: boolean;
+    allowed_hosts?: string[];
+}
+interface PackagesConfig {
+    apt?: string[];
+    pip?: string[];
+    npm?: string[];
+    cargo?: string[];
+    gem?: string[];
+    go?: string[];
+}
+interface VaultDecl {
+    display_name: string;
+    provider?: ProviderName;
+    credentials: CredentialDecl[];
+    metadata?: Record<string, string>;
+}
+type CredentialType = "static_bearer" | "environment_variable";
+interface CredentialDecl {
+    name: string;
+    type: CredentialType;
+    mcp_server_url?: string;
+    access_token?: string;
+    protocol?: "sse" | "streamable_http";
+    secret_name?: string;
+    secret_value?: string;
+    networking?: {
+        type: "unrestricted" | "limited";
+    };
+}
+interface MemoryStoreDecl {
+    description: string;
+    provider?: ProviderName;
+    entries?: MemoryEntryDecl[];
+}
+interface MemoryEntryDecl {
+    key: string;
+    content: string;
+}
+interface SkillDecl {
+    name?: string;
+    source: string;
+    description?: string;
+    version?: string;
+    origin?: "custom" | "official";
+    provider?: ProviderName;
+}
+interface FileDecl {
+    source: string;
+    name?: string;
+    purpose?: string;
+    provider?: ProviderName;
+}
+interface ModelWithSpeed {
+    id: string;
+    speed?: "standard" | "fast";
+}
+type ModelSpec = string | ModelWithSpeed;
+interface AgentDecl {
+    name?: string;
+    description?: string;
+    model: string | Record<ProviderName, ModelSpec>;
+    instructions: string;
+    environment?: string;
+    provider?: ProviderName;
+    tools?: AgentToolsDecl;
+    mcp_servers?: McpServerDecl[];
+    skills?: AgentSkillDecl[];
+    vault?: string;
+    memory_stores?: string[];
+    multiagent?: MultiagentDecl;
+    metadata?: Record<string, string>;
+}
+type AgentSkillDecl = string | AgentSkillRefDecl;
+interface AgentSkillRefDecl {
+    type: "official" | "custom";
+    skill_id: string;
+    version?: string;
+}
+interface AgentToolsDecl {
+    builtin: string[];
+    mcp?: AgentMcpToolkitDecl[];
+    permissions?: Record<string, "allow" | "ask">;
+}
+interface AgentMcpToolkitDecl {
+    type: "mcp_toolkit";
+    mcp_server_name: string;
+    default_config?: {
+        enabled: boolean;
+    };
+    configs: Array<{
+        name: string;
+        enabled: boolean;
+    }>;
+}
+interface McpServerDecl {
+    name: string;
+    type?: "url" | "http" | "official";
+    url?: string;
+}
+interface MultiagentDecl {
+    type: "coordinator";
+    agents: string[];
+}
+interface DeploymentDecl {
+    agent: string;
+    agent_version?: number;
+    environment?: string;
+    vaults?: string[];
+    memory_stores?: string[];
+    resources?: DeploymentResourceDecl[];
+    initial_events: InitialEventDecl[];
+    schedule?: ScheduleDecl;
+    description?: string;
+    provider?: ProviderName;
+    metadata?: Record<string, string>;
+}
+type DeploymentResourceDecl = DeploymentFileResource | DeploymentMemoryStoreResource | DeploymentGithubRepoResource;
+interface DeploymentFileResource {
+    type: "file";
+    file_id?: string;
+    source?: string;
+    mount_path?: string;
+}
+interface DeploymentMemoryStoreResource {
+    type: "memory_store";
+    memory_store: string;
+    access?: "read_write" | "read_only";
+    instructions?: string;
+}
+interface DeploymentGithubRepoResource {
+    type: "github_repository";
+    url: string;
+    checkout?: {
+        branch?: string;
+        commit?: string;
+    };
+    mount_path?: string;
+    authorization_token?: string;
+}
+type InitialEventDecl = InitialUserMessage | InitialSystemMessage | InitialDefineOutcome;
+interface InitialUserMessage {
+    type: "user.message";
+    content: string;
+}
+interface InitialSystemMessage {
+    type: "system.message";
+    content: string;
+}
+interface InitialDefineOutcome {
+    type: "user.define_outcome";
+    description?: string;
+    rubric?: string;
+    rubric_file?: string;
+    max_iterations?: number;
+}
+interface ScheduleDecl {
+    expression: string;
+    timezone: string;
+}
+/**
+ * A ProjectConfig where all file references (instructions, memory entries)
+ * have been resolved to their inline content.
+ */
+interface ResolvedProjectConfig extends ProjectConfig {
+    _resolved: true;
+}
+
+interface SessionFileResource {
+    file_id: string;
+    mount_path: string;
+}
+interface SessionBindings {
+    agent_id: string;
+    agent_version?: number;
+    /** Cloud sandbox id. Every provider runs sessions inside an environment. */
+    environment_id: string;
+    vault_ids: string[];
+    memory_store_ids: string[];
+    files?: SessionFileResource[];
+    title?: string;
+    metadata?: Record<string, string>;
+}
+interface ProviderSessionInfo {
+    id: string;
+    agent_id: string;
+    environment_id: string;
+    status: string;
+    title?: string;
+    vault_ids: string[];
+    memory_store_ids: string[];
+    created_at: string;
+    updated_at: string;
+    attributes: Record<string, unknown>;
+}
+interface SessionFilter {
+    agent_id?: string;
+    limit?: number;
+    page?: string;
+}
+interface SessionListResult {
+    sessions: ProviderSessionInfo[];
+    has_more: boolean;
+    next_page?: string;
+}
+
+interface SkillFile {
+    relativePath: string;
+    content: Buffer;
+}
+
+interface ProviderSkillInfo {
+    id: string;
+    name: string;
+    description?: string;
+    source: "custom" | "official";
+    status: "checking" | "active" | "rejected" | "deleted";
+    latest_version?: string;
+    created_at?: string;
+    updated_at?: string;
+}
+
+interface ResourceState {
+    address: ResourceAddress;
+    remote_id: string | null;
+    version?: number;
+    /**
+     * Backward-compatible alias for desired_hash. Kept while older state files
+     * and callers still read/write content_hash directly.
+     */
+    content_hash: string;
+    desired_hash?: string;
+    desired_comparable_hash?: string;
+    remote_hash?: string;
+    remote_snapshot?: unknown;
+    drift_status?: "in_sync" | "drifted" | "missing" | "unchecked";
+}
+interface StateFile {
+    resources: ResourceState[];
+}
+
+interface RemoteResource {
+    id: string | null;
+    type: string;
+    version?: number;
+}
+interface ModelInfo {
+    id: string;
+    display_name: string;
+    source: string;
+    is_enabled: boolean;
+    is_new: boolean;
+    price_factor?: number;
+    efforts?: string[];
+    default_effort?: string;
+}
+type DriftSupport = "full" | "existence" | "unsupported";
+interface ComparableRemoteResource {
+    id: string | null;
+    type: string;
+    version?: number;
+    comparable: unknown;
+    snapshot?: unknown;
+}
+/**
+ * A remote resource reverse-mapped into a `agents.yaml` declaration, ready to be
+ * serialized under the matching top-level group (e.g. `vaults.<name>`).
+ * `name` is the yaml key; `decl` matches the corresponding zod schema shape.
+ */
+interface ExportedResource {
+    name: string;
+    decl: Record<string, unknown>;
+}
+interface ResolvedAgentRefs {
+    skill_ids: Array<{
+        type: string;
+        skill_id: string;
+        version?: string;
+    }>;
+    multiagent_agent_ids?: string[];
+}
+interface ResolvedDeploymentRefs {
+    agent_id: string;
+    agent_version?: number;
+    environment_id: string;
+    vault_ids: string[];
+    memory_store_ids: Record<string, string>;
+}
+interface DeploymentContext {
+    id: string | null;
+    name: string;
+    decl: DeploymentDecl;
+    refs: ResolvedDeploymentRefs;
+    basePath: string;
+}
+interface DeploymentRunResult$1 {
+    run_id?: string;
+    session_id: string | null;
+    error?: {
+        type: string;
+        message: string;
+    };
+}
+interface DeploymentInfo$1 {
+    id: string | null;
+    status: string;
+    paused_reason?: {
+        type: string;
+        error?: {
+            type: string;
+        };
+    };
+    schedule?: {
+        expression: string;
+        timezone?: string;
+    };
+    attributes?: Record<string, unknown>;
+}
+interface ProviderAdapter {
+    readonly name: string;
+    /**
+     * Whether `sendSessionMessage` returns an event-id cursor the stream/poll can
+     * resume after. true → send-then-stream with `afterId`; false → connect-before-send.
+     */
+    readonly eventResume: boolean;
+    validate(): Promise<void>;
+    /**
+     * Locate a remote resource. When `id` is provided, the resource is verified
+     * precisely via its detail endpoint (`GET /{endpoint}/{id}`), which avoids the
+     * ambiguity of name matching when names are not unique. Without `id`, falls
+     * back to listing and matching by `name` (used by conflict adoption).
+     */
+    findResource(type: ResourceType, name: string, id?: string | null): Promise<RemoteResource | null>;
+    listAgents?(filter?: {
+        prefix?: string;
+        limit?: number;
+    }): Promise<CloudAgent[]>;
+    listEnvironments?(filter?: {
+        limit?: number;
+    }): Promise<CloudEnvironment[]>;
+    listVaults?(filter?: {
+        limit?: number;
+    }): Promise<CloudVault[]>;
+    getDriftSupport?(type: ResourceType): DriftSupport;
+    readComparableResource?(type: ResourceType, id: string | null, name: string): Promise<ComparableRemoteResource | null>;
+    normalizeDesiredResource?(type: ResourceType, name: string, decl: unknown): unknown | null;
+    /**
+     * Reverse-map remote resources of a given type into `agents.yaml` declarations
+     * (used by `agents sync`). Returns an empty array for unsupported types. Secret
+     * values that the provider does not return are emitted as `${ENV}` placeholders.
+     */
+    exportResources?(type: ResourceType): Promise<ExportedResource[]>;
+    createEnvironment(name: string, decl: EnvironmentDecl): Promise<RemoteResource>;
+    updateEnvironment(id: string, name: string, decl: EnvironmentDecl): Promise<RemoteResource>;
+    deleteEnvironment(id: string, cascade?: boolean): Promise<void>;
+    createVault(name: string, decl: VaultDecl): Promise<RemoteResource>;
+    deleteVault(id: string): Promise<void>;
+    createSkill(name: string, decl: SkillDecl, files: SkillFile[]): Promise<RemoteResource>;
+    updateSkill(id: string, name: string, decl: SkillDecl, files: SkillFile[]): Promise<RemoteResource>;
+    deleteSkill(id: string): Promise<void>;
+    createAgent(name: string, decl: AgentDecl, refs: ResolvedAgentRefs): Promise<RemoteResource>;
+    updateAgent(id: string, name: string, decl: AgentDecl, refs: ResolvedAgentRefs): Promise<RemoteResource>;
+    deleteAgent(id: string): Promise<void>;
+    createMemoryStore?(name: string, decl: MemoryStoreDecl): Promise<RemoteResource>;
+    deleteMemoryStore?(id: string): Promise<void>;
+    createDeployment(name: string, decl: DeploymentDecl, refs: ResolvedDeploymentRefs, basePath: string): Promise<RemoteResource>;
+    updateDeployment(id: string, name: string, decl: DeploymentDecl, refs: ResolvedDeploymentRefs, basePath: string): Promise<RemoteResource>;
+    deleteDeployment(id: string): Promise<void>;
+    runDeployment(ctx: DeploymentContext): Promise<DeploymentRunResult$1>;
+    getDeployment(ctx: DeploymentContext): Promise<DeploymentInfo$1>;
+    uploadFile(filePath: string, options?: {
+        name?: string;
+        purpose?: string;
+    }): Promise<ProviderFileInfo>;
+    /** Upload from in-memory content (no filesystem), for server contexts that receive bytes directly (e.g. webui browser uploads). */
+    uploadFileContent(content: Uint8Array, filename: string, options?: {
+        mimeType?: string;
+        purpose?: string;
+    }): Promise<ProviderFileInfo>;
+    deleteFile(id: string): Promise<void>;
+    /** Fetch a single file's metadata (incl. scan `status`); used to gate session binding on availability. */
+    getFileInfo?(id: string): Promise<ProviderFileInfo>;
+    /**
+     * Resolve a short-lived presigned download URL for a file (e.g. an agent-delivered artifact).
+     * Optional — only providers with a content/download endpoint implement it (qoder GET
+     * /files/{id}/content). Callers fetch it on demand so the URL never goes stale in the UI.
+     */
+    getFileDownloadUrl?(id: string): Promise<{
+        url: string;
+        expires_at?: string;
+    }>;
+    /** List workspace user-uploaded files (newest first). Optional — only providers with a list API implement it. */
+    listFiles?(): Promise<ProviderFileInfo[]>;
+    /**
+     * List skills (newest first). `source` selects the catalog: "custom" (workspace-uploaded, the
+     * default) or "official" (the provider's built-in catalog). Optional — only providers with a
+     * list API implement it.
+     */
+    listSkills?(source?: "custom" | "official"): Promise<ProviderSkillInfo[]>;
+    /** Fetch a single skill's metadata (incl. scan `status`); used to poll create → active. */
+    getSkillInfo?(id: string): Promise<ProviderSkillInfo>;
+    /**
+     * Create a skill from an already-uploaded zip's file_id and return immediately with the
+     * initial (usually `checking`) status. NON-blocking — unlike `createSkill`, it does NOT wait
+     * for the security scan. The webui polls `getSkillInfo` until `active`.
+     */
+    createSkillFromFileId?(fileId: string): Promise<ProviderSkillInfo>;
+    createSession(bindings: SessionBindings): Promise<ProviderSessionInfo>;
+    listSessions(filter?: SessionFilter): Promise<SessionListResult>;
+    getSession(id: string): Promise<ProviderSessionInfo>;
+    deleteSession(id: string): Promise<void>;
+    sendSessionMessage(sessionId: string, message: string): Promise<string | undefined>;
+    streamSessionEvents(sessionId: string, options?: EventStreamOptions): AsyncIterable<ProviderSessionEvent>;
+    listSessionEvents(sessionId: string, options?: EventListOptions): Promise<ProviderSessionEventList>;
+    listModels?(): Promise<ModelInfo[]>;
+    /**
+     * Download all remote skills and return their extracted file content.
+     * Used by `agents sync` to materialize skill sources locally.
+     * Returns a map of skill name → extracted SkillFile[].
+     */
+    downloadAllSkillFiles?(): Promise<Map<string, SkillFile[]>>;
+}
+
+interface IStateManager {
+    getResource(address: ResourceAddress): ResourceState | undefined;
+    setResource(resource: ResourceState): void;
+    removeResource(address: ResourceAddress): void;
+    listResources(): ResourceState[];
+    findResource(query: {
+        type: string;
+        name: string;
+        provider?: string;
+    }): ResourceState | undefined;
+    getStateFile(): StateFile;
+    save(): Promise<void>;
+}
+declare class StateManager implements IStateManager {
+    private state;
+    private path;
+    private index;
+    private constructor();
+    private buildIndex;
+    static load(path: string): Promise<StateManager>;
+    static initialize(path: string): StateManager;
+    getResource(address: ResourceAddress): ResourceState | undefined;
+    setResource(resource: ResourceState): void;
+    removeResource(address: ResourceAddress): void;
+    listResources(): ResourceState[];
+    findResource(query: {
+        type: string;
+        name: string;
+        provider?: string;
+    }): ResourceState | undefined;
+    getStateFile(): StateFile;
+    save(): Promise<void>;
+}
+
+interface StateScope {
+    projectId: string;
+}
+interface StateBackend {
+    read<T>(scope: StateScope, fn: (state: IStateManager) => Promise<T> | T): Promise<T>;
+    write<T>(scope: StateScope, fn: (state: IStateManager) => Promise<T> | T): Promise<T>;
+}
+
+interface ProjectRuntimeContext {
+    configPath?: string;
+    statePath?: string;
+    projectName: string;
+    config: ResolvedProjectConfig;
+    state: IStateManager;
+    providers: Map<string, ProviderAdapter>;
+}
+interface CreateRuntimeInput {
+    projectName: string;
+    config: ResolvedProjectConfig;
+    state: IStateManager;
+    configPath?: string;
+    providers?: Record<string, unknown>;
+}
+interface BackendRuntimeInput {
+    projectName: string;
+    config: ResolvedProjectConfig;
+    stateBackend: StateBackend;
+    stateScope: StateScope;
+    configPath?: string;
+    providers?: Record<string, unknown>;
+}
+/**
+ * Context-first entry point: create a ProjectRuntimeContext from pre-resolved objects.
+ * No file I/O is performed — the caller is responsible for loading and resolving config.
+ */
+declare function createProjectRuntime(input: CreateRuntimeInput): ProjectRuntimeContext;
+declare function readProjectRuntime<T>(input: BackendRuntimeInput, fn: (ctx: ProjectRuntimeContext) => Promise<T> | T): Promise<T>;
+declare function writeProjectRuntime<T>(input: BackendRuntimeInput, fn: (ctx: ProjectRuntimeContext) => Promise<T> | T): Promise<T>;
+
+interface ResolveProjectConfigOptions {
+    /** Override the derived project name (defaults to the config file's parent directory). */
+    projectName?: string;
+    /** Expand `${env:...}` references while loading (defaults to true). */
+    resolveEnv?: boolean;
+}
+interface LoadedProjectConfig {
+    configPath: string;
+    projectName: string;
+    config: ResolvedProjectConfig;
+}
+/**
+ * Shared config-resolution spine for every host: load the config file, raise
+ * configuration errors as a UserError, then resolve file references. Interfaces
+ * call this instead of re-implementing the load-and-resolve sequence.
+ */
+declare function resolveProjectConfig(filePath: string, options?: ResolveProjectConfigOptions): Promise<LoadedProjectConfig>;
+interface ResolveProjectConfigFromObjectOptions {
+    /** Project name to stamp onto the resolved config. */
+    projectName: string;
+    /** Base path used to resolve any `file:` references (defaults to process.cwd()). */
+    basePath?: string;
+}
+/**
+ * Object-level twin of {@link resolveProjectConfig}: validate an in-memory config
+ * object through the same zod schema and file-reference resolution instead of
+ * reading from disk. Hosts that assemble config from env + code (rather than a
+ * yaml file) use this so they don't bypass SDK invariants like the `_resolved` marker.
+ */
+declare function resolveProjectConfigFromObject(rawConfig: unknown, options: ResolveProjectConfigFromObjectOptions): Promise<LoadedProjectConfig>;
+
+interface ExecutionPlan {
+    actions: PlannedAction[];
+    diagnostics: Diagnostic[];
+}
+
+type RuntimeFeedbackLevel = "info" | "success" | "warning" | "error";
+type RuntimeFeedbackType = "resource_action_success" | "resource_action_failed" | "resource_already_gone" | "resource_adopted" | "refresh_resource_missing" | "refresh_drift_unchecked" | "refresh_resource_failed" | "provider_wait";
+interface RuntimeFeedbackEvent {
+    type: RuntimeFeedbackType;
+    level: RuntimeFeedbackLevel;
+    message: string;
+    action?: PlannedAction;
+    resource?: ResourceAddress;
+}
+type RuntimeFeedbackSink = (event: RuntimeFeedbackEvent) => void;
+
+interface ResourceRuntimeOptions extends DestructiveDecisionOptions {
+    provider?: string;
+    refresh?: boolean;
+    refreshOnly?: boolean;
+    quiet?: boolean;
+    onFeedback?: RuntimeFeedbackSink;
+}
+interface ResourceRefreshResult {
+    removed: ResourceState[];
+    errors: Array<{
+        resource: ResourceState;
+        error: string;
+    }>;
+}
+interface ResourceActionResult {
+    action: PlannedAction;
+    status: "success" | "failed" | "skipped";
+    error?: string;
+}
+interface ResourceExecutionResult {
+    results: ResourceActionResult[];
+    partial: boolean;
+}
+interface ResourcePlanResult {
+    executionContext: ProjectRuntimeContext;
+    plan: ExecutionPlan;
+    refreshResult?: ResourceRefreshResult;
+    targetProviders?: string[];
+    destructiveActions: PlannedAction[];
+}
+type DestructivePolicy = "block" | "prompt" | "force";
+interface DestructiveDecisionOptions {
+    policy?: DestructivePolicy;
+    confirm?: (actions: PlannedAction[]) => boolean | Promise<boolean>;
+}
+interface ResourceSyncRun {
+    planned: ResourcePlanResult;
+    execution?: ResourceExecutionResult;
+}
+declare function syncProjectResourcesWithStateBackend(input: BackendRuntimeInput, options?: ResourceRuntimeOptions): Promise<ResourceSyncRun>;
+declare function importResource(ctx: ProjectRuntimeContext, address: ResourceAddress, remoteId: string, options?: {
+    resourceVersion?: number;
+}): Promise<ResourceState>;
+declare function planProjectContext(ctx: ProjectRuntimeContext, options?: ResourceRuntimeOptions): Promise<ResourcePlanResult>;
+declare function executePlannedProject(planned: ResourcePlanResult, options?: DestructiveDecisionOptions & {
+    onFeedback?: RuntimeFeedbackSink;
+    concurrency?: number;
+}): Promise<ResourceExecutionResult>;
+declare function decideDestructive(destructiveActions: PlannedAction[], options?: DestructiveDecisionOptions): Promise<"proceed" | "blocked" | "cancelled">;
+
+interface ValidateProjectConfigOptions {
+    /** Providers to capability-check. Defaults to the config's target providers. */
+    providers?: string[];
+}
+/** Full config validation: cross-references + provider capabilities. Used by `agents validate`/plan/apply. */
+declare function validateProjectConfig(config: ProjectConfig, options?: ValidateProjectConfigOptions): Diagnostic[];
+/**
+ * Reference checks only (no provider capabilities). The low-level primitive for hosts
+ * that must NOT run provider capability rules — e.g. webui playbooks use server-only MCP
+ * (no tools.mcp), which the Bailian capability check would wrongly flag.
+ */
+declare function collectConfigReferences(config: ProjectConfig): Diagnostic[];
+
+interface SyncProjectOptions {
+    /** Provider to read remote resources from (single provider, not "all"). */
+    provider: string;
+    /** Resource types to export. Defaults to ["vault"]. */
+    types?: ResourceType[];
+    /** When set, preserve the raw providers block from this config file in output. */
+    configPath?: string;
+}
+interface SecretPlaceholder {
+    vaultName: string;
+    credentialName: string;
+    envVar: string;
+}
+interface SyncProjectResult {
+    /** The assembled config object (version + providers + resource groups). */
+    config: Record<string, unknown>;
+    /** Serialized yaml, aligned with the plan/apply config format. */
+    yaml: string;
+    /** Count of exported resources per type. */
+    counts: Record<string, number>;
+    /** Downloaded skill files, keyed by skill name → extracted SkillFile[]. */
+    skillFiles?: Map<string, SkillFile[]>;
+    /** Vault credential secret placeholders that need user input. */
+    secretPlaceholders?: SecretPlaceholder[];
+}
+/**
+ * Pick the provider to sync from when --provider is omitted.
+ * Requires an on-disk config with an unambiguous default.
+ */
+declare function resolveSyncProvider(config: Pick<ResolvedProjectConfig, "providers" | "defaults">, explicitProvider?: string): string;
+/**
+ * Reverse-export a provider's remote resources WITHOUT a `agents.yaml`. The adapter
+ * is built from environment variables (e.g. ANTHROPIC_API_KEY), making this the
+ * first-run entry point: bootstrap a config from a remote account before any
+ * local file exists. The emitted `providers` block uses `${ENV}` placeholders.
+ */
+declare function syncProviderResourcesFromEnv(opts: SyncProjectOptions): Promise<SyncProjectResult>;
+/**
+ * Reverse-export using credentials from an existing project config/runtime context.
+ */
+declare function syncProviderResourcesFromContext(ctx: ProjectRuntimeContext, opts: SyncProjectOptions): Promise<SyncProjectResult>;
+
+interface MigrateOptions {
+    fromPath: string;
+    toPath: string;
+}
+interface MigrateResult {
+    added: Record<string, number>;
+    skipped: Record<string, number>;
+    yaml: string;
+}
+/**
+ * Migrate resources from a synced.yaml into an existing agents.yaml.
+ *
+ * - Uses the target agents.yaml's provider (from `defaults.provider` or the first provider key)
+ * - Appends resources that don't already exist (by YAML key)
+ * - Skips resources whose key already exists in the target
+ * - Replaces the `provider` field on each migrated resource with the target provider
+ */
+declare function migrateConfig(opts: MigrateOptions): Promise<MigrateResult>;
+
+/**
+ * The deployment-execution seam: trigger a run and read deployment status. The
+ * deployment runtime drives a configured deployment exclusively through this
+ * surface. The wide {@link import("./interface.ts").ProviderAdapter} structurally
+ * satisfies it; create/update/delete of deployments live in {@link ResourceCrudAdapter}.
+ */
+interface DeploymentRunAdapter {
+    runDeployment(ctx: DeploymentContext): Promise<DeploymentRunResult$1>;
+    getDeployment(ctx: DeploymentContext): Promise<DeploymentInfo$1>;
+}
+
+interface DeploymentSummary {
+    name: string;
+    provider: string;
+    remoteId: string | null;
+    scheduleExpression: string;
+    agent: string;
+    state: ResourceState;
+}
+interface DeploymentBindings {
+    agentId: string;
+    environmentId: string;
+    vaultIds: string[];
+    memoryStoreIds: string[];
+}
+interface DeploymentInfo {
+    id: string | null;
+    status: string;
+    paused_reason?: {
+        type: string;
+        error?: {
+            type: string;
+        };
+    };
+    schedule?: {
+        expression: string;
+        timezone?: string;
+    };
+    attributes?: Record<string, unknown>;
+}
+interface DeploymentDetail {
+    name: string;
+    provider: string;
+    info: DeploymentInfo;
+    bindings: DeploymentBindings;
+}
+interface DeploymentRunResult {
+    run_id?: string;
+    session_id: string | null;
+    error?: {
+        type: string;
+        message: string;
+    };
+}
+interface DeploymentRun {
+    name: string;
+    provider: string;
+    result: DeploymentRunResult;
+}
+declare function listDeploymentsForContext(ctx: ProjectRuntimeContext, providerFilter?: string): DeploymentSummary[];
+declare function getDeploymentDetailsForContext(ctx: ProjectRuntimeContext, name: string, adapter?: Pick<DeploymentRunAdapter, "getDeployment">, resolvedProvider?: string): Promise<DeploymentDetail>;
+declare function runDeploymentForContext(ctx: ProjectRuntimeContext, name: string, adapter?: Pick<DeploymentRunAdapter, "runDeployment">, resolvedProvider?: string): Promise<DeploymentRun>;
+declare function getDeploymentRuntimeProviderForContext(ctx: ProjectRuntimeContext, name: string, overrideProvider?: string): string;
+
+type DestroyResourceStatus = "success" | "failed" | "blocked" | "skipped";
+type DestroyResourceResultReason = "destroyed" | "already_gone" | "cascade_required" | "provider_missing" | "failed" | "skipped";
+interface DestroyResourceResult {
+    resource: ResourceState;
+    status: DestroyResourceStatus;
+    reason: DestroyResourceResultReason;
+    error?: string;
+    cascaded?: boolean;
+}
+interface DestroyPlanResult {
+    resources: ResourceState[];
+    executionContext: ProjectRuntimeContext;
+}
+interface DestroyProjectOptions {
+    cascade?: boolean;
+    onFeedback?: RuntimeFeedbackSink;
+    onResourceStart?: (resource: ResourceState) => void;
+    onResourceResult?: (result: DestroyResourceResult) => void;
+    onCascadeRequired?: (result: DestroyResourceResult) => boolean | Promise<boolean>;
+}
+interface DestroyProjectResult extends DestroyPlanResult {
+    results: DestroyResourceResult[];
+    destroyed: number;
+    partial: boolean;
+}
+declare function planDestroyProjectContext(ctx: ProjectRuntimeContext): DestroyPlanResult;
+declare function destroyPlannedProjectResources(planned: DestroyPlanResult, options?: DestroyProjectOptions): Promise<DestroyProjectResult>;
+
+interface ProviderModelInfo {
+    id: string;
+    display_name: string;
+    source: string;
+    is_enabled: boolean;
+    is_new: boolean;
+    price_factor?: number;
+    efforts?: string[];
+    default_effort?: string;
+}
+interface ProviderModelListing {
+    provider: string;
+    supportsDynamicListing: boolean;
+    models: ProviderModelInfo[];
+}
+/**
+ * The model-listing seam: enumerate a provider's available models. Optional —
+ * only providers with dynamic model discovery implement it. The wide
+ * {@link import("../providers/interface.ts").ProviderAdapter} structurally satisfies it.
+ */
+interface ModelListAdapter {
+    listModels?(): Promise<ModelInfo[]>;
+}
+/**
+ * Context-first entry point: list models from a pre-built providers Map.
+ * No file I/O is performed — the caller supplies the provider adapters.
+ */
+declare function listProviderModelsForContext(providers: ReadonlyMap<string, ModelListAdapter>, providerFilter?: string): Promise<ProviderModelListing[]>;
+declare function listProviderNames(): string[];
+
+interface AgentSkillBuildInput {
+    kind: "official" | "custom";
+    /** Skill code/id for official skills. */
+    code?: string;
+    version?: string;
+    /** Name + source for custom (managed) skills. */
+    name?: string;
+    source?: string;
+    description?: string;
+}
+interface AgentMcpBuildInput {
+    serverName: string;
+    serverType: "official" | "url" | "http";
+    serverUrl?: string;
+    defaultEnabled?: boolean;
+    tools: Array<{
+        name: string;
+        enabled?: boolean;
+    }>;
+}
+interface AgentBuildInput {
+    description?: string;
+    model?: AgentDecl["model"];
+    instructions?: string;
+    environment?: string;
+    provider?: string;
+    builtinTools?: string[];
+    skills?: AgentSkillBuildInput[];
+    mcp?: AgentMcpBuildInput[];
+    metadata?: Record<string, string>;
+}
+interface BuiltAgent {
+    agent: AgentDecl;
+    /** Custom skills referenced by the agent, to be merged into config.skills. */
+    customSkills: Record<string, SkillDecl>;
+}
+/**
+ * Construct a normalized AgentDecl by overlaying neutral override fields onto an
+ * optional base agent. Owns the provider-specific encoding of tools/mcp/skills so
+ * callers (e.g. a WebUI catalog) don't hand-assemble core's config shapes.
+ */
+declare function buildAgentDecl(base: AgentDecl | undefined, input: AgentBuildInput): BuiltAgent;
+
+interface AgentResourcePlanOptions {
+    refresh?: boolean;
+    quiet?: boolean;
+}
+interface AgentResourceSyncOptions extends AgentResourcePlanOptions {
+    policy?: DestructivePolicy;
+    confirm?: (actions: PlannedAction[]) => boolean | Promise<boolean>;
+}
+/**
+ * List RAW cloud agents from the provider — the actual remote objects, not the local
+ * config agents that `listAgents` returns. This is what the resource center needs to
+ * surface same-name duplicates and identity-stamp drift (metadata.playbook vs agents.*) that
+ * the local view can't see. Resolves the single configured provider (or `options.provider`)
+ * and delegates to the adapter's optional `listAgents`; returns [] if unsupported.
+ */
+declare function listCloudAgents(ctx: ProjectRuntimeContext, options?: {
+    provider?: string;
+    prefix?: string;
+    limit?: number;
+}): Promise<CloudAgent[]>;
+/**
+ * List RAW cloud environments — the shared base sandboxes (networking + packages) that
+ * sessions run inside. Not tied to any playbook/agent. Delegates to the adapter's optional
+ * `listEnvironments`; returns [] if unsupported.
+ */
+declare function listCloudEnvironments(ctx: ProjectRuntimeContext, options?: {
+    provider?: string;
+    limit?: number;
+}): Promise<CloudEnvironment[]>;
+/** Create a cloud environment directly (used by the webui entry-check base-env provisioning). */
+declare function createCloudEnvironment(ctx: ProjectRuntimeContext, name: string, decl: EnvironmentDecl, options?: {
+    provider?: string;
+}): Promise<RemoteResource>;
+/** Delete a cloud environment by remote id (used by the webui resource center). */
+declare function deleteCloudEnvironment(ctx: ProjectRuntimeContext, id: string, options?: {
+    provider?: string;
+}): Promise<void>;
+/**
+ * List RAW cloud vaults — the shared credential stores bound to sessions via `vault_ids`.
+ * Not tied to any playbook/agent. Delegates to the adapter's optional `listVaults`; returns []
+ * if unsupported.
+ */
+declare function listCloudVaults(ctx: ProjectRuntimeContext, options?: {
+    provider?: string;
+    limit?: number;
+}): Promise<CloudVault[]>;
+/** Create a cloud vault (+ its credentials) directly, for the webui's user-supplied-key flow. */
+declare function createCloudVault(ctx: ProjectRuntimeContext, name: string, decl: VaultDecl, options?: {
+    provider?: string;
+}): Promise<RemoteResource>;
+/** Delete a cloud vault by remote id (used by the webui resource center). */
+declare function deleteCloudVault(ctx: ProjectRuntimeContext, id: string, options?: {
+    provider?: string;
+}): Promise<void>;
+/** Archive a cloud agent (soft delete → status=archived). Used by the resource center's
+ * archive action; the bailian adapter maps this to POST /agents/{id}/archive. */
+declare function archiveCloudAgent(ctx: ProjectRuntimeContext, id: string, options?: {
+    provider?: string;
+}): Promise<void>;
+declare function getAgent(ctx: ProjectRuntimeContext, agentId: string): AgentDefinition;
+declare function listAgentsWithReadiness(ctx: ProjectRuntimeContext, options?: {
+    refresh?: boolean;
+}): Promise<AgentWithReadiness[]>;
+declare function syncAgentResourcesWithStateBackend(input: BackendRuntimeInput, agentId: string, options?: AgentResourceSyncOptions): Promise<AgentSyncRun>;
+
+interface SessionCreateOptions {
+    environment?: string;
+    /**
+     * Explicit remote environment id. When set, it is bound directly (bypassing the
+     * config-name → state resolution), letting callers that already hold a provider
+     * environment id (e.g. the webui) pin the sandbox without declaring it in config.
+     * Takes precedence over `environment` / the agent's declared environment.
+     */
+    environmentId?: string;
+    vault?: string;
+    /**
+     * Explicit remote vault ids. When set, they are bound directly (bypassing the
+     * config-name → state resolution), letting callers that already hold provider
+     * vault ids (e.g. the webui) bind a user-supplied credential vault without
+     * declaring it in config. Takes precedence over `vault` / the agent's vault.
+     */
+    vaultIds?: string[];
+    memoryStores?: string[];
+    /** Uploaded files to mount as session resources, so the task can read the user's files. */
+    files?: {
+        fileId: string;
+        mountPath: string;
+    }[];
+    title?: string;
+    provider?: string;
+    metadata?: Record<string, string>;
+}
+declare function resolveSessionProvider(agentName: string, config: ProjectConfig, overrideProvider?: string): string;
+
+interface SessionRuntimeTarget {
+    agent?: string;
+    provider?: string;
+}
+interface SessionRuntimeCreateOptions extends SessionCreateOptions, SessionRuntimeTarget {
+}
+interface SessionRuntimeRunOptions extends SessionRuntimeCreateOptions {
+    pollIntervalMs?: number;
+    pollTimeoutMs?: number;
+}
+interface SessionRuntimeSendOptions extends SessionRuntimeTarget {
+    pollIntervalMs?: number;
+    pollTimeoutMs?: number;
+}
+interface CreatedSessionRun {
+    agentName: string;
+    provider: string;
+    session: ProviderSessionInfo;
+}
+interface StreamingSessionRun extends CreatedSessionRun {
+    events: AsyncIterable<ProviderSessionEvent>;
+}
+interface CollectedSessionEvents {
+    eventId?: string;
+    terminalStatus: string;
+    result: ProviderSessionEventList;
+}
+interface SessionSummary {
+    session: ProviderSessionInfo;
+    provider: string;
+    agentId?: string;
+    agentName?: string;
+}
+interface SessionSummaryList {
+    provider: string;
+    summaries: SessionSummary[];
+    hasMore: boolean;
+    nextPage?: string;
+}
+declare function isTerminalSessionStatus(status: string | undefined): boolean;
+declare function createSessionForAgent(ctx: ProjectRuntimeContext, options?: SessionRuntimeCreateOptions): Promise<CreatedSessionRun>;
+declare function startSessionRun(ctx: ProjectRuntimeContext, prompt: string, options?: SessionRuntimeRunOptions): Promise<StreamingSessionRun>;
+declare function sendSessionMessageStreaming(ctx: ProjectRuntimeContext, sessionId: string, message: string, options?: SessionRuntimeSendOptions): Promise<AsyncIterable<ProviderSessionEvent>>;
+declare function startSessionRunPolling(ctx: ProjectRuntimeContext, prompt: string, options?: SessionRuntimeRunOptions): Promise<CreatedSessionRun & CollectedSessionEvents>;
+declare function sendSessionMessagePolling(ctx: ProjectRuntimeContext, sessionId: string, message: string, options?: SessionRuntimeSendOptions): Promise<CollectedSessionEvents>;
+declare function listSessionSummaries(ctx: ProjectRuntimeContext, options?: SessionRuntimeTarget & {
+    filter?: SessionFilter;
+}): Promise<SessionSummaryList>;
+declare function getSession(ctx: ProjectRuntimeContext, sessionId: string, provider?: string): Promise<ProviderSessionInfo>;
+declare function deleteSession(ctx: ProjectRuntimeContext, sessionId: string, provider?: string): Promise<void>;
+declare function listSessionEvents(ctx: ProjectRuntimeContext, sessionId: string, options?: SessionRuntimeTarget & {
+    limit?: number;
+    order?: string;
+    page_token?: string;
+    page?: string;
+}): Promise<ProviderSessionEventList>;
+/**
+ * Upload a file's raw bytes to the resolved provider's Files API and return its metadata.
+ * Content-based (no filesystem) so server contexts can forward browser uploads directly.
+ */
+declare function uploadFile(ctx: ProjectRuntimeContext, content: Uint8Array, filename: string, options?: SessionRuntimeTarget & {
+    mimeType?: string;
+    purpose?: string;
+}): Promise<ProviderFileInfo & {
+    available: boolean;
+}>;
+/** Delete a previously uploaded file by id from the resolved provider's Files API. */
+declare function deleteFile(ctx: ProjectRuntimeContext, id: string, options?: SessionRuntimeTarget): Promise<void>;
+/** Fetch a single file's metadata (incl. scan `status`), to gate session binding on availability. */
+declare function getFileInfo(ctx: ProjectRuntimeContext, id: string, options?: SessionRuntimeTarget): Promise<ProviderFileInfo & {
+    available: boolean;
+}>;
+/** Resolve a short-lived presigned download URL for a file (e.g. an agent-delivered artifact). */
+declare function getFileDownloadUrl(ctx: ProjectRuntimeContext, id: string, options?: SessionRuntimeTarget): Promise<{
+    url: string;
+    expires_at?: string;
+}>;
+/** List workspace user-uploaded files (newest first) from the resolved provider's Files API.
+ * Returns [] when the provider lacks file listing (graceful degradation, mirrors cloud listing). */
+declare function listFiles(ctx: ProjectRuntimeContext, options?: SessionRuntimeTarget): Promise<Array<ProviderFileInfo & {
+    available: boolean;
+}>>;
+/** List skills (newest first) from the resolved provider's Skills API. `source` selects the
+ * catalog: "custom" (workspace-uploaded, the default) or "official" (the built-in catalog).
+ * Returns [] when the provider lacks skill listing (graceful degradation, mirrors cloud listing). */
+declare function listSkills(ctx: ProjectRuntimeContext, options?: SessionRuntimeTarget & {
+    source?: "custom" | "official";
+}): Promise<ProviderSkillInfo[]>;
+/** Fetch a single skill's metadata (incl. scan `status`), to poll create → active. */
+declare function getSkillInfo(ctx: ProjectRuntimeContext, id: string, options?: SessionRuntimeTarget): Promise<ProviderSkillInfo>;
+/** Create a skill from an uploaded zip's file_id (non-blocking; returns initial scan status). */
+declare function createSkillFromFileId(ctx: ProjectRuntimeContext, fileId: string, options?: SessionRuntimeTarget): Promise<ProviderSkillInfo>;
+/** Delete a custom skill by id from the resolved provider's Skills API. */
+declare function deleteSkill(ctx: ProjectRuntimeContext, id: string, options?: SessionRuntimeTarget): Promise<void>;
+/**
+ * Subscribe to a session's live event stream by id (native SSE). The underlying provider
+ * stream pushes only post-connect events, so callers that need full history must replay it
+ * via listSessionEvents and de-dupe by ProviderSessionEvent.id.
+ */
+declare function streamSessionEvents(ctx: ProjectRuntimeContext, sessionId: string, options?: SessionRuntimeTarget & EventStreamOptions): AsyncIterable<ProviderSessionEvent>;
+
+/** Files as carried by `SessionBindings.files` — only `mount_path` matters for the hint. */
+interface MountedFile {
+    mount_path: string;
+}
+/** Prepend the file-mount hint to a prompt. Returns the prompt unchanged when there are no files. */
+declare function prependFileHint(prompt: string, files: MountedFile[] | undefined, provider: string): string;
+/** 将 prompt 内 ⟦file:mountPath⟧ 占位符替换为 provider 感知的真实 sandbox 路径 */
+declare function rewriteFileMentions(prompt: string, provider: string): string;
+/** 发送给 provider 前统一处理：先替换 mention 占位符，再 prepend 文件 hint */
+declare function preparePromptForProvider(prompt: string, files: MountedFile[] | undefined, provider: string): string;
+
+/**
+ * Resolve a provider's config block from environment variables (actual values, not
+ * `${ENV}` placeholders). Throws when a required field's env var is unset. Used both
+ * by `buildProviderFromEnv` and by servers that assemble a raw project config object
+ * (e.g. the server) and feed it through `resolveProjectConfigFromObject`.
+ */
+declare function resolveProviderConfigFromEnv(providerName: string): Record<string, string>;
+
+declare const AGENTS_CONFIG_PROVIDERS: readonly ["bailian", "qoder", "ark", "claude"];
+type ProviderConfigProvider = (typeof AGENTS_CONFIG_PROVIDERS)[number];
+declare const AGENTS_PROVIDER_FIELDS: Record<ProviderConfigProvider, readonly {
+    key: string;
+    label: string;
+    secret: boolean;
+}[]>;
+type ProviderConfig = {
+    AGENTS_PROVIDER: ProviderConfigProvider;
+    [key: string]: string;
+};
+declare function providerConfigPath(): string;
+/** Active provider after bootstrap — defaults to bailian when unset. */
+declare function resolveActiveProvider(): ProviderConfigProvider;
+/** Whether the current process env has all required fields for the active provider. */
+declare function areRuntimeCredentialsReady(): boolean;
+/** Load the nearest `.env` walking up from `startDir` (at most 10 levels). */
+declare function loadDotEnv(startDir?: string): string | undefined;
+/** Apply config.json provider fields to `process.env`. With `force: false`, only unset vars are filled. */
+declare function applyProviderConfigToEnv(config: ProviderConfig, { force }?: {
+    force?: boolean;
+}): void;
+/** Load ~/.agents/config.json into `process.env`. Bootstrap passes `{ force: true }` so config.json wins. */
+declare function loadProviderConfigIntoEnvSync(options?: {
+    force?: boolean;
+}): void;
+/** Async variant for servers that prefer non-blocking I/O at startup. */
+declare function loadProviderConfigIntoEnv(options?: {
+    force?: boolean;
+}): Promise<void>;
+/**
+ * Runtime credential bootstrap:
+ * 1. `.env` (and pre-set shell env) — lowest priority for provider fields
+ * 2. `~/.agents/config.json` — highest priority; overrides conflicting provider fields
+ */
+declare function bootstrapRuntimeCredentialsSync(startDir?: string): void;
+declare function bootstrapRuntimeCredentials(startDir?: string): Promise<void>;
+
+declare function parseStateAddress(address: string, options?: {
+    requireProvider?: boolean;
+}): ResourceAddress;
+
+interface LocalFileStateBackendOptions {
+    configPath?: string;
+    statePath?: string;
+}
+declare class LocalFileStateBackend implements StateBackend {
+    private readonly configPath?;
+    private readonly statePath?;
+    constructor(options?: LocalFileStateBackendOptions);
+    read<T>(scope: StateScope, fn: (state: IStateManager) => Promise<T> | T): Promise<T>;
+    write<T>(scope: StateScope, fn: (state: IStateManager) => Promise<T> | T): Promise<T>;
+    getStatePath(_scope: StateScope): string;
+}
+
+/** Normalize a skill zip and extract its entries to SkillFile[]. */
+declare function extractSkillZipFiles(raw: Buffer): Promise<SkillFile[]>;
+
+export { AGENTS_CONFIG_PROVIDERS, AGENTS_PROVIDER_FIELDS, type AgentBuildInput, AgentDefinition, type AgentMcpBuildInput, type AgentSkillBuildInput, AgentSyncRun, AgentWithReadiness, type BackendRuntimeInput, CloudAgent, CloudEnvironment, CloudVault, type CollectedSessionEvents, type DestroyResourceResult, type DestructivePolicy, Diagnostic, type IStateManager, type LoadedProjectConfig, LocalFileStateBackend, type MigrateOptions, type MigrateResult, PlannedAction, type ProjectRuntimeContext, type ProviderConfig, type ProviderConfigProvider, ProviderFileInfo, ProviderSessionEvent, type ProviderSessionInfo, type ProviderSkillInfo, type ResolvedProjectConfig, type ResourceActionResult, ResourceAddress, type ResourceExecutionResult, type ResourcePlanResult, type ResourceRefreshResult, type ResourceRuntimeOptions, type ResourceState, type ResourceSyncRun, ResourceType, type RuntimeFeedbackEvent, type RuntimeFeedbackSink, type SecretPlaceholder, type SkillFile, StateManager, type StateScope, type SyncProjectOptions, type SyncProjectResult, UserError, type ValidateProjectConfigOptions, applyProviderConfigToEnv, archiveCloudAgent, areRuntimeCredentialsReady, bootstrapRuntimeCredentials, bootstrapRuntimeCredentialsSync, buildAgentDecl, collectConfigReferences, createCloudEnvironment, createCloudVault, createProjectRuntime, createSessionForAgent, createSkillFromFileId, decideDestructive, deleteCloudEnvironment, deleteCloudVault, deleteFile, deleteSession, deleteSkill, destroyPlannedProjectResources, executePlannedProject, extractSkillZipFiles, getAgent, getDeploymentDetailsForContext, getDeploymentRuntimeProviderForContext, getFileDownloadUrl, getFileInfo, getSession, getSkillInfo, importResource, isTerminalSessionStatus, listAgentsWithReadiness, listCloudAgents, listCloudEnvironments, listCloudVaults, listDeploymentsForContext, listFiles, listProviderModelsForContext, listProviderNames, listSessionEvents, listSessionSummaries, listSkills, loadDotEnv, loadProviderConfigIntoEnv, loadProviderConfigIntoEnvSync, migrateConfig, parseStateAddress, planDestroyProjectContext, planProjectContext, preparePromptForProvider, prependFileHint, providerConfigPath, readProjectRuntime, resolveActiveProvider, resolveProjectConfig, resolveProjectConfigFromObject, resolveProviderConfigFromEnv, resolveSessionProvider, resolveSyncProvider, rewriteFileMentions, runDeploymentForContext, sendSessionMessagePolling, sendSessionMessageStreaming, startSessionRun, startSessionRunPolling, streamSessionEvents, syncAgentResourcesWithStateBackend, syncProjectResourcesWithStateBackend, syncProviderResourcesFromContext, syncProviderResourcesFromEnv, uploadFile, validateProjectConfig, writeProjectRuntime };