@moorline/contracts 0.0.1

package/dist/provider.d.ts

@@ -0,0 +1,89 @@
+import type { JsonSchemaLike, PackageDependency, PackageManifestBase } from './package.js';
+import type { EventEmitter } from 'node:events';
+import type { ProviderPackageId, ProviderInputImage, ProviderRuntimeEvent, ProviderSessionRecord, RuntimeCommandRunner, RuntimeModeName } from './runtime.js';
+export interface ProviderPackageManifest extends PackageManifestBase {
+    type: 'provider';
+    entrypoint?: string;
+    dependencies?: PackageDependency[];
+    configSchema?: JsonSchemaLike;
+    displayCategory?: string;
+}
+export interface RuntimeProviderPackageContext {
+    config: Record<string, unknown>;
+    commandRunner?: RuntimeCommandRunner;
+}
+export interface RuntimeProviderDiagnostics {
+    accountLabel: string | null;
+    availableModels: string[];
+    connectedSessions: number;
+    statusCounts: Record<string, number>;
+    capabilityMetadata: Record<string, unknown>;
+}
+export interface RuntimeProviderTestResult {
+    ok: boolean;
+    message: string;
+    remediation?: string;
+    accountLabel: string | null;
+    availableModels: string[];
+    sentTurn: boolean;
+    error?: string;
+}
+export interface RuntimeProviderSessionInput {
+    sessionId: string;
+    threadId: string;
+    spaceId: string;
+    runtimeMode: RuntimeModeName;
+    workspacePath: string;
+    resumeThreadId: string | null;
+    lifecycleStatus: string;
+    providerAutoStartEnabled?: boolean;
+}
+export interface RuntimeProvider extends EventEmitter<{
+    providerEvent: [event: ProviderRuntimeEvent];
+}> {
+    listSessions(): ProviderSessionRecord[];
+    getDiagnostics(): RuntimeProviderDiagnostics;
+    startOrResumeSession(input: {
+        session: RuntimeProviderSessionInput;
+        runtimeRoot: string;
+        actor: string;
+        model?: string;
+    }): Promise<ProviderSessionRecord>;
+    recoverSessions(input: {
+        sessions: RuntimeProviderSessionInput[];
+        runtimeRoot: string;
+        model?: string;
+    }): Promise<void>;
+    testConnection?(input: {
+        runtimeRoot: string;
+        actor: string;
+        model?: string;
+        sendTurn?: boolean;
+        prompt?: string;
+    }): Promise<RuntimeProviderTestResult>;
+    sendTurn(threadId: string, input: {
+        text: string;
+        images?: ProviderInputImage[];
+    }, model?: string): Promise<{
+        turnId: string;
+    }>;
+    compactThread(threadId: string): Promise<void>;
+    respondToRequest(threadId: string, requestId: string, decision: 'accept' | 'acceptForSession' | 'decline' | 'cancel'): Promise<void>;
+    respondToUserInput(threadId: string, requestId: string, answers: Record<string, string | string[]>): Promise<void>;
+    interruptTurn(threadId: string): Promise<void>;
+    drain(): Promise<void>;
+    stopSession(threadId: string): void;
+    stopAll(): void;
+}
+export interface RuntimeProviderFactoryContext {
+    providerPackageId: ProviderPackageId;
+}
+export type RuntimeProviderFactory = (input: RuntimeProviderFactoryContext) => RuntimeProvider;
+export type RuntimeEnvironmentVerifier = () => Promise<void>;
+export interface RuntimeProviderPackage {
+    manifest: ProviderPackageManifest;
+    createProviderFactory(input: RuntimeProviderPackageContext): RuntimeProviderFactory;
+    createEnvironmentVerifier?(input: RuntimeProviderPackageContext): RuntimeEnvironmentVerifier | null;
+}
+export declare function validateProviderPackageManifest(manifest: ProviderPackageManifest): ProviderPackageManifest;
+export declare function validateProviderPackageRuntimeContract(pkg: RuntimeProviderPackage): void;

package/dist/provider.js

@@ -0,0 +1,43 @@
+import { validateJsonSchemaLike, validatePackageActivationRule, validatePackageDependencies, validatePackageId } from './package.js';
+export function validateProviderPackageManifest(manifest) {
+    if (!manifest || typeof manifest !== 'object' || Array.isArray(manifest)) {
+        throw new Error('Provider package manifest must be an object');
+    }
+    const record = manifest;
+    validatePackageId(record.id, 'Provider package manifest id');
+    if (typeof record.name !== 'string' || !record.name.trim()) {
+        throw new Error('Provider package manifest name is required');
+    }
+    if (typeof record.version !== 'string' || !record.version.trim()) {
+        throw new Error('Provider package manifest version is required');
+    }
+    if (record.type !== 'provider') {
+        throw new Error('Provider package manifest type must be "provider"');
+    }
+    if (record.description !== undefined && (typeof record.description !== 'string' || !record.description.trim())) {
+        throw new Error('Provider package manifest description must be non-empty when provided');
+    }
+    if (record.entrypoint !== undefined && (typeof record.entrypoint !== 'string' || !record.entrypoint.trim())) {
+        throw new Error('Provider package manifest entrypoint must be non-empty when provided');
+    }
+    if (record.displayCategory !== undefined &&
+        (typeof record.displayCategory !== 'string' || !record.displayCategory.trim())) {
+        throw new Error('Provider package manifest displayCategory must be non-empty when provided');
+    }
+    validatePackageDependencies(record.dependencies, 'provider package manifest');
+    validateJsonSchemaLike(record.configSchema, 'provider package manifest');
+    const activation = validatePackageActivationRule(record.activation, 'provider package manifest');
+    return {
+        ...manifest,
+        ...(activation !== undefined ? { activation } : {})
+    };
+}
+export function validateProviderPackageRuntimeContract(pkg) {
+    if (typeof pkg.createProviderFactory !== 'function') {
+        throw new Error(`Provider package ${pkg.manifest.id} must implement createProviderFactory`);
+    }
+    if (pkg.createEnvironmentVerifier !== undefined && typeof pkg.createEnvironmentVerifier !== 'function') {
+        throw new Error(`Provider package ${pkg.manifest.id} exported invalid createEnvironmentVerifier`);
+    }
+}
+//# sourceMappingURL=provider.js.map

package/dist/provider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider.js","sourceRoot":"","sources":["../src/provider.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,sBAAsB,EAAE,6BAA6B,EAAE,2BAA2B,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAuGrI,MAAM,UAAU,+BAA+B,CAAC,QAAiC;IAC/E,IAAI,CAAC,QAAQ,IAAI,OAAO,QAAQ,KAAK,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC;QACzE,MAAM,IAAI,KAAK,CAAC,6CAA6C,CAAC,CAAC;IACjE,CAAC;IACD,MAAM,MAAM,GAAG,QAA8C,CAAC;IAC9D,iBAAiB,CAAC,MAAM,CAAC,EAAE,EAAE,8BAA8B,CAAC,CAAC;IAC7D,IAAI,OAAO,MAAM,CAAC,IAAI,KAAK,QAAQ,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE,EAAE,CAAC;QAC3D,MAAM,IAAI,KAAK,CAAC,4CAA4C,CAAC,CAAC;IAChE,CAAC;IACD,IAAI,OAAO,MAAM,CAAC,OAAO,KAAK,QAAQ,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC;QACjE,MAAM,IAAI,KAAK,CAAC,+CAA+C,CAAC,CAAC;IACnE,CAAC;IACD,IAAI,MAAM,CAAC,IAAI,KAAK,UAAU,EAAE,CAAC;QAC/B,MAAM,IAAI,KAAK,CAAC,mDAAmD,CAAC,CAAC;IACvE,CAAC;IACD,IAAI,MAAM,CAAC,WAAW,KAAK,SAAS,IAAI,CAAC,OAAO,MAAM,CAAC,WAAW,KAAK,QAAQ,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,IAAI,EAAE,CAAC,EAAE,CAAC;QAC/G,MAAM,IAAI,KAAK,CAAC,uEAAuE,CAAC,CAAC;IAC3F,CAAC;IACD,IAAI,MAAM,CAAC,UAAU,KAAK,SAAS,IAAI,CAAC,OAAO,MAAM,CAAC,UAAU,KAAK,QAAQ,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,IAAI,EAAE,CAAC,EAAE,CAAC;QAC5G,MAAM,IAAI,KAAK,CAAC,sEAAsE,CAAC,CAAC;IAC1F,CAAC;IACD,IACE,MAAM,CAAC,eAAe,KAAK,SAAS;QACpC,CAAC,OAAO,MAAM,CAAC,eAAe,KAAK,QAAQ,IAAI,CAAC,MAAM,CAAC,eAAe,CAAC,IAAI,EAAE,CAAC,EAC9E,CAAC;QACD,MAAM,IAAI,KAAK,CAAC,2EAA2E,CAAC,CAAC;IAC/F,CAAC;IACD,2BAA2B,CAAC,MAAM,CAAC,YAAY,EAAE,2BAA2B,CAAC,CAAC;IAC9E,sBAAsB,CAAC,MAAM,CAAC,YAAY,EAAE,2BAA2B,CAAC,CAAC;IACzE,MAAM,UAAU,GAAG,6BAA6B,CAAC,MAAM,CAAC,UAAU,EAAE,2BAA2B,CAAC,CAAC;IACjG,OAAO;QACL,GAAG,QAAQ;QACX,GAAG,CAAC,UAAU,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;KACpD,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,sCAAsC,CAAC,GAA2B;IAChF,IAAI,OAAO,GAAG,CAAC,qBAAqB,KAAK,UAAU,EAAE,CAAC;QACpD,MAAM,IAAI,KAAK,CAAC,oBAAoB,GAAG,CAAC,QAAQ,CAAC,EAAE,uCAAuC,CAAC,CAAC;IAC9F,CAAC;IACD,IAAI,GAAG,CAAC,yBAAyB,KAAK,SAAS,IAAI,OAAO,GAAG,CAAC,yBAAyB,KAAK,UAAU,EAAE,CAAC;QACvG,MAAM,IAAI,KAAK,CAAC,oBAAoB,GAAG,CAAC,QAAQ,CAAC,EAAE,6CAA6C,CAAC,CAAC;IACpG,CAAC;AACH,CAAC"}

package/dist/runtime.d.ts

@@ -0,0 +1,176 @@
+export interface CommandResult {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+}
+export interface RuntimeCommandRunner {
+    run(command: string, args: string[], cwd?: string): Promise<CommandResult>;
+}
+export type RuntimeModeName = 'full-access' | 'approval-required';
+export declare function parseRuntimeModeName(value: unknown, label?: string): RuntimeModeName;
+export type ProviderPackageId = string;
+export type ProviderSessionStatus = 'connecting' | 'ready' | 'running' | 'waiting' | 'error' | 'closed';
+export interface ProviderAccountMetadata {
+    accountLabel: string | null;
+    availableModels: string[];
+}
+export type ProviderInputImage = {
+    url: string;
+} | {
+    localPath: string;
+};
+export type ProviderMessagePhase = 'commentary' | 'final_answer';
+export interface ProviderThreadTokenUsage {
+    totalTokens: number;
+    lastTurnTokens: number | null;
+    modelContextWindow: number | null;
+}
+export type CanonicalItemType = 'assistant_message' | 'reasoning' | 'plan' | 'command_execution' | 'file_change' | 'web_search' | 'image_view' | 'dynamic_tool_call' | 'error' | 'unknown';
+export type CanonicalRequestType = 'command_execution_approval' | 'file_read_approval' | 'file_change_approval' | 'apply_patch_approval' | 'exec_command_approval' | 'tool_user_input' | 'dynamic_tool_call' | 'auth_tokens_refresh' | 'unknown';
+export type ProviderApprovalDecision = 'accept' | 'acceptForSession' | 'decline' | 'cancel';
+export interface ProviderSessionRecord {
+    providerPackageId: ProviderPackageId;
+    provider?: ProviderPackageId;
+    providerSessionKind?: string;
+    capabilities?: Record<string, unknown>;
+    nativeMetadata?: Record<string, unknown>;
+    threadId: string;
+    runtimeMode: RuntimeModeName;
+    cwd: string;
+    model?: string;
+    status: ProviderSessionStatus;
+    activeTurnId?: string;
+    resumeCursor?: {
+        threadId: string;
+    };
+    createdAt: string;
+    updatedAt: string;
+    lastError?: string;
+}
+export interface ProviderRuntimeEventBase {
+    eventId: string;
+    providerPackageId: ProviderPackageId;
+    provider?: ProviderPackageId;
+    providerSessionKind?: string;
+    capabilities?: Record<string, unknown>;
+    nativeMetadata?: Record<string, unknown>;
+    threadId: string;
+    createdAt: string;
+    turnId?: string;
+    itemId?: string;
+    requestId?: string;
+}
+export type ProviderRuntimeEvent = (ProviderRuntimeEventBase & {
+    type: 'provider.metadata.updated';
+    payload: ProviderAccountMetadata;
+}) | (ProviderRuntimeEventBase & {
+    type: 'session.state.changed';
+    payload: {
+        state: ProviderSessionStatus;
+        reason?: string;
+    };
+}) | (ProviderRuntimeEventBase & {
+    type: 'thread.started';
+    payload: {
+        providerThreadId: string;
+    };
+}) | (ProviderRuntimeEventBase & {
+    type: 'thread.state.changed';
+    payload: {
+        state: 'open' | 'archived' | 'closed' | 'compacted';
+        detail?: unknown;
+    };
+}) | (ProviderRuntimeEventBase & {
+    type: 'thread.token-usage.updated';
+    payload: ProviderThreadTokenUsage;
+}) | (ProviderRuntimeEventBase & {
+    type: 'turn.started';
+    payload: {
+        model?: string;
+        effort?: string;
+    };
+}) | (ProviderRuntimeEventBase & {
+    type: 'turn.completed';
+    payload: {
+        state: 'completed' | 'failed' | 'cancelled' | 'interrupted';
+        stopReason?: string;
+        errorMessage?: string;
+    };
+}) | (ProviderRuntimeEventBase & {
+    type: 'turn.aborted';
+    payload: {
+        reason: string;
+    };
+}) | (ProviderRuntimeEventBase & {
+    type: 'content.delta';
+    payload: {
+        streamKind: 'assistant_text';
+        delta: string;
+    };
+}) | (ProviderRuntimeEventBase & {
+    type: 'item.started' | 'item.completed';
+    payload: {
+        itemType: CanonicalItemType;
+        title?: string;
+        detail?: string;
+        status?: string;
+        localPath?: string;
+        phase?: ProviderMessagePhase;
+    };
+}) | (ProviderRuntimeEventBase & {
+    type: 'request.opened';
+    payload: {
+        requestType: CanonicalRequestType;
+        detail?: string;
+        args?: unknown;
+        parameterKeys?: string[];
+        parameterSummary?: Record<string, unknown>;
+    };
+}) | (ProviderRuntimeEventBase & {
+    type: 'request.resolved';
+    payload: {
+        requestType: CanonicalRequestType;
+        decision?: ProviderApprovalDecision;
+        resolution?: unknown;
+    };
+}) | (ProviderRuntimeEventBase & {
+    type: 'user-input.requested';
+    payload: {
+        questions: Array<{
+            id: string;
+            header: string;
+            question: string;
+            options: Array<{
+                label: string;
+                description: string;
+            }>;
+        }>;
+    };
+}) | (ProviderRuntimeEventBase & {
+    type: 'user-input.resolved';
+    payload: {
+        answers: Record<string, string | string[]>;
+    };
+}) | (ProviderRuntimeEventBase & {
+    type: 'runtime.warning' | 'runtime.error';
+    payload: {
+        message: string;
+        class?: string;
+        detail?: unknown;
+    };
+});
+export interface PendingRuntimeRequestRecord {
+    requestId: string;
+    threadId: string;
+    turnId: string | null;
+    spaceId: string;
+    requesterUserId: string | null;
+    messageId: string | null;
+    requestType: CanonicalRequestType;
+    status: 'open' | 'resolved';
+    detail: string | null;
+    questionsJson: string | null;
+    decision: ProviderApprovalDecision | null;
+    createdAt: string;
+    resolvedAt: string | null;
+}

package/dist/runtime.js

@@ -0,0 +1,11 @@
+const RUNTIME_MODE_NAMES = ['full-access', 'approval-required'];
+function isRuntimeModeName(value) {
+    return value === 'full-access' || value === 'approval-required';
+}
+export function parseRuntimeModeName(value, label = 'runtime_mode') {
+    if (isRuntimeModeName(value)) {
+        return value;
+    }
+    throw new Error(`${label} must be one of: ${RUNTIME_MODE_NAMES.join(', ')}.`);
+}
+//# sourceMappingURL=runtime.js.map

package/dist/runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.js","sourceRoot":"","sources":["../src/runtime.ts"],"names":[],"mappings":"AAYA,MAAM,kBAAkB,GAAsB,CAAC,aAAa,EAAE,mBAAmB,CAAC,CAAC;AAEnF,SAAS,iBAAiB,CAAC,KAAc;IACvC,OAAO,KAAK,KAAK,aAAa,IAAI,KAAK,KAAK,mBAAmB,CAAC;AAClE,CAAC;AAED,MAAM,UAAU,oBAAoB,CAAC,KAAc,EAAE,KAAK,GAAG,cAAc;IACzE,IAAI,iBAAiB,CAAC,KAAK,CAAC,EAAE,CAAC;QAC7B,OAAO,KAAK,CAAC;IACf,CAAC;IACD,MAAM,IAAI,KAAK,CAAC,GAAG,KAAK,oBAAoB,kBAAkB,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAChF,CAAC"}

package/dist/skill.d.ts

@@ -0,0 +1,8 @@
+import type { JsonSchemaLike, PackageDependency, PackageManifestBase } from './package.js';
+export interface SkillPackageManifest extends PackageManifestBase {
+    type: 'skill';
+    skillsRoot?: string;
+    dependencies?: PackageDependency[];
+    configSchema?: JsonSchemaLike;
+}
+export declare function validateSkillPackageManifest(manifest: SkillPackageManifest): SkillPackageManifest;

package/dist/skill.js

@@ -0,0 +1,31 @@
+import { validateJsonSchemaLike, validatePackageActivationRule, validatePackageDependencies, validatePackageId } from './package.js';
+export function validateSkillPackageManifest(manifest) {
+    if (!manifest || typeof manifest !== 'object' || Array.isArray(manifest)) {
+        throw new Error('Skill package manifest must be an object');
+    }
+    const record = manifest;
+    validatePackageId(record.id, 'Skill package manifest id');
+    if (typeof record.name !== 'string' || !record.name.trim()) {
+        throw new Error('Skill package manifest name is required');
+    }
+    if (typeof record.version !== 'string' || !record.version.trim()) {
+        throw new Error('Skill package manifest version is required');
+    }
+    if (record.type !== 'skill') {
+        throw new Error('Skill package manifest type must be "skill"');
+    }
+    if (record.description !== undefined && (typeof record.description !== 'string' || !record.description.trim())) {
+        throw new Error('Skill package manifest description must be non-empty when provided');
+    }
+    if (record.skillsRoot !== undefined && (typeof record.skillsRoot !== 'string' || !record.skillsRoot.trim())) {
+        throw new Error('Skill package manifest skillsRoot must be non-empty when provided');
+    }
+    validatePackageDependencies(record.dependencies, 'skill manifest');
+    validateJsonSchemaLike(record.configSchema, 'skill manifest');
+    const activation = validatePackageActivationRule(record.activation, 'skill manifest');
+    return {
+        ...manifest,
+        ...(activation !== undefined ? { activation } : {})
+    };
+}
+//# sourceMappingURL=skill.js.map

package/dist/skill.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"skill.js","sourceRoot":"","sources":["../src/skill.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,sBAAsB,EAAE,6BAA6B,EAAE,2BAA2B,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AASrI,MAAM,UAAU,4BAA4B,CAAC,QAA8B;IACzE,IAAI,CAAC,QAAQ,IAAI,OAAO,QAAQ,KAAK,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC;QACzE,MAAM,IAAI,KAAK,CAAC,0CAA0C,CAAC,CAAC;IAC9D,CAAC;IACD,MAAM,MAAM,GAAG,QAA8C,CAAC;IAC9D,iBAAiB,CAAC,MAAM,CAAC,EAAE,EAAE,2BAA2B,CAAC,CAAC;IAC1D,IAAI,OAAO,MAAM,CAAC,IAAI,KAAK,QAAQ,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE,EAAE,CAAC;QAC3D,MAAM,IAAI,KAAK,CAAC,yCAAyC,CAAC,CAAC;IAC7D,CAAC;IACD,IAAI,OAAO,MAAM,CAAC,OAAO,KAAK,QAAQ,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC;QACjE,MAAM,IAAI,KAAK,CAAC,4CAA4C,CAAC,CAAC;IAChE,CAAC;IACD,IAAI,MAAM,CAAC,IAAI,KAAK,OAAO,EAAE,CAAC;QAC5B,MAAM,IAAI,KAAK,CAAC,6CAA6C,CAAC,CAAC;IACjE,CAAC;IACD,IAAI,MAAM,CAAC,WAAW,KAAK,SAAS,IAAI,CAAC,OAAO,MAAM,CAAC,WAAW,KAAK,QAAQ,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,IAAI,EAAE,CAAC,EAAE,CAAC;QAC/G,MAAM,IAAI,KAAK,CAAC,oEAAoE,CAAC,CAAC;IACxF,CAAC;IACD,IAAI,MAAM,CAAC,UAAU,KAAK,SAAS,IAAI,CAAC,OAAO,MAAM,CAAC,UAAU,KAAK,QAAQ,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,IAAI,EAAE,CAAC,EAAE,CAAC;QAC5G,MAAM,IAAI,KAAK,CAAC,mEAAmE,CAAC,CAAC;IACvF,CAAC;IACD,2BAA2B,CAAC,MAAM,CAAC,YAAY,EAAE,gBAAgB,CAAC,CAAC;IACnE,sBAAsB,CAAC,MAAM,CAAC,YAAY,EAAE,gBAAgB,CAAC,CAAC;IAC9D,MAAM,UAAU,GAAG,6BAA6B,CAAC,MAAM,CAAC,UAAU,EAAE,gBAAgB,CAAC,CAAC;IACtF,OAAO;QACL,GAAG,QAAQ;QACX,GAAG,CAAC,UAAU,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;KACpD,CAAC;AACJ,CAAC"}

package/dist/transport.d.ts

@@ -0,0 +1,269 @@
+import type { JsonSchemaLike, PackageDependency, PackageManifestBase } from './package.js';
+import type { RuntimeCommandRunner } from './runtime.js';
+export type RuntimeScopeId = string;
+export type RuntimeSpaceId = string;
+export type RuntimeThreadId = string;
+export interface RuntimeSurfaceNames {
+    mainCategoryName: string;
+    chatChannelName: string;
+    statusChannelName: string;
+    sessionsCategoryName: string;
+    missionsCategoryName: string;
+    archiveCategoryName: string;
+}
+export interface ManagedAdminAccessGroupConfig {
+    enabled: boolean;
+    name: string;
+}
+export interface ManagedMemberAccessGroupConfig {
+    enabled: boolean;
+    name: string;
+}
+export type RuntimeAccessGroupKind = 'admin' | 'member';
+export interface RuntimeAccessGroupRecord {
+    id: string;
+    kind: RuntimeAccessGroupKind;
+    name: string;
+    verifiedAt?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface RuntimeAccessGroupInput {
+    scopeId: RuntimeScopeId;
+    kind: RuntimeAccessGroupKind;
+    name: string;
+    previousId?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface RuntimeSurfaceState {
+    scopeId?: string;
+    mainCategoryId: string;
+    chatChannelId: string;
+    statusChannelId: string;
+    sessionsCategoryId: string;
+    missionsCategoryId: string;
+    archiveCategoryId: string;
+    adminAccessGroupId?: string;
+    memberAccessGroupId?: string;
+    adminAccessGroupName?: string;
+    memberAccessGroupName?: string;
+    adminAccessGroupVerifiedAt?: string;
+    memberAccessGroupVerifiedAt?: string;
+    createdAt: string;
+    updatedAt: string;
+    metadata?: Record<string, unknown>;
+}
+export interface RuntimeSurfaceBootstrapInput {
+    scopeId?: RuntimeScopeId;
+    actorId?: string;
+    names?: Partial<RuntimeSurfaceNames>;
+    managedAdminAccessGroup?: ManagedAdminAccessGroupConfig;
+    managedMemberAccessGroup?: ManagedMemberAccessGroupConfig;
+    explicitAdminRoleIds?: string[];
+    explicitAdminUserIds?: string[];
+    previousState: RuntimeSurfaceState | null;
+    nowIso: string;
+    config?: Record<string, unknown>;
+}
+export interface RuntimeActorIdentity {
+    actorId: string;
+    displayName?: string;
+    accessGroupIds?: string[];
+    isSurfaceAdmin?: boolean;
+    transportMetadata?: Record<string, unknown>;
+}
+export interface RuntimeSpaceRecord {
+    id: RuntimeSpaceId;
+    name: string;
+    kind: 'root' | 'group' | 'room' | 'thread' | 'dm' | 'external';
+    parentId: RuntimeSpaceId | null;
+    metadata?: Record<string, unknown>;
+}
+export interface RuntimeAttachmentPayload {
+    kind: 'file' | 'image' | 'link';
+    path?: string;
+    url?: string;
+    name?: string;
+    description?: string;
+    contentType?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface RuntimeMessageBlock {
+    kind: 'text' | 'section' | 'fields' | 'notice';
+    text?: string;
+    title?: string;
+    fields?: Array<{
+        label: string;
+        value: string;
+        inline?: boolean;
+    }>;
+    tone?: 'default' | 'info' | 'success' | 'warning' | 'danger';
+    metadata?: Record<string, unknown>;
+}
+export interface RuntimeActionReference {
+    actionId: string;
+    label: string;
+    style?: 'primary' | 'secondary' | 'success' | 'danger';
+    input?: Record<string, unknown>;
+    disabled?: boolean;
+}
+export interface RuntimeMessagePayload {
+    text?: string;
+    blocks?: RuntimeMessageBlock[];
+    attachments?: RuntimeAttachmentPayload[];
+    actions?: RuntimeActionReference[];
+    metadata?: Record<string, unknown>;
+}
+export interface RuntimeMessageReceipt {
+    id: string;
+    nativeId?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface RuntimeInboundMessage {
+    id?: string;
+    text: string;
+    attachments?: RuntimeAttachmentPayload[];
+    metadata?: Record<string, unknown>;
+}
+export interface RuntimeNativeInteraction {
+    kind: string;
+    id?: string;
+    payload?: unknown;
+}
+export type RuntimeTransportEvent = {
+    type: 'message.received';
+    scopeId: RuntimeScopeId;
+    spaceId: RuntimeSpaceId;
+    actor: RuntimeActorIdentity;
+    message: RuntimeInboundMessage;
+} | {
+    type: 'action.invoked';
+    scopeId: RuntimeScopeId;
+    spaceId?: RuntimeSpaceId;
+    actor: RuntimeActorIdentity;
+    actionId: string;
+    input: Record<string, unknown>;
+    native?: RuntimeNativeInteraction;
+} | {
+    type: 'resource.lifecycle';
+    scopeId: RuntimeScopeId;
+    resource: RuntimeSpaceRecord;
+    action: 'created' | 'updated' | 'deleted';
+    previous?: Partial<RuntimeSpaceRecord>;
+};
+export interface RuntimeTransportAccessInput {
+    authToken?: string;
+    scopeId: RuntimeScopeId;
+    applicationId?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface RuntimeTransportVerification {
+    scopeId: RuntimeScopeId;
+    scopeName: string;
+    actorId: string;
+    actorName: string;
+    applicationId?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface RuntimeTransportAuth {
+    token?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface RuntimeMessageTarget {
+    scopeId?: RuntimeScopeId;
+    spaceId: RuntimeSpaceId;
+    threadId?: RuntimeThreadId;
+}
+export interface RuntimeTransportCapabilities {
+    nativeActions: boolean;
+    spaces: {
+        list: boolean;
+        create: boolean;
+        update: boolean;
+        delete: boolean;
+    };
+    presence: boolean;
+    maxMessageTextLength?: number;
+    maxAttachmentBytes?: number;
+    metadata?: Record<string, unknown>;
+}
+export interface RuntimeCreateSpaceInput {
+    scopeId: RuntimeScopeId;
+    name: string;
+    kind: RuntimeSpaceRecord['kind'];
+    parentId?: RuntimeSpaceId | null;
+    metadata?: Record<string, unknown>;
+}
+export interface RuntimeUpdateSpaceInput {
+    scopeId: RuntimeScopeId;
+    spaceId: RuntimeSpaceId;
+    name?: string;
+    parentId?: RuntimeSpaceId | null;
+    metadata?: Record<string, unknown>;
+}
+export interface RuntimeDeleteSpaceInput {
+    scopeId: RuntimeScopeId;
+    spaceId: RuntimeSpaceId;
+}
+export interface RuntimePresenceInput {
+    scopeId?: RuntimeScopeId;
+    spaceId?: RuntimeSpaceId;
+    status: 'online' | 'idle' | 'busy' | 'offline';
+    text?: string;
+}
+export interface RuntimeNativeActionRegistration {
+    scopeId: RuntimeScopeId;
+    actions: RuntimeActionDefinition[];
+}
+export interface RuntimeActionDefinition {
+    id: string;
+    title: string;
+    description?: string;
+    inputSchema?: Record<string, unknown>;
+    requiredCapability?: string;
+    policy?: {
+        allowedWhileDraining?: boolean;
+        bypassQueue?: boolean;
+    };
+    metadata?: Record<string, unknown>;
+}
+export interface RuntimeTransport {
+    verifyAccess(input: RuntimeTransportAccessInput): Promise<RuntimeTransportVerification>;
+    start(auth: RuntimeTransportAuth): Promise<void>;
+    stop(): Promise<void>;
+    capabilities(): RuntimeTransportCapabilities;
+    onEvent(handler: (event: RuntimeTransportEvent) => Promise<void>): void;
+    sendMessage(target: RuntimeMessageTarget, payload: RuntimeMessagePayload): Promise<RuntimeMessageReceipt>;
+    listSpaces?(scopeId: RuntimeScopeId): Promise<RuntimeSpaceRecord[]>;
+    createSpace?(input: RuntimeCreateSpaceInput): Promise<RuntimeSpaceRecord>;
+    updateSpace?(input: RuntimeUpdateSpaceInput): Promise<RuntimeSpaceRecord>;
+    deleteSpace?(input: RuntimeDeleteSpaceInput): Promise<void>;
+    setPresence?(input: RuntimePresenceInput): Promise<void>;
+    registerNativeActions?(input: RuntimeNativeActionRegistration): Promise<void>;
+    ensureAccessGroup?(input: RuntimeAccessGroupInput): Promise<RuntimeAccessGroupRecord>;
+    reconcileRuntimeSurface?(input: RuntimeSurfaceBootstrapInput): Promise<RuntimeSurfaceState>;
+}
+export interface TransportPackageManifest extends PackageManifestBase {
+    type: 'transport';
+    entrypoint?: string;
+    dependencies?: PackageDependency[];
+    configSchema?: JsonSchemaLike;
+    displayCategory?: string;
+}
+export interface RuntimeTransportPackageContext {
+    config: Record<string, unknown>;
+    commandRunner?: RuntimeCommandRunner;
+}
+export interface RuntimeTransportConfigCompletionInput {
+    config: Record<string, unknown>;
+}
+export interface RuntimeTransportConfigCompletionResult {
+    config: Record<string, unknown>;
+    warnings?: string[];
+}
+export interface RuntimeTransportPackage {
+    manifest: TransportPackageManifest;
+    createTransport(input: RuntimeTransportPackageContext): RuntimeTransport;
+    completeConfig?(input: RuntimeTransportConfigCompletionInput): RuntimeTransportConfigCompletionResult | Promise<RuntimeTransportConfigCompletionResult>;
+}
+export declare function validateTransportPackageManifest(manifest: TransportPackageManifest): TransportPackageManifest;
+export declare function validateTransportPackageRuntimeContract(pkg: RuntimeTransportPackage): void;