@kmlckj/aios-agent-server-sdk 0.0.0-stage → 0.0.2

package/dist/sdk/src/runtime-control.d.ts

@@ -0,0 +1,111 @@
+import type { ResourceSettings, ResourceKey } from '../../cli/daemon/resource-limits.js';
+import type { LocalTaskExecutionState } from '../../shared/local-task-api.js';
+import type { LocalRuntimeTaskState } from '../../shared/local-runtime-api.js';
+import type { DependencyStatus } from './types.js';
+import type { VerifiedRuntime } from './runtime-integrity.js';
+export interface RuntimeHealth {
+    ready: boolean;
+    sampledAt: string;
+    host: {
+        pid: number;
+        node: string;
+        platform: NodeJS.Platform;
+        arch: string;
+        startedAt: string;
+        mode: 'background' | 'managed' | 'embedded' | 'shared-cli';
+    };
+    versions: {
+        sdk: string;
+        protocol: number;
+        dataFormat: number;
+    };
+    /** Only present when the launching SDK verified the signed package and every listed file. */
+    verifiedPackage?: VerifiedRuntime;
+    configurationRevision: string;
+    dependencies: DependencyStatus;
+    limits: RuntimeLimits;
+    activity: RuntimeActivity;
+}
+export interface ManagedHostOptions {
+    /** Explicit grace period and timeout action for shutdown, parent disconnect and termination signals. */
+    shutdown: DrainOptions;
+}
+export interface HostExit {
+    code: number | null;
+    signal: NodeJS.Signals | null;
+}
+export type RuntimeLimits = ResourceSettings;
+export type RuntimeLimitKey = ResourceKey;
+export interface RuntimeActivity {
+    sampledAt: string;
+    phase: 'accepting' | 'draining' | 'drained';
+    readyToShutdown: boolean;
+    activeRuns: Array<{
+        sessionId: string;
+        runId: string;
+    }>;
+    preparations: number;
+    mutations: number;
+    queuedMessages: number;
+    pendingInteractions: number;
+    admission: {
+        dispatching: boolean;
+        deferred: number;
+        stopped: boolean;
+    };
+    memoryBusy: boolean;
+    automation: {
+        running: boolean;
+        scheduled: number;
+    };
+    operations: number;
+    workspaceBusy: boolean;
+    browserLogin: boolean;
+    runtimes: LocalRuntimeTaskState[];
+    executions: Array<LocalTaskExecutionState | import('../../shared/execution-activity.js').OwnedRuntimeActivity>;
+    /** Ready engines without activity telemetry cannot be declared idle. */
+    unobservedSessions: string[];
+    observationErrors: Array<{
+        sessionId: string;
+        message: string;
+    }>;
+    controlsPending: number;
+    requestOperations: number;
+    controlErrors: Array<{
+        operation: string;
+        message: string;
+    }>;
+}
+export type DrainOptions = {
+    timeoutMs: number;
+} & ({
+    onTimeout: 'return';
+} | {
+    onTimeout: 'cancel';
+    cancelTimeoutMs: number;
+});
+export interface DrainResult {
+    status: 'drained' | 'timed_out' | 'failed';
+    cancellationRequested: boolean;
+    activity: RuntimeActivity;
+}
+export interface RuntimeCacheStatus {
+    entries: Array<{
+        path: string;
+        bytes: number;
+        files: number;
+        fingerprint: string;
+        eligible: boolean;
+        reason?: string;
+    }>;
+    bytes: number;
+    maximumBytes: number;
+    overBudget: boolean;
+    revision: string;
+}
+export interface RuntimeCachePruneResult extends RuntimeCacheStatus {
+    applied: boolean;
+    reclaimedBytes: number;
+    removed?: string[];
+    skipped?: RuntimeCacheStatus['entries'];
+}

package/dist/sdk/src/runtime-integrity.d.ts

@@ -0,0 +1,10 @@
+export interface VerifiedRuntime {
+    version: string;
+    protocol: number;
+    dataFormat: number;
+    platform: NodeJS.Platform;
+    arch: string;
+    profile: 'light';
+    manifestSha256: string;
+}
+export declare function validateSdkRuntimeDirectory(directory: string, trustedPublicKey?: string): Promise<VerifiedRuntime>;

package/dist/sdk/src/tool-reference.d.ts

@@ -0,0 +1,11 @@
+export declare function applicationToolProviderId(agent: {
+    id: string;
+    version: string;
+    toolProviderId?: string;
+}): string;
+/** Stable across process restarts; suitable for team tool allowlists. */
+export declare function applicationToolReference(agent: {
+    id: string;
+    version: string;
+    toolProviderId?: string;
+}, name: string): string;

package/dist/sdk/src/tool-result.d.ts

@@ -0,0 +1,36 @@
+/** MCP content supported by the callback provider's negotiated protocol. */
+export type ToolContent = {
+    type: 'text';
+    text: string;
+} | {
+    type: 'image';
+    data: string;
+    mimeType: string;
+} | {
+    type: 'resource';
+    resource: {
+        uri: string;
+        mimeType?: string;
+    } & ({
+        text: string;
+    } | {
+        blob: string;
+    });
+};
+export interface ToolResult {
+    kind: 'aios-tool-result';
+    content: ToolContent[];
+    /** JSON data, including external operation IDs, is also included in model-visible text. */
+    data?: Record<string, unknown>;
+    error?: {
+        code: string;
+        message: string;
+        details?: Record<string, unknown>;
+    };
+}
+/** Opt in to rich results; ordinary strings and JSON return values retain their existing meaning. */
+export declare function toolResult(result: Omit<ToolResult, 'kind'>): ToolResult;
+export declare function encodeToolResult(value: unknown): {
+    content: ToolContent[];
+    isError: boolean;
+};

package/dist/sdk/src/tool-server.d.ts

@@ -0,0 +1,14 @@
+import type { BusinessTool, McpServer } from './types.js';
+/** Application callbacks remain in the application process, using the runtime's MCP pipeline. */
+export declare function serveBusinessTools(id: string, tools: BusinessTool[], resolveFile?: (sessionId: string, path: string, access: 'read' | 'write', signal: AbortSignal) => Promise<import('./file-storage.js').FileReference>): Promise<{
+    descriptor: McpServer;
+    close: () => Promise<void>;
+    closed: Promise<void>;
+    status: () => {
+        retired: boolean;
+        sessions: number;
+        calls: number;
+        closing: boolean;
+    };
+    retire: () => void;
+}>;

package/dist/sdk/src/transport.d.ts

@@ -0,0 +1,25 @@
+import { type SdkServiceMetadata } from './local-connection.js';
+import type { ClientOptions } from './types.js';
+import type { CredentialConnection } from '../../shared/managed-authorization.js';
+import { type VerifiedRuntime } from './runtime-integrity.js';
+export { validateSdkRuntimeDirectory } from './runtime-integrity.js';
+export interface ServiceTransport {
+    readonly eventWaitMs?: number;
+    call<T>(method: string, params?: unknown, id?: string, signal?: AbortSignal): Promise<T>;
+    stop(): Promise<void>;
+    shutdown(): Promise<void>;
+}
+export declare class RuntimeTransport {
+    private readonly metadata;
+    private readonly ownerExit?;
+    private readonly communication?;
+    eventWaitMs: number;
+    private closed;
+    private readonly clientId;
+    private constructor();
+    static start(input: ClientOptions, credentials?: CredentialConnection): Promise<RuntimeTransport>;
+    static attach(options: ClientOptions, metadata: SdkServiceMetadata, verifiedPackage: VerifiedRuntime, credentials?: CredentialConnection, ownerExit?: AbortSignal): Promise<RuntimeTransport>;
+    call<T>(method: string, params?: unknown, id?: `${string}-${string}-${string}-${string}-${string}`, signal?: AbortSignal): Promise<T>;
+    stop(): Promise<void>;
+    shutdown(): Promise<void>;
+}

package/dist/sdk/src/types.d.ts

@@ -0,0 +1,405 @@
+export type { TaskEvent, SessionEvent, SessionEventPage, EventObservationOptions, TaskInteraction, TaskMessage, HistoryQuery, HistoryPage, RunQuery, RunRecord, RunPage, RunState, QueueSnapshot } from '../../shared/sdk-session-contract.js';
+import type { BuiltinSelection, BuiltinSnapshot, CapabilityDescriptor } from '../../shared/agent-capabilities.js';
+import type { AuthSession, AuthPasswordChangeRequired } from '../../shared/desktop-api.js';
+import type { CredentialProvider, ManagedAuthentication } from '../../shared/managed-authorization.js';
+export type { TeamState, TeamMemberState, TeamTaskState, TeamCommand, TeamCommandResult } from '../../shared/team-control.js';
+export type { ExpertSelection, PreparedExpertAgent, ResolvedExpertSource } from '../../shared/expert-selection.js';
+export type { ManagedAuthentication, ManagedPrincipal, ManagedCredential, ManagedCredentialRequest, CredentialProvider, CredentialReason, ManagedAuthorizationEvent } from '../../shared/managed-authorization.js';
+export type { BuiltinSelection, BuiltinSnapshot, CapabilityDescriptor, ToolCategory, SkillCategory } from '../../shared/agent-capabilities.js';
+export type { AuthSession, PlatformUser, TenantSummary, LoginContext, AuthRequiredPasswordChangeRequest, AuthSwitchSubjectRequest } from '../../shared/desktop-api.js';
+export type { AvailableChatModel } from '../../shared/cloud-assistant-api.js';
+export type { AccountContextSummary, AccountContextQuery } from '../../shared/account-context-api.js';
+export type { PersonalUsageStatistics } from '../../shared/usage-statistics-api.js';
+export type { EnterpriseKnowledgeBase, EnterpriseKnowledgeSearchQuery, EnterpriseKnowledgeSearchResult, EnterpriseKnowledgeDocument, EnterpriseKnowledgeTreeResult } from '../../shared/enterprise-knowledge-api.js';
+export type { SkillMarketItem, SkillMarketDetail, SkillMarketSearchQuery, SkillMarketSearchResult } from '../../shared/skill-market-api.js';
+export type { PluginMarketItem, PluginMarketDetail, PluginMarketListQuery, PluginMarketListResult } from '../../shared/plugin-market-api.js';
+export type { PluginAuthorizationStatus, PluginAuthorizationDefinition, PluginAuthorizationSaveRequest } from '../../shared/plugin-market-api.js';
+export type { LocalPluginInstallation } from '../../shared/local-plugin-api.js';
+export type { SkillVersionSelection, SkillVersionUpdate } from '../../core/skills/skill-versions.js';
+export interface SkillVersionInfo {
+    binding: import('../../core/skills/skill-bindings.js').SkillBinding;
+    current: import('../../shared/local-task-api.js').LocalTaskSkillReference;
+}
+export type SkillVersionUpdateResult = Awaited<ReturnType<typeof import('../../core/skills/skill-versions.js').updateSkillVersion>>;
+export interface PluginUpdateResult {
+    changed: boolean;
+    before: {
+        recordId: string;
+        version?: string | null;
+    };
+    installation: import('../../shared/local-plugin-api.js').LocalPluginInstallation;
+}
+export interface ExternalModel {
+    generationCapabilities?: import('../../shared/runtime-tuning.js').GenerationCapabilities;
+    id: string;
+    endpoint: string;
+    model: string;
+    protocol: 'chat_completions' | 'responses';
+    apiKey?: string;
+    contextWindow: number;
+    maxOutputTokens?: number;
+    functionCalling: boolean;
+    imageInput?: boolean;
+    reasoning?: boolean;
+}
+export interface RuntimeOptions {
+    /** Omit to use the matching runtime installed with this npm package. */
+    directory?: string;
+    dataDirectory: string;
+    /** Optional storage bases. Each uses the same app/principal partition as dataDirectory. */
+    workspaceDirectory?: string;
+    cacheDirectory?: string;
+    temporaryDirectory?: string;
+    nodeExecutable?: string;
+    tools?: Partial<Record<'node' | 'python' | 'git' | 'bash' | 'npm', string>>;
+    /** Override only for a runtime built and signed by your own organization. */
+    trustedPublicKey?: string;
+}
+/** Attach to an already running CLI; never starts, installs or stops that service. */
+export interface CliConnectionOptions {
+    dataDirectory: string;
+    appId: string;
+    userScope: string;
+    appName?: string;
+    builtins?: BuiltinSelection;
+}
+export interface NetworkOptions {
+    proxyMode: 'off' | 'system' | 'custom';
+    proxyUrl: string;
+    caFile: string;
+    noProxy: string;
+}
+interface CommonOptions {
+    authorization?: {
+        required: boolean;
+    };
+    memory?: import('../../shared/memory-customization.js').MemoryConfiguration;
+    /** Explicit host declarations, keyed by platform model code. Unlisted parameters are rejected. */
+    generationCapabilities?: Record<string, import('../../shared/runtime-tuning.js').GenerationCapabilities>;
+    appId: string;
+    userScope: string;
+    appName?: string;
+    runtime: RuntimeOptions;
+    builtins?: BuiltinSelection;
+    network?: NetworkOptions;
+    communication?: import('./communication.js').CommunicationOptions;
+}
+export type ClientOptions = CommonOptions & ({
+    mode: 'platform';
+    platformBaseUrl: string;
+    environment?: 'dev' | 'prod';
+    /** Omit for SDK-managed interactive login. Managed mode never stores platform credentials. */
+    authentication?: ManagedAuthentication;
+} | {
+    mode: 'standalone';
+    models: ExternalModel[];
+});
+export type ResolvedClientOptions = ClientOptions & {
+    runtime: RuntimeOptions & {
+        directory: string;
+    };
+};
+export interface ClientServices {
+    credentials?: CredentialProvider;
+    diagnostics?: import('./diagnostics.js').DiagnosticSink;
+    memoryStore?: import('../../shared/memory-customization.js').MemoryStoreAdapter;
+    authorize?: import('./authorization.js').SessionAuthorizer;
+}
+export interface ToolContext {
+    files?: {
+        resolve(path: string, access: 'read' | 'write'): Promise<import('./file-storage.js').FileReference>;
+    };
+    signal: AbortSignal;
+    callId: string;
+    /** Present on calls dispatched by the SDK execution engine; not model arguments. */
+    execution?: Readonly<import('../../shared/execution-context.js').ExecutionBinding & {
+        invocationId: string;
+    }>;
+}
+export interface BusinessTool {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+    readOnly: boolean;
+    execute(input: Record<string, unknown>, context: ToolContext): unknown | Promise<unknown>;
+}
+export interface McpServer {
+    id: string;
+    name: string;
+    transport: 'HTTP' | 'STDIO';
+    url?: string;
+    bearerToken?: string;
+    command?: string;
+    args?: string[];
+    env?: Record<string, string>;
+    tools?: string[];
+    defaultToolsApproval?: 'auto' | 'prompt';
+    toolApprovals?: Record<string, 'auto' | 'prompt'>;
+}
+export interface ExecutionDefaults {
+    runtimeTuning?: import('../../shared/runtime-tuning.js').RuntimeTuning;
+    model: string;
+    mode?: 'agent' | 'plan' | 'chat';
+    permissionMode?: 'ask_dangerous' | 'allow_all';
+    thinkingEnabled?: boolean;
+    reasoningEffort?: import('../../shared/model-selection.js').ModelReasoningEffort;
+    /** Requested window; the shared model policy validates it against the model capacity. */
+    contextWindow?: number;
+}
+export interface AgentDefinition extends ExecutionDefaults {
+    jsHooks?: Partial<Record<'beforeTool' | 'afterTool', {
+        matcher?: string;
+        timeoutMs?: number;
+        execute(event: Readonly<import('../../shared/js-agent-hooks.js').ToolLifecycleEvent>, context: {
+            signal: AbortSignal;
+        }): void | import('../../shared/js-agent-hooks.js').ToolHookDecision | Promise<void | import('../../shared/js-agent-hooks.js').ToolHookDecision>;
+    }>>;
+    /** Serializable lifecycle policy returned by session configuration. */
+    jsHookDefinitions?: import('../../shared/js-agent-hooks.js').JsHookDefinition[];
+    team?: import('../../shared/agent-team.js').AgentTeamDefinition;
+    id: string;
+    version: string;
+    name: string;
+    instructions: string;
+    rules?: import('../../shared/session-policy.js').ApplicationRule[];
+    profile?: import('../../shared/execution-profile.js').ExecutionProfile;
+    hooks?: import('../../shared/agent-hooks.js').AgentCommandHook[];
+    builtins?: BuiltinSelection;
+    tools?: BusinessTool[];
+    /** Stable logical identity, independent of the callback URL and secret. */
+    toolProviderId?: string;
+    mcpServers?: McpServer[];
+    skills?: import('../../shared/local-task-api.js').LocalTaskSkillReference[];
+    plugins?: import('../../shared/local-task-api.js').LocalTaskPluginReference[];
+}
+export type { LocalSkillDefinition } from '../../shared/local-skill-api.js';
+export type { ExecutionProfile } from '../../shared/execution-profile.js';
+export type { AgentCommandHook } from '../../shared/agent-hooks.js';
+export type { AgentTeamDefinition, AgentTeamMember } from '../../shared/agent-team.js';
+export type { TaskPathPolicy } from '../../shared/task-path-policy.js';
+export type { TaskOperationReference, TaskOperationSnapshot } from '../../shared/task-operation.js';
+export type { ExecutionContext, ExecutionBinding } from '../../shared/execution-context.js';
+export type { SessionScopePolicy, SessionMemoryPolicy, RunMemoryPolicy, ApplicationRule } from '../../shared/session-policy.js';
+export interface SessionCreateOptions {
+    name?: string;
+    workspacePath?: string;
+    creationId?: string;
+    policy?: import('../../shared/session-policy.js').SessionScopePolicy;
+}
+export type { ArtifactEvidence, ArtifactVerification } from '../../shared/artifact-evidence.js';
+export interface ArtifactQuery {
+    runId?: string;
+    query?: string;
+    type?: import('../../shared/local-task-api.js').LocalTaskArtifactType;
+    limit?: number;
+}
+export type SessionArtifact = import('../../shared/local-task-api.js').LocalTaskArtifact & {
+    /** Latest observed reference, or workspace-only when no execution evidence exists. */
+    source: {
+        kind: 'execution' | 'workspace';
+        eventId?: string;
+        runId?: string;
+        threadId?: string;
+        tool?: string;
+        at?: string;
+    };
+    evidence: import('../../shared/artifact-evidence.js').ArtifactEvidence[];
+    operations: import('../../shared/task-operation.js').TaskOperationReference[];
+};
+export interface SessionInfo {
+    id: string;
+    name: string;
+    workspacePath: string;
+    status: string;
+    metadataRevision: string;
+    createdAt: string;
+    updatedAt: string;
+    archivedAt?: string;
+}
+export interface SessionConfiguration {
+    revision: number;
+    agent: Omit<AgentDefinition, 'tools' | 'mcpServers' | 'jsHooks'>;
+    builtins: BuiltinSnapshot;
+    defaults: ExecutionDefaults;
+    policy?: import('../../shared/session-policy.js').SessionScopePolicy;
+    parent?: {
+        sessionId: string;
+        memberId: string;
+        configurationRevision: number;
+    };
+}
+export interface SessionAgentUpdate {
+    agentId: string;
+    agentVersion: string;
+    expectedRevision: number;
+}
+export interface ProviderStatus {
+    agentId: string;
+    agentVersion: string;
+    /** Registration status only; does not assert that an external MCP server is reachable. */
+    status: 'registered' | 'unregistered';
+    providers: Array<{
+        id: string;
+        name: string;
+    }>;
+    ownedByCaller: boolean;
+}
+export interface ConfigurationUpdate {
+    authorization?: {
+        required: boolean;
+    };
+    memory?: import('../../shared/memory-customization.js').MemoryConfiguration;
+    generationCapabilities?: Record<string, import('../../shared/runtime-tuning.js').GenerationCapabilities>;
+    communication?: import('./communication.js').CommunicationOptions;
+    runtime?: RuntimeOptions;
+    builtins?: BuiltinSelection;
+    network?: NetworkOptions;
+    platformBaseUrl?: string;
+    models?: ExternalModel[];
+}
+export interface ClientConfiguration {
+    authorization?: {
+        required: boolean;
+    };
+    memory?: import('../../shared/memory-customization.js').MemoryConfiguration;
+    generationCapabilities?: Record<string, import('../../shared/runtime-tuning.js').GenerationCapabilities>;
+    communication?: import('./communication.js').CommunicationOptions;
+    mode: ClientOptions['mode'];
+    appId: string;
+    userScope: string;
+    appName: string;
+    runtime: RuntimeOptions;
+    paths: {
+        contextDirectory: string;
+        resourcesDirectory: string;
+        tasksDirectory: string;
+        workspacesDirectory: string;
+        temporaryDirectory: string;
+        cacheDirectory: string;
+    };
+    builtins: BuiltinSnapshot;
+    network: NetworkOptions;
+    platformBaseUrl?: string;
+    models?: Array<Omit<ExternalModel, 'apiKey'> & {
+        apiKeyConfigured: boolean;
+    }>;
+    authentication?: ManagedAuthentication;
+}
+export type DependencyStatus = import('../../core/host/runtime-dependencies.js').ResolvedRuntimeDependencies;
+export type LocalPreferences = import('../../cli/daemon/preferences.js').Preferences;
+export type LocalPreferenceDomain = import('../../cli/daemon/preferences.js').PreferenceDomain | 'securityPolicy';
+export type { ComputerUseSettings } from '../../shared/computer-use-api.js';
+export type { NativeSettings, NativeCapabilityStatus } from './native-status.js';
+export type { MemoryView, MemoryEditRequest } from '../../shared/local-memory.js';
+export interface SessionMemoryApi {
+    get(request: import('../../shared/local-memory.js').MemoryContextRequest & {
+        sessionId: string;
+    }): Promise<import('../../shared/local-memory.js').MemoryView>;
+    edit(request: import('../../shared/local-memory.js').MemoryEditRequest & {
+        sessionId: string;
+    }): Promise<import('../../shared/local-memory.js').MemoryView>;
+    reset(request: {
+        sessionId: string;
+    }): Promise<import('../../shared/local-memory.js').MemoryView>;
+    setEnabled(request: {
+        sessionId: string;
+        enabled: boolean;
+    }): Promise<import('../../shared/local-memory.js').MemoryView>;
+}
+export interface AuthTokens {
+    accessToken: string;
+    refreshToken: string;
+    accessTokenExpiresAt: string;
+    platformBaseUrl: string;
+}
+export type CredentialStoreOptions = {
+    kind: 'session' | 'system';
+} | {
+    kind: 'vault';
+    secret: string;
+};
+export type LoginRequest = {
+    loginType: 'USERNAME' | 'PHONE';
+    account: string;
+    password: string;
+    countryCode?: string;
+    credentialStore?: CredentialStoreOptions;
+};
+export type LoginResult = {
+    status: 'authenticated';
+    tokens: AuthTokens;
+    session: AuthSession;
+} | {
+    status: 'challenge';
+    challenge: AuthPasswordChangeRequired;
+};
+export interface AuthStatus {
+    session: AuthSession | null;
+    credentialStore: {
+        kind: 'session' | 'vault' | 'system' | 'managed';
+        configured: boolean;
+        locked: boolean;
+    };
+    restoration: {
+        state: 'ready' | 'restoring';
+    } | {
+        state: 'failed';
+        code: string;
+        message: string;
+    };
+}
+export interface BrowserLoginOptions {
+    requestId?: string;
+    credentialStore?: CredentialStoreOptions;
+}
+export interface BrowserLoginStatus {
+    id: string;
+    state: 'starting' | 'waiting' | 'completed' | 'cancelled' | 'failed';
+    authorizationUrl?: string;
+    session?: AuthSession;
+    error?: {
+        code: string;
+        message: string;
+        exitCode: number;
+    };
+}
+export interface SendOptions extends Partial<ExecutionDefaults> {
+    /** Selected scene and its implicit resources, preserved in this turn's history and queue. */
+    sceneContext?: import('../../shared/local-task-api.js').LocalTaskSceneContext;
+    /** Narrow this run's long-term memory access within the session grant. */
+    memory?: import('../../shared/session-policy.js').RunMemoryPolicy;
+    /** Trusted host metadata. Immutable for this run, including queued dispatch and continuations. */
+    context?: import('../../shared/execution-context.js').ExecutionContext;
+    /** Default is background. Foreground is cancelled if the submitting process exits unexpectedly. */
+    execution?: 'foreground' | 'background';
+    /** 0 for unlimited; otherwise 1000..604800000 ms. */
+    timeoutMs?: number;
+    commandId?: string;
+    attachments?: Array<{
+        path: string;
+    }>;
+    attachmentIds?: string[];
+    references?: import('../../shared/local-task-api.js').LocalTaskFileReference[];
+    richContent?: import('../../shared/local-task-api.js').LocalTaskRichContent;
+    skills?: import('../../shared/local-task-api.js').LocalTaskSkillReference[];
+    plugins?: import('../../shared/local-task-api.js').LocalTaskPluginReference[];
+}
+export type CommandReceipt = import('../../shared/local-task-command.js').LocalTaskCommandReply | null;
+export type CommandResult = import('../../shared/local-task-command.js').LocalTaskCommandResult;
+export interface CapabilityQuery {
+    kind?: 'tool' | 'skill';
+    category?: string;
+    enabled?: boolean;
+    available?: boolean;
+    source?: CapabilityDescriptor['source'];
+}
+export interface EffectiveCapability extends CapabilityDescriptor {
+    enabled: boolean;
+    available: boolean;
+    reason?: string;
+    operations?: Array<{
+        id: string;
+        available: boolean;
+        reason?: string;
+    }>;
+}

package/dist/shared/account-context-api.d.ts

@@ -0,0 +1,47 @@
+export interface AccountCreditSourceBalance {
+    sourceType: string | null;
+    initialPoints: number | null;
+    remainingPoints: number | null;
+    frozenPoints: number | null;
+    nearestExpiresAt: string | null;
+}
+export interface AccountContextSummary {
+    availableBalance: number | null;
+    planName: string | null;
+    planId?: string | null;
+    totalBalance?: number | null;
+    planLevel?: string | null;
+    planStatus?: string | null;
+    subscriptionId?: string | null;
+    subscriptionPlanId?: string | null;
+    subscriptionStatus?: string | null;
+    subscriptionValidFrom?: string | null;
+    subscriptionValidTo?: string | null;
+    subscriptionRemainingDays?: number | null;
+    sourceBalances?: AccountCreditSourceBalance[];
+}
+export type AccountReferralActivityStatus = 'TECHNICAL_DISABLED' | 'DISABLED' | 'UNPUBLISHED' | 'SCHEDULED' | 'ACTIVE' | 'ENDED';
+export interface AccountReferralCampaign {
+    technicalEnabled: boolean;
+    rewardEnabled: boolean;
+    activityStatus: AccountReferralActivityStatus;
+    registerRewardPoints: number | null;
+}
+export interface AccountPlanPurchase {
+    id: string;
+    planId: string;
+    planName: string;
+    subscriptionId: string | null;
+    purchasedAt: string;
+    expiresAt: string | null;
+    pointsGranted: number | null;
+    pointsRemaining: number | null;
+}
+export interface AccountContextQuery {
+    subjectName?: string;
+}
+export interface AccountContextApi {
+    getSummary: (query?: AccountContextQuery) => Promise<AccountContextSummary>;
+    getReferralCampaign: () => Promise<AccountReferralCampaign>;
+    listPlanPurchases: () => Promise<AccountPlanPurchase[]>;
+}