@openagentpack/sdk 0.6.0 → 0.7.1

package/dist/resource-runtime-DZDY45_Q.d.ts

@@ -0,0 +1,1126 @@
+import { C as CloudAgent, c as CloudEnvironment, d as CloudVault, f as ResourceAddress, R as ResourceType, P as PlannedAction, D as Diagnostic } from './dto-BT1Q1Ii6.js';
+import { P as ProviderFileInfo } from './file-Cj5-Vx27.js';
+import { b as EventStreamOptions, a as ProviderSessionEvent, E as EventListOptions, P as ProviderSessionEventList } from './session-event-DB_YlDiK.js';
+
+type ProviderName = string;
+interface ProjectConfig {
+    version: string;
+    providers: Record<string, unknown>;
+    defaults?: DefaultsConfig;
+    environments?: Record<string, EnvironmentDecl>;
+    tunnels?: Record<string, TunnelDecl>;
+    vaults?: Record<string, VaultDecl>;
+    memory_stores?: Record<string, MemoryStoreDecl>;
+    skills?: Record<string, SkillDecl>;
+    files?: Record<string, FileDecl>;
+    identities?: Record<string, IdentityDecl>;
+    agents?: Record<string, AgentDecl>;
+    channels?: Record<string, ChannelDecl>;
+    deployments?: Record<string, DeploymentDecl>;
+}
+interface DefaultsConfig {
+    provider?: string;
+    /** Logical name of the default declared Identity used by identity-aware resources and runtimes. */
+    identity?: string;
+}
+type IdentityDecl = ManagedIdentityDecl | ExternalIdentityDecl;
+interface ManagedIdentityDecl {
+    provider?: ProviderName;
+    external_id: string;
+    name?: string;
+    enabled?: boolean;
+    metadata?: Record<string, string>;
+    identity_id?: never;
+}
+interface ExternalIdentityDecl {
+    provider?: ProviderName;
+    /** Pre-existing provider Identity id. External references are never mutated or deleted. */
+    identity_id: string;
+    external_id?: never;
+    name?: never;
+    enabled?: never;
+    metadata?: never;
+}
+interface EnvironmentDecl {
+    name?: string;
+    description?: string;
+    provider?: ProviderName;
+    /** Pre-existing provider environment id. When set, OpenCMA treats the environment as an external reference and will not create/update/delete it remotely. */
+    environment_id?: string;
+    config: EnvironmentConfig;
+    metadata?: Record<string, string>;
+}
+interface EnvironmentConfig {
+    type: "cloud" | "self_hosted";
+    networking?: NetworkingConfig;
+    packages?: PackagesConfig;
+    /** Shell script executed by supported providers while preparing a sandbox. */
+    setup_script?: string;
+}
+interface TunnelDecl {
+    name?: string;
+    description?: string;
+    /** Pre-existing Qoder tunnel id (e.g. tnl_00xxxx). Tunnels are allocated by Qoder BYOC admin and referenced, not created. */
+    tunnel_id: string;
+    metadata?: Record<string, string>;
+}
+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 CredentialNetworking {
+    /** Legacy policy type; Bailian requests use allowed_hosts instead. */
+    type?: "unrestricted" | "limited";
+    allowed_hosts?: string[];
+}
+interface CredentialInjectionLocation {
+    header?: boolean;
+    body?: boolean;
+}
+interface CredentialDecl {
+    name: string;
+    type: CredentialType;
+    metadata?: Record<string, string>;
+    mcp_server_url?: string;
+    access_token?: string;
+    protocol?: "sse" | "streamable_http";
+    secret_name?: string;
+    secret_value?: string;
+    networking?: CredentialNetworking;
+    injection_location?: CredentialInjectionLocation;
+}
+interface MemoryStoreDecl {
+    description: string;
+    provider?: ProviderName;
+    metadata?: Record<string, string>;
+    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;
+    /** Local label only; declarative uploads preserve the source file's basename. */
+    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;
+    tunnel?: string;
+    provider?: ProviderName;
+    tools?: AgentToolsDecl;
+    mcp_servers?: McpServerDecl[];
+    skills?: AgentSkillDecl[];
+    vault?: string;
+    memory_stores?: string[];
+    /** String refs are inherited by Qoder Forward Templates; object refs mount Files into Sessions. */
+    files?: Array<string | AgentFileMountDecl>;
+    /** Desired display metadata for Qoder Forward's system-managed writable Store. */
+    default_memory_store?: DefaultMemoryStoreDecl;
+    /** Resources mounted into every managed session created for this agent. */
+    resources?: SessionResourceDecl[];
+    multiagent?: MultiagentDecl;
+    metadata?: Record<string, string>;
+    /** Qoder runtime environment variables. Forward delivery stores these as Template defaults. */
+    environment_variables?: Record<string, string>;
+    /** Provider-side tools the Agent Harness operates itself. Qoder Forward delivery only. */
+    managed_tool_config?: ManagedToolConfigDecl;
+    /** Provider-specific remote materialization. Omitted means the existing managed Agent resource. */
+    delivery?: Record<ProviderName, AgentDeliveryDecl>;
+}
+interface AgentFileMountDecl {
+    /** Logical key under the top-level files section. */
+    file: string;
+    /** Provider sandbox path. Bailian paths live under /mnt. */
+    mount_path: string;
+}
+interface DefaultMemoryStoreDecl {
+    name: string;
+    description?: string;
+    /** Permanently delete the system-managed Store during destroy. Defaults to false. */
+    delete_on_destroy?: boolean;
+}
+interface ManagedToolConfigDecl {
+    /** Replaces the provider's enabled managed-tool set; an empty array disables all of them. */
+    enabled_tools: string[];
+}
+interface AgentDeliveryDecl {
+    type: "managed" | "forward";
+}
+interface ChannelDecl {
+    provider?: ProviderName;
+    /** Logical Agent name. The provider adapter resolves its materialized remote resource. Required for `fixed` mode; ignored for `pairing` mode. */
+    agent?: string;
+    /** Logical Identity name. Falls back to defaults.identity. Required for `fixed` mode; ignored for `pairing` mode. */
+    identity?: string;
+    type: string;
+    name?: string;
+    /** Identity resolution mode. `fixed` binds the channel to one Identity/Template; `pairing` creates a transport-only channel used by Schedules/Sinks. Defaults to `fixed`. */
+    mode?: "fixed" | "pairing";
+    enabled?: boolean;
+    credentials?: Record<string, string>;
+    options?: Record<string, unknown>;
+}
+type AgentSkillDecl = string | AgentSkillRefDecl;
+interface AgentSkillRefDecl {
+    type: "official" | "custom";
+    skill_id: string;
+    version?: string;
+}
+interface AgentToolsDecl {
+    builtin: string[];
+    /** Permission inherited by every enabled builtin without an explicit override. */
+    default_permission?: "allow" | "ask";
+    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 {
+    name?: string;
+    agent: string;
+    agent_version?: number;
+    environment?: string;
+    tunnel?: string;
+    vaults?: string[];
+    memory_stores?: string[];
+    resources?: DeploymentResourceDecl[];
+    initial_events: InitialEventDecl[];
+    schedule?: ScheduleDecl;
+    description?: string;
+    provider?: ProviderName;
+    metadata?: Record<string, string>;
+    /** Qoder-only deployment-level variables copied into each created session. */
+    environment_variables?: string;
+}
+type DeploymentResourceDecl = DeploymentFileResource | DeploymentMemoryStoreResource | DeploymentGithubRepoResource;
+/** Provider-neutral resources that can be attached directly when a session is created. */
+interface SessionGithubRepoResourceDecl extends Omit<DeploymentGithubRepoResource, "authorization_token"> {
+    /** Required for private repositories; interpolate this value from an environment variable. */
+    authorization_token: string;
+}
+type SessionResourceDecl = SessionGithubRepoResourceDecl;
+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 ProviderSkillInfo {
+    id: string;
+    name: string;
+    description?: string;
+    source: "custom" | "official";
+    status: "checking" | "active" | "rejected" | "deleted";
+    latest_version?: string;
+    created_at?: string;
+    updated_at?: string;
+    attributes?: Record<string, unknown>;
+}
+
+interface CursorPage<T> {
+    data: T[];
+    has_more: boolean;
+    next_page?: string;
+}
+interface CursorListOptions {
+    limit?: number;
+    page?: string;
+}
+interface AgentListOptions extends CursorListOptions {
+    include_archived?: boolean;
+}
+type AgentVersionListOptions = CursorListOptions;
+type AgentPage = CursorPage<CloudAgent>;
+interface EnvironmentListOptions extends CursorListOptions {
+    include_archived?: boolean;
+}
+type EnvironmentPage = CursorPage<CloudEnvironment>;
+interface VaultListOptions extends CursorListOptions {
+    include_archived?: boolean;
+}
+type VaultPage = CursorPage<CloudVault>;
+interface VaultCredentialInfo {
+    id: string;
+    display_name: string;
+    auth_type: string;
+    secret_name?: string;
+    mcp_server_url?: string;
+    networking_type?: string;
+    networking?: CredentialNetworking;
+    injection_location?: CredentialInjectionLocation;
+    metadata?: Record<string, string>;
+}
+interface SkillListOptions extends CursorListOptions {
+    source?: "custom" | "official";
+}
+interface SkillVersionInfo {
+    id?: string;
+    skill_id: string;
+    type: string;
+    name?: string;
+    description?: string;
+    version: string;
+    status?: string;
+    created_at?: string;
+    updated_at?: string;
+    additional_properties?: Record<string, unknown>;
+    attributes: Record<string, unknown>;
+}
+type SkillVersionListOptions = CursorListOptions;
+type SkillVersionPage = CursorPage<SkillVersionInfo>;
+interface SkillDownloadInfo {
+    skill_id: string;
+    version: string;
+    file_url: string;
+}
+type SkillPage = CursorPage<ProviderSkillInfo>;
+interface FileListOptions extends CursorListOptions {
+    scope_id?: string;
+}
+type FilePage = CursorPage<ProviderFileInfo>;
+interface SessionUpdateInput {
+    title?: string;
+    metadata?: Record<string, string>;
+}
+/** Raw AgentStudio message/event input. Provider adapters preserve the wire shape. */
+type SessionEventInput = Record<string, unknown>;
+interface SessionEventSendResult {
+    event_ids: string[];
+    attributes: Record<string, unknown>;
+}
+interface DeploymentRunInfo {
+    id: string;
+    deployment_id?: string;
+    session_id?: string | null;
+    status?: string;
+    error?: {
+        type?: string;
+        message?: string;
+    };
+    created_at?: string;
+    updated_at?: string;
+    attributes: Record<string, unknown>;
+}
+type DeploymentRunPage = CursorPage<DeploymentRunInfo>;
+type ManagedAgentOperationAuth = "api_key" | "none";
+interface ManagedAgentOperationCapability {
+    supported: boolean;
+    auth: ManagedAgentOperationAuth | null;
+    reason?: string;
+}
+interface ManagedAgentProviderCapabilities {
+    provider: string;
+    operations: Record<string, ManagedAgentOperationCapability>;
+}
+
+type MemoryMetadata = Record<string, string>;
+interface MemoryStoreInfo {
+    id: string;
+    type: "memory_store";
+    name: string;
+    description: string;
+    metadata: MemoryMetadata;
+    status?: "active" | "archived" | string;
+    entry_count?: number;
+    total_size?: number;
+    session_count?: number;
+    created_by?: MemoryActor;
+    created_at: string;
+    updated_at: string;
+    archived_at?: string | null;
+}
+interface MemoryInfo {
+    id: string;
+    type: "memory";
+    memory_store_id: string;
+    path: string;
+    content?: string | null;
+    content_size_bytes: number;
+    content_sha256: string;
+    version?: number;
+    memory_version_id?: string;
+    metadata: MemoryMetadata;
+    created_by?: MemoryActor;
+    created_at: string;
+    updated_at: string;
+}
+interface MemoryPrefixInfo {
+    type: "memory_prefix";
+    path: string;
+}
+type MemoryListItem = MemoryInfo | MemoryPrefixInfo;
+type MemoryVersionOperation = "created" | "updated" | "modified" | "deleted";
+interface MemoryActor {
+    type: string;
+    api_key_id?: string;
+    session_id?: string;
+    user_id?: string;
+}
+interface MemoryVersionInfo {
+    id: string;
+    type: "memory_version";
+    memory_store_id: string;
+    memory_id: string;
+    path?: string | null;
+    content?: string | null;
+    content_size_bytes?: number | null;
+    content_sha256?: string | null;
+    operation: MemoryVersionOperation;
+    version?: number;
+    redacted?: boolean;
+    redacted_at?: string | null;
+    created_by?: MemoryActor;
+    created_at: string;
+}
+interface MemoryPage<T> {
+    data: T[];
+    has_more: boolean;
+    next_cursor?: string;
+}
+interface MemoryProviderCapabilities {
+    archive_store: boolean;
+    batch_create: boolean;
+    versions: boolean;
+    optimistic_concurrency: boolean;
+    memory_metadata: boolean;
+}
+interface MemoryStoreListOptions {
+    limit?: number;
+    cursor?: string;
+    include_archived?: boolean;
+}
+interface MemoryListOptions {
+    limit?: number;
+    cursor?: string;
+    prefix?: string;
+    depth?: number;
+    view?: "basic" | "full";
+}
+interface MemoryVersionListOptions {
+    limit?: number;
+    cursor?: string;
+    memory_id?: string;
+    view?: "basic" | "full";
+}
+interface CreateMemoryStoreInput {
+    name: string;
+    description?: string;
+    metadata?: MemoryMetadata;
+}
+interface UpdateMemoryStoreInput {
+    name?: string;
+    description?: string;
+    metadata?: MemoryMetadata;
+}
+interface CreateMemoryInput {
+    path: string;
+    content: string;
+    metadata?: MemoryMetadata;
+}
+interface BatchCreateMemoryInput {
+    items: CreateMemoryInput[];
+    on_conflict?: "overwrite" | "fail";
+}
+interface BatchCreateMemoryResultItem {
+    path: string;
+    memory?: MemoryInfo;
+    error?: {
+        type: string;
+        message: string;
+    };
+}
+interface BatchCreateMemoryResult {
+    results: BatchCreateMemoryResultItem[];
+}
+interface UpdateMemoryInput {
+    path?: string;
+    content?: string;
+    metadata?: MemoryMetadata;
+    expected_content_sha256?: string;
+}
+
+interface SessionFileResource {
+    file_id: string;
+    mount_path: string;
+}
+interface SessionGithubRepositoryResource {
+    type: "github_repository";
+    url: string;
+    checkout?: {
+        branch?: string;
+        commit?: string;
+    };
+    mount_path?: string;
+    authorization_token: string;
+}
+type SessionResource = SessionGithubRepositoryResource;
+interface CommonSessionBindings {
+    /** Uploaded files to mount in the session sandbox. */
+    files?: SessionFileResource[];
+    /** Provider-neutral resources to mount when the session is created. */
+    resources?: SessionResource[];
+    title?: string;
+    metadata?: Record<string, string>;
+    /** Provider-neutral representation; Qoder maps it to each Session API's wire shape. */
+    environment_variables?: Record<string, string>;
+}
+interface ManagedSessionBindings extends CommonSessionBindings {
+    /** Omitted for backward compatibility; omitted always means managed. */
+    delivery?: "managed";
+    agent_id: string;
+    agent_version?: number;
+    /** Cloud sandbox id. Every provider runs sessions inside an environment. */
+    environment_id: string;
+    /** Qoder BYOC tunnel id. Required to reach internal MCP servers from the sandbox. */
+    tunnel_id?: string;
+    vault_ids: string[];
+    memory_store_ids: string[];
+}
+interface ForwardSessionBindings extends CommonSessionBindings {
+    delivery: "forward";
+    /** Qoder Forward Template selected from the applied Agent materialization. */
+    template_id: string;
+    /** Existing business Identity supplied by the session caller; omitted uses the provider's default Identity. */
+    identity_id?: string;
+}
+type SessionBindings = ManagedSessionBindings | ForwardSessionBindings;
+interface ProviderSessionInfo {
+    id: string;
+    agent_id: string;
+    environment_id: string;
+    tunnel_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;
+    statuses?: string[];
+    created_at_gte?: string;
+    created_at_lte?: string;
+    limit?: number;
+    page?: string;
+}
+interface SessionListResult {
+    sessions: ProviderSessionInfo[];
+    has_more: boolean;
+    next_page?: string;
+}
+
+interface SkillFile {
+    relativePath: string;
+    content: Buffer;
+}
+
+interface ResourceState {
+    address: ResourceAddress;
+    remote_id: string | null;
+    /**
+     * This resource is owned by the provider or another system and is only
+     * referenced by this project. It must never be deleted remotely.
+     */
+    externally_managed?: boolean;
+    /** Provider API domain that owns the remote resource (currently relevant to Qoder). */
+    api_mode?: "managed" | "forward" | "auto";
+    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;
+    desired_readiness_baseline?: ResourceReadinessBaseline;
+    remote_hash?: string;
+    remote_snapshot?: unknown;
+    /** Non-reversible declaration fingerprint used to infer safe logical renames. */
+    replacement_fingerprint?: string;
+    drift_paths?: string[];
+    drift_status?: "in_sync" | "drifted" | "missing" | "unchecked";
+}
+interface ResourceReadinessBaseline {
+    operational_hash: string;
+    description_hash: string;
+    metadata_hash: string;
+}
+interface StateFile {
+    resources: ResourceState[];
+    pending_default_memory_store_cleanups?: PendingDefaultMemoryStoreCleanup[];
+}
+interface PendingDefaultMemoryStoreCleanup {
+    agent_name: string;
+    provider: string;
+    remote_id: string;
+    identity_id?: string;
+    template_id?: string;
+    last_error?: string;
+}
+
+interface RemoteResource {
+    id: string | null;
+    type: string;
+    version?: number;
+}
+type ProviderResourceMode = "managed" | "forward" | "auto";
+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 ResolvedTemplateRefs extends ResolvedAgentRefs {
+    environment_id: string;
+    /** Qoder BYOC private-network route used by Forward Templates. */
+    tunnel_id?: string;
+    vault_ids: string[];
+    file_ids?: string[];
+    identity_id?: string;
+    memory_store_ids?: string[];
+    /** Forward Store ids owned by this project and therefore safe to detach during reconciliation. */
+    owned_memory_store_ids?: string[];
+}
+interface ResolvedDeploymentRefs {
+    agent_id: string;
+    agent_version?: number;
+    environment_id: string;
+    /** Qoder BYOC tunnel id. Passed through only when the deployment targets Qoder BYOC. */
+    tunnel_id?: string;
+    vault_ids: string[];
+    memory_store_ids: Record<string, string>;
+}
+interface ResolvedChannelRefs {
+    identity_id?: string;
+    agent_id?: string;
+}
+interface DefaultMemoryStoreReconcileResult {
+    status: "updated" | "unchanged" | "pending";
+    memory_store_id?: string;
+}
+interface DeploymentContext {
+    id: string | null;
+    name: string;
+    decl: DeploymentDecl;
+    refs: ResolvedDeploymentRefs;
+    basePath: string;
+}
+interface DeploymentRunResult {
+    run_id?: string;
+    session_id: string | null;
+    error?: {
+        type: string;
+        message: 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 DeploymentListFilter {
+    agent_id?: string;
+    /** Bailian server-side fuzzy match against deployment id or name. */
+    keyword?: string;
+    status?: "active" | "paused";
+    include_archived?: boolean;
+    limit?: number;
+    page?: string;
+    created_at_gte?: string;
+    created_at_lte?: string;
+}
+interface DeploymentListResult {
+    deployments: DeploymentInfo[];
+    has_more: boolean;
+    next_page?: string;
+}
+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;
+    readonly memoryCapabilities?: MemoryProviderCapabilities;
+    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, mode?: ProviderResourceMode): Promise<RemoteResource | null>;
+    listAgents?(filter?: {
+        prefix?: string;
+        limit?: number;
+    }): Promise<CloudAgent[]>;
+    /** Cursor-preserving API listing used by command surfaces. */
+    listAgentResources?(options?: AgentListOptions): Promise<AgentPage>;
+    getRemoteAgent?(id: string, version?: number): Promise<CloudAgent>;
+    listAgentVersions?(id: string, options?: AgentVersionListOptions): Promise<AgentPage>;
+    listEnvironments?(filter?: {
+        limit?: number;
+    }): Promise<CloudEnvironment[]>;
+    listEnvironmentResources?(options?: EnvironmentListOptions): Promise<EnvironmentPage>;
+    getRemoteEnvironment?(id: string): Promise<CloudEnvironment>;
+    listVaults?(filter?: {
+        limit?: number;
+    }): Promise<CloudVault[]>;
+    listVaultResources?(options?: VaultListOptions): Promise<VaultPage>;
+    getRemoteVault?(id: string): 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, mode?: ProviderResourceMode): Promise<RemoteResource>;
+    updateEnvironment(id: string, name: string, decl: EnvironmentDecl, mode?: ProviderResourceMode): Promise<RemoteResource>;
+    deleteEnvironment(id: string, cascade?: boolean, mode?: ProviderResourceMode): Promise<void>;
+    createVault(name: string, decl: VaultDecl, mode?: ProviderResourceMode): Promise<RemoteResource>;
+    deleteVault(id: string, mode?: ProviderResourceMode): Promise<void>;
+    createCredential?(vaultId: string, credential: CredentialDecl): Promise<RemoteResource>;
+    listCredentials?(vaultId: string): Promise<VaultCredentialInfo[]>;
+    createSkill(name: string, decl: SkillDecl, files: SkillFile[], mode?: ProviderResourceMode): Promise<RemoteResource>;
+    updateSkill(id: string, name: string, decl: SkillDecl, files: SkillFile[], mode?: ProviderResourceMode): Promise<RemoteResource>;
+    deleteSkill(id: string, mode?: ProviderResourceMode): 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>;
+    createTemplate?(name: string, decl: AgentDecl, refs: ResolvedTemplateRefs): Promise<RemoteResource>;
+    updateTemplate?(id: string, name: string, decl: AgentDecl, refs: ResolvedTemplateRefs): Promise<RemoteResource>;
+    /** Remove the template from desired state. Qoder implements this as a soft archive. */
+    archiveTemplate?(id: string, ownedMemoryStoreIds?: string[]): Promise<void>;
+    reconcileDefaultMemoryStore?(identityId: string, templateId: string, desired: DefaultMemoryStoreDecl): Promise<DefaultMemoryStoreReconcileResult>;
+    findDefaultMemoryStoreId?(identityId: string, templateId: string): Promise<string | null>;
+    deleteDefaultMemoryStore?(id: string): Promise<void>;
+    createIdentity?(name: string, decl: IdentityDecl): Promise<RemoteResource>;
+    updateIdentity?(id: string, name: string, decl: IdentityDecl): Promise<RemoteResource>;
+    deleteIdentity?(id: string): Promise<void>;
+    createChannel?(name: string, decl: ChannelDecl, refs: ResolvedChannelRefs): Promise<RemoteResource>;
+    updateChannel?(id: string, name: string, decl: ChannelDecl, refs: ResolvedChannelRefs): Promise<RemoteResource>;
+    deleteChannel?(id: string): Promise<void>;
+    createMemoryStore?(name: string, decl: MemoryStoreDecl, mode?: ProviderResourceMode): Promise<RemoteResource>;
+    deleteMemoryStore?(id: string, mode?: ProviderResourceMode): Promise<void>;
+    listMemoryStores?(options?: MemoryStoreListOptions): Promise<MemoryPage<MemoryStoreInfo>>;
+    getMemoryStore?(id: string): Promise<MemoryStoreInfo>;
+    updateMemoryStore?(id: string, input: UpdateMemoryStoreInput, mode?: ProviderResourceMode): Promise<MemoryStoreInfo>;
+    archiveMemoryStore?(id: string): Promise<MemoryStoreInfo>;
+    createMemory?(storeId: string, input: CreateMemoryInput, mode?: ProviderResourceMode): Promise<MemoryInfo>;
+    batchCreateMemories?(storeId: string, input: BatchCreateMemoryInput): Promise<BatchCreateMemoryResult>;
+    listMemories?(storeId: string, options?: MemoryListOptions, mode?: ProviderResourceMode): Promise<MemoryPage<MemoryListItem>>;
+    getMemory?(storeId: string, memoryId: string): Promise<MemoryInfo>;
+    updateMemory?(storeId: string, memoryId: string, input: UpdateMemoryInput, mode?: ProviderResourceMode): Promise<MemoryInfo>;
+    deleteMemory?(storeId: string, memoryId: string, expectedContentSha256?: string): Promise<void>;
+    listMemoryVersions?(storeId: string, options?: MemoryVersionListOptions): Promise<MemoryPage<MemoryVersionInfo>>;
+    getMemoryVersion?(storeId: string, versionId: string): Promise<MemoryVersionInfo>;
+    redactMemoryVersion?(storeId: string, versionId: string): Promise<MemoryVersionInfo>;
+    createDeployment(name: string, decl: DeploymentDecl, refs: ResolvedDeploymentRefs, basePath: string): Promise<RemoteResource>;
+    updateDeployment(id: string, name: string, decl: DeploymentDecl, refs: ResolvedDeploymentRefs, basePath: string, preparedFiles?: ReadonlyMap<string, string>): Promise<RemoteResource>;
+    deleteDeployment(id: string): Promise<void>;
+    runDeployment(ctx: DeploymentContext): Promise<DeploymentRunResult>;
+    getDeployment(ctx: DeploymentContext): Promise<DeploymentInfo>;
+    listDeployments?(filter?: DeploymentListFilter): Promise<DeploymentListResult>;
+    getDeploymentById?(id: string): Promise<DeploymentInfo>;
+    runDeploymentById?(id: string): Promise<DeploymentRunResult>;
+    pauseDeploymentById?(id: string): Promise<DeploymentInfo>;
+    unpauseDeploymentById?(id: string): Promise<DeploymentInfo>;
+    listDeploymentRuns?(deploymentId: string, options?: CursorListOptions): Promise<DeploymentRunPage>;
+    getDeploymentRun?(runId: string): Promise<DeploymentRunInfo>;
+    pauseDeployment?(ctx: DeploymentContext): Promise<DeploymentInfo>;
+    unpauseDeployment?(ctx: DeploymentContext): Promise<DeploymentInfo>;
+    uploadFile(filePath: string, options?: {
+        name?: string;
+        purpose?: string;
+    }, mode?: ProviderResourceMode): 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, mode?: ProviderResourceMode): 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[]>;
+    listFileResources?(options?: FileListOptions): Promise<FilePage>;
+    downloadFileContent?(id: string): Promise<Uint8Array>;
+    /**
+     * 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[]>;
+    listSkillResources?(options?: SkillListOptions): Promise<SkillPage>;
+    /** Fetch a single skill's metadata (incl. scan `status`); used to poll create → active. */
+    getSkillInfo?(id: string): Promise<ProviderSkillInfo>;
+    listSkillVersions?(id: string, options?: SkillVersionListOptions): Promise<SkillVersionPage>;
+    getSkillVersion?(id: string, version: string): Promise<SkillVersionInfo>;
+    getSkillDownloadInfo?(id: string, version: string): Promise<SkillDownloadInfo>;
+    /**
+     * 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>;
+    updateSession?(id: string, input: SessionUpdateInput): Promise<ProviderSessionInfo>;
+    archiveSession?(id: string): Promise<ProviderSessionInfo>;
+    deleteSession(id: string): Promise<void>;
+    sendSessionMessage(sessionId: string, message: string): Promise<string | undefined>;
+    sendSessionEvents?(sessionId: string, events: SessionEventInput[]): Promise<SessionEventSendResult>;
+    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;
+    /** Project-local fallback values; the process environment takes precedence. Never mutates process.env. */
+    environment?: Record<string, string>;
+}
+interface LoadedProjectConfig {
+    configPath: string;
+    projectName: string;
+    config: ResolvedProjectConfig;
+    /** Root config and local files/directories that influence the resolved project. */
+    sourcePaths: string[];
+}
+/**
+ * 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;
+    /** Resolve `${ENV_VAR}` references recursively before schema validation. */
+    resolveEnv?: boolean;
+    /** Project-local fallback values; the process environment takes precedence. */
+    environment?: Record<string, 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;
+    scope?: ResourcePlanScope;
+    mode?: ResourceSyncMode;
+    refresh?: boolean;
+    refreshOnly?: boolean;
+    quiet?: boolean;
+    onFeedback?: RuntimeFeedbackSink;
+    concurrency?: number;
+}
+type ResourceSyncMode = "reconcile" | "create-only";
+interface ResourcePlanScope {
+    roots: ResourceAddress[];
+    includeDependencies?: boolean;
+}
+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[];
+    selectedAddresses?: ResourceAddress[];
+    mode?: ResourceSyncMode;
+}
+type DestructivePolicy = "block" | "prompt" | "force";
+interface DestructiveDecisionOptions {
+    policy?: DestructivePolicy;
+    confirm?: (actions: PlannedAction[]) => boolean | Promise<boolean>;
+}
+interface ResourceSyncRun {
+    planned: ResourcePlanResult;
+    execution?: ResourceExecutionResult;
+}
+declare function planProjectWithStateBackend(input: BackendRuntimeInput, options?: ResourceRuntimeOptions): Promise<ResourcePlanResult>;
+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">;
+
+export { type SkillDecl as $, type AgentVersionListOptions as A, type BackendRuntimeInput as B, type ProviderAdapter as C, type DeploymentContext as D, type EnvironmentListOptions as E, type FileListOptions as F, type MemoryStoreInfo as G, type BatchCreateMemoryInput as H, type BatchCreateMemoryResult as I, type CreateMemoryInput as J, type MemoryInfo as K, type CreateMemoryStoreInput as L, type ManagedAgentProviderCapabilities as M, type MemoryProviderCapabilities as N, type MemoryVersionInfo as O, type ProjectConfig as P, type MemoryListOptions as Q, type ResolvedProjectConfig as R, type SkillFile as S, type MemoryPage as T, type MemoryListItem as U, type VaultListOptions as V, type MemoryStoreListOptions as W, type MemoryVersionListOptions as X, type UpdateMemoryInput as Y, type UpdateMemoryStoreInput as Z, type AgentDecl as _, type ProjectRuntimeContext as a, type ResourcePlanResult as a0, type ResourceSyncMode as a1, type DestructivePolicy as a2, type EnvironmentDecl as a3, type RemoteResource as a4, type VaultDecl as a5, type SessionResourceDecl as a6, type SessionFilter as a7, type SessionBindings as a8, type SessionGithubRepositoryResource as a9, importResource as aA, planProjectContext as aB, planProjectWithStateBackend as aC, readProjectRuntime as aD, resolveProjectConfig as aE, resolveProjectConfigFromObject as aF, syncProjectResourcesWithStateBackend as aG, writeProjectRuntime as aH, type StateBackend as aa, type StateScope as ab, type IStateManager as ac, type CredentialDecl as ad, type CredentialInjectionLocation as ae, type CredentialNetworking as af, type CursorListOptions as ag, type CursorPage as ah, type DeploymentDecl as ai, type LoadedProjectConfig as aj, type ManagedAgentOperationAuth as ak, type ManagedAgentOperationCapability as al, type MemoryPrefixInfo as am, type ResourceActionResult as an, type ResourceExecutionResult as ao, type ResourcePlanScope as ap, type ResourceRefreshResult as aq, type ResourceRuntimeOptions as ar, type ResourceSyncRun as as, type RuntimeFeedbackEvent as at, type SessionListResult as au, StateManager as av, type VaultCredentialInfo as aw, createProjectRuntime as ax, decideDestructive as ay, executePlannedProject as az, type DeploymentRunResult as b, type DeploymentInfo as c, type DeploymentListFilter as d, type DeploymentListResult as e, type ResourceState as f, type ProviderSessionInfo as g, type DeploymentRunInfo as h, type ProviderSkillInfo as i, type SkillDownloadInfo as j, type SkillVersionInfo as k, type AgentPage as l, type AgentListOptions as m, type DeploymentRunPage as n, type EnvironmentPage as o, type FilePage as p, type SkillVersionListOptions as q, type SkillVersionPage as r, type SkillListOptions as s, type SkillPage as t, type VaultPage as u, type SessionEventInput as v, type SessionEventSendResult as w, type SessionUpdateInput as x, type RuntimeFeedbackSink as y, type ModelInfo as z };