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

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>;
+}