agl 1.0.17 → 21.0.2

package/dist_ts/interfaces.flexipc.d.ts

@@ -0,0 +1,939 @@
+import * as plugins from './plugins.js';
+import { type IControllerProjectFilesystemIdentity } from './interfaces.projects.js';
+type TFlexCreateSessionOptions = plugins.flexharness.IFlexCreateSessionOptions;
+type TFlexMessage = plugins.flexharness.IFlexMessage;
+type TFlexMessagePage = plugins.flexharness.IFlexMessagePage;
+type TFlexPermissionRequest = plugins.flexharness.IFlexPermissionRequest;
+export type TFlexPromptQueueEntry = plugins.flexharness.IFlexPromptQueueEntry;
+type TFlexPromptOptions = plugins.flexharness.IFlexPromptOptions;
+type TFlexSession = plugins.flexharness.IFlexSession;
+type TFlexToolMessagePart = plugins.flexharness.IFlexToolMessagePart;
+type TFlexReasoningMessagePart = Extract<plugins.flexharness.TFlexMessagePart, {
+    type: 'reasoning';
+}>;
+type TFlexTextMessagePart = Extract<plugins.flexharness.TFlexMessagePart, {
+    type: 'text';
+}>;
+type TFlexUpdateSessionOptions = plugins.flexharness.IFlexUpdateSessionOptions;
+type TFlexPermissionDecision = plugins.flexharness.TFlexPermissionDecision;
+type TFlexPrompt = plugins.flexharness.TFlexPrompt;
+type TFlexProjectManagementRecord = plugins.flexharness.TFlexProjectManagementRecord;
+type TFlexProjectManagementSnapshot = plugins.flexharness.IFlexProjectManagementSnapshot;
+type TFlexProjectManagementTombstone = plugins.flexharness.IFlexProjectManagementTombstone;
+type TFlexProjectManagementWriteContext = plugins.flexharness.IFlexProjectManagementWriteContext;
+type TFlexJsonValue = plugins.flexharness.TJsonValue;
+export type TFlexSlashCommandDescriptor = plugins.flexharness.IFlexSlashCommandDescriptor;
+export type TFlexSessionReversionInfo = plugins.flexharness.IFlexSessionReversionInfo;
+export type TFlexTurnReversionFinalizedOutcome = plugins.flexharness.TFlexTurnReversionFinalizedOutcome;
+export type TFlexTurnReversionCaptureInspectionV2 = plugins.flexharness.TFlexTurnReversionCaptureInspectionV2;
+export type TFlexTurnReversionApplyInspection = plugins.flexharness.IFlexTurnReversionApplyInspection;
+export declare const flexIpcProtocolVersion: 14;
+export declare const flexIpcMaximumFrameBytes: number;
+export declare const flexIpcMaximumPendingRequests = 64;
+export declare const flexIpcMaximumBrowserChannels = 128;
+export declare const flexIpcMaximumBrowserFrameBytes: number;
+export declare const flexIpcMaximumPendingBrowserFrames = 128;
+export declare const flexIpcMaximumPendingBrowserFrameBytes: number;
+export declare const flexIpcMaximumChildJobs = 64;
+export declare const flexIpcMaximumPromptQueueEntries = 128;
+export declare const flexIpcMaximumQueuedSessionChanges = 256;
+export declare const flexIpcMaximumQueuedSessionChangeBytes: number;
+export declare const flexIpcControlTimeoutMs = 35000;
+export declare const flexIpcStartupTimeoutMs = 180000;
+export declare const flexIpcDisposeTimeoutMs = 10000;
+export declare const flexIpcSlashTimeoutMs: number;
+export declare const flexIpcMaximumHostTimeoutMs: number;
+export declare const flexIpcCancellationGraceTimeoutMs = 2000;
+export interface IFlexProjectRecord {
+    projectId: string;
+    directory: string;
+    directoryIdentity?: IControllerProjectFilesystemIdentity;
+}
+export interface IFlexIdentityBoundProjectRecord extends IFlexProjectRecord {
+    directoryIdentity: IControllerProjectFilesystemIdentity;
+}
+export interface IFlexDatabaseDescriptor {
+    mongoDbUrl: string;
+    mongoDbName: string;
+}
+export interface IFlexServiceInit {
+    controllerId: string;
+    database: IFlexDatabaseDescriptor;
+    flexCredentialDirectory: string;
+    projects: IFlexProjectRecord[];
+}
+export interface IFlexBrowserResourceDescriptor {
+    resourceId: string;
+    attachmentRevision: number;
+}
+export interface IFlexBrowserChannelBinding {
+    projectId: string;
+    browserResourceId: string;
+    attachmentAuthorityId: string;
+    attachmentRevision: number;
+    actorId: string;
+    peerId: string;
+    role: 'agent';
+    source: 'flex';
+    scopeId: string;
+    channelId: string;
+    runId: string;
+    sessionId: {
+        harnessId: 'flex';
+        nativeId: string;
+    };
+}
+export interface IFlexIntelligenceSessionId {
+    harnessId: 'opencode' | 'flex';
+    nativeId: string;
+}
+export interface IFlexIntelligenceChatSummary {
+    sessionId: IFlexIntelligenceSessionId;
+    title: string;
+    updatedAt: string;
+    isActive?: boolean;
+}
+export interface IFlexIntelligenceChatMessage {
+    role: string;
+    text: string;
+    timestamp?: string;
+}
+export interface IFlexIntelligenceChatTranscript {
+    sessionId: IFlexIntelligenceSessionId;
+    title: string;
+    messages: IFlexIntelligenceChatMessage[];
+    totalMessages?: number;
+}
+export interface IFlexIntelligenceResult {
+    answer: string;
+    scratchpad: string;
+    model: string;
+}
+export interface IFlexTurnReversionBaseRequest {
+    scopeId: string;
+    storageKey: string;
+    sessionId: string;
+    runId: string;
+    captureId: string;
+}
+export interface IFlexTurnReversionApplyRequest extends IFlexTurnReversionBaseRequest {
+    reference: TFlexJsonValue;
+    operationId: string;
+    direction: 'undo' | 'redo';
+}
+export interface IFlexTurnReversionReleaseRequest extends IFlexTurnReversionBaseRequest {
+    reference: TFlexJsonValue;
+}
+export interface IFlexGitWorktreeDescriptor {
+    worktreeId: string;
+    projectId: string;
+    sessionId: string;
+    path: string;
+    repositoryId: string;
+    createdAt: string;
+}
+export type TFlexIntelligenceJobStatus = 'running' | 'completed' | 'failed' | 'cancelled';
+export interface IFlexHostRequestMap {
+    'reversion.prepare': {
+        request: IFlexTurnReversionBaseRequest;
+        response: {
+            prepared: true;
+        };
+    };
+    'reversion.inspect-capture': {
+        request: IFlexTurnReversionBaseRequest;
+        response: TFlexTurnReversionCaptureInspectionV2;
+    };
+    'reversion.finalize': {
+        request: IFlexTurnReversionBaseRequest;
+        response: TFlexTurnReversionFinalizedOutcome;
+    };
+    'reversion.inspect-apply': {
+        request: IFlexTurnReversionApplyRequest;
+        response: TFlexTurnReversionApplyInspection;
+    };
+    'reversion.apply': {
+        request: IFlexTurnReversionApplyRequest;
+        response: {
+            applied: true;
+        };
+    };
+    'reversion.release': {
+        request: IFlexTurnReversionReleaseRequest;
+        response: {
+            released: true;
+        };
+    };
+    'git.worktree.create': {
+        request: {
+            scopeId: string;
+            sessionId: string;
+        };
+        response: {
+            worktree: IFlexGitWorktreeDescriptor;
+        };
+    };
+    'git.worktree.list': {
+        request: {
+            scopeId: string;
+            sessionId: string;
+        };
+        response: {
+            worktrees: IFlexGitWorktreeDescriptor[];
+        };
+    };
+    'git.worktree.remove': {
+        request: {
+            scopeId: string;
+            sessionId: string;
+            worktreeId: string;
+            compensate?: true;
+        };
+        response: {
+            removed: true;
+        };
+    };
+    'crossharness.chats.list': {
+        request: {
+            capabilityToken: string;
+            limit: number;
+        };
+        response: {
+            chats: IFlexIntelligenceChatSummary[];
+        };
+    };
+    'crossharness.chat.read': {
+        request: {
+            capabilityToken: string;
+            sessionId: IFlexIntelligenceSessionId;
+            limit: number;
+            maxChars: number;
+        };
+        response: {
+            transcript: IFlexIntelligenceChatTranscript;
+        };
+    };
+    'project-management.load': {
+        request: {
+            storageKey: string;
+            sessionId: string;
+            sessionGenerationId: string;
+            sessionGenerationSequence: number;
+        };
+        response: {
+            record: TFlexProjectManagementRecord | null;
+        };
+    };
+    'project-management.save': {
+        request: {
+            storageKey: string;
+            sessionId: string;
+            snapshot: TFlexProjectManagementSnapshot;
+            expectedRevision: number;
+            writeContext: TFlexProjectManagementWriteContext;
+        };
+        response: TFlexProjectManagementCommitResult;
+    };
+    'project-management.tombstone': {
+        request: {
+            storageKey: string;
+            sessionId: string;
+            tombstone: TFlexProjectManagementTombstone;
+            expectedRevision: number;
+        };
+        response: TFlexProjectManagementCommitResult;
+    };
+    'project-management.purge': {
+        request: {
+            storageKey: string;
+        };
+        response: {
+            purged: true;
+        };
+    };
+    'browser.resources.resolve': {
+        request: {
+            scopeId: string;
+            sessionId: string;
+            runId: string;
+        };
+        response: {
+            resources: IFlexBrowserResourceDescriptor[];
+        };
+    };
+    'browser.channel.open': {
+        request: {
+            scopeId: string;
+            sessionId: string;
+            runId: string;
+            resourceId: string;
+            attachmentRevision: number;
+            channelId: string;
+        };
+        response: {
+            binding: IFlexBrowserChannelBinding;
+            capabilityToken: string;
+        };
+    };
+    'browser.channel.close': {
+        request: {
+            channelId: string;
+        };
+        response: {
+            closed: true;
+        };
+    };
+}
+export type TFlexProjectManagementCommitResult = {
+    committed: true;
+} | {
+    committed: false;
+    actualRevision: number;
+};
+export type TFlexHostRequestMethod = keyof IFlexHostRequestMap;
+export type TFlexHostRequest<TMethod extends TFlexHostRequestMethod> = IFlexHostRequestMap[TMethod]['request'];
+export type TFlexHostResponse<TMethod extends TFlexHostRequestMethod> = IFlexHostRequestMap[TMethod]['response'];
+export type TFlexServiceState = 'starting' | 'ready' | 'unsupported' | 'failed' | 'stopping' | 'stopped';
+export type TFlexServiceStatusCode = 'UNSUPPORTED_RUNTIME' | 'INITIALIZATION_FAILED' | 'SERVICE_STOPPED';
+export interface IFlexServiceStatus {
+    state: TFlexServiceState;
+    ready: boolean;
+    code?: TFlexServiceStatusCode;
+    startedAt?: string;
+}
+export type TFlexPublicConnectionState = 'pending' | 'active' | 'deleting' | 'reauthRequired';
+export interface IFlexPublicAccountSummary {
+    providerId: string;
+    authKind: 'chatgptOAuth';
+    accountId?: string;
+    email?: string;
+    plan?: string;
+}
+export interface IFlexPublicProviderConnection {
+    loginId: string;
+    providerId: 'openai';
+    status: TFlexPublicConnectionState;
+    account?: IFlexPublicAccountSummary;
+}
+/** Private child-to-controller projection. It is never exposed by controller RPC. */
+export interface IFlexOpenCodeOAuthAuth {
+    type: 'oauth';
+    access: string;
+    refresh: string;
+    expires: number;
+    accountId?: string;
+}
+export interface IFlexPublicProviderModel {
+    providerId: 'openai';
+    modelId: string;
+    displayName: string;
+    description: string;
+    hidden: boolean;
+    reasoningEfforts: Array<{
+        effort: string;
+        description: string;
+    }>;
+    defaultReasoningEffort: string;
+    inputModalities: Array<'text' | 'image' | 'audio'>;
+    supportsPersonality: boolean;
+    serviceTiers: Array<{
+        id: string;
+        name: string;
+        description: string;
+    }>;
+    defaultServiceTier?: string;
+    isDefault: boolean;
+}
+export interface IFlexPublicProviderRateLimitWindow {
+    usedPercent: number;
+    limitWindowSeconds: number;
+    resetAfterSeconds: number;
+    resetsAt: number;
+}
+export interface IFlexPublicProviderRateLimitDetails {
+    allowed: boolean;
+    limitReached: boolean;
+    primaryWindow?: IFlexPublicProviderRateLimitWindow;
+    secondaryWindow?: IFlexPublicProviderRateLimitWindow;
+}
+export interface IFlexPublicProviderAdditionalRateLimit {
+    limitName: string;
+    meteredFeature: string;
+    rateLimit?: IFlexPublicProviderRateLimitDetails;
+}
+export interface IFlexPublicProviderAccountRateLimits {
+    providerId: 'openai';
+    plan: string;
+    observedAt: string;
+    rateLimit?: IFlexPublicProviderRateLimitDetails;
+    additionalRateLimits: IFlexPublicProviderAdditionalRateLimit[];
+    rateLimitReachedType?: string;
+    rateLimitResetCreditsAvailableCount?: number;
+}
+export interface IFlexModelChoice {
+    providerConnectionId: string;
+    modelId: string;
+    variant?: string;
+}
+export interface IFlexJobAdmission {
+    jobId: string;
+}
+export interface IFlexSessionListResult {
+    sessions: TFlexSession[];
+    total: number;
+    truncated: boolean;
+}
+export type TFlexSlashExecutionResult = plugins.flexharness.IFlexSlashCommandNotCommandResult | plugins.flexharness.IFlexSlashCommandMalformedResult | plugins.flexharness.IFlexSlashCommandUnknownResult | plugins.flexharness.IFlexSlashCommandOperationResult | plugins.flexharness.IFlexSlashCommandHandlerResult | {
+    type: 'prompt-admission';
+    name: string;
+    admission: {
+        queueId: string;
+        runId: string;
+    };
+};
+export interface IFlexRequestMap {
+    'service.status': {
+        request: Record<string, never>;
+        response: IFlexServiceStatus;
+    };
+    'project.replaceAll': {
+        request: {
+            projects: IFlexProjectRecord[];
+        };
+        response: {
+            replaced: true;
+            retired: number;
+        };
+    };
+    'project.register': {
+        request: {
+            project: IFlexIdentityBoundProjectRecord;
+        };
+        response: {
+            registered: true;
+        };
+    };
+    'project.remove': {
+        request: {
+            project: IFlexIdentityBoundProjectRecord;
+        };
+        response: {
+            removed: true;
+        };
+    };
+    'intelligence.start': {
+        request: {
+            scopeId: string;
+            sourceSessionId: IFlexIntelligenceSessionId;
+            question: string;
+            scratchpad: string;
+            model: IFlexModelChoice;
+            capabilityToken: string;
+        };
+        response: {
+            jobId: string;
+            workerSessionId: string;
+        };
+    };
+    'intelligence.get': {
+        request: {
+            scopeId: string;
+            jobId: string;
+            capabilityToken: string;
+        };
+        response: {
+            status: TFlexIntelligenceJobStatus;
+            workerSessionId: string;
+            result?: IFlexIntelligenceResult;
+            error?: string;
+        };
+    };
+    'intelligence.cancel': {
+        request: {
+            scopeId: string;
+            capabilityToken: string;
+        };
+        response: {
+            cancelled: boolean;
+        };
+    };
+    'session.list': {
+        request: {
+            scopeId: string;
+            offset?: number;
+            limit?: number;
+        };
+        response: IFlexSessionListResult;
+    };
+    'session.create': {
+        request: {
+            scopeId: string;
+            options?: TFlexCreateSessionOptions;
+        };
+        response: TFlexSession;
+    };
+    'session.get': {
+        request: {
+            scopeId: string;
+            sessionId: string;
+        };
+        response: TFlexSession;
+    };
+    'session.update': {
+        request: {
+            scopeId: string;
+            sessionId: string;
+            options: TFlexUpdateSessionOptions;
+        };
+        response: TFlexSession;
+    };
+    'session.delete': {
+        request: {
+            scopeId: string;
+            sessionId: string;
+        };
+        response: {
+            deleted: true;
+        };
+    };
+    'session.compact': {
+        request: {
+            scopeId: string;
+            sessionId: string;
+            model?: IFlexModelChoice;
+        };
+        response: {
+            compacted: true;
+        };
+    };
+    'session.reversion.info': {
+        request: {
+            scopeId: string;
+            sessionId: string;
+        };
+        response: TFlexSessionReversionInfo;
+    };
+    'slash.list': {
+        request: {
+            scopeId: string;
+            sessionId: string;
+        };
+        response: {
+            commands: TFlexSlashCommandDescriptor[];
+        };
+    };
+    'slash.execute': {
+        request: {
+            scopeId: string;
+            sessionId: string;
+            input: string;
+            model?: IFlexModelChoice;
+        };
+        response: TFlexSlashExecutionResult;
+    };
+    'message.page': {
+        request: {
+            scopeId: string;
+            sessionId: string;
+            limit?: number;
+            before?: string;
+        };
+        response: TFlexMessagePage;
+    };
+    'message.get': {
+        request: {
+            scopeId: string;
+            sessionId: string;
+            messageId: string;
+        };
+        response: TFlexMessage;
+    };
+    'prompt.start': {
+        request: {
+            scopeId: string;
+            sessionId: string;
+            prompt: TFlexPrompt;
+            options?: TFlexPromptOptions;
+            model?: IFlexModelChoice;
+            upload?: {
+                operationId: string;
+                directory: string;
+            };
+        };
+        response: {
+            queueId: string;
+            runId: string;
+        };
+    };
+    'prompt.acknowledge': {
+        request: {
+            scopeId: string;
+            sessionId: string;
+            queueId: string;
+            runId: string;
+        };
+        response: {
+            acknowledged: true;
+        };
+    };
+    'prompt.get': {
+        request: {
+            scopeId: string;
+            sessionId: string;
+            queueId: string;
+        };
+        response: {
+            entry: TFlexPromptQueueEntry;
+        };
+    };
+    'prompt.list': {
+        request: {
+            scopeId: string;
+            sessionId: string;
+        };
+        response: {
+            entries: TFlexPromptQueueEntry[];
+        };
+    };
+    'prompt.cancel': {
+        request: {
+            scopeId: string;
+            sessionId: string;
+            queueId: string;
+        };
+        response: {
+            accepted: boolean;
+        };
+    };
+    'permission.list': {
+        request: {
+            scopeId: string;
+            sessionId?: string;
+            familyRootSessionId?: string;
+        };
+        response: {
+            permissions: TFlexPermissionRequest[];
+        };
+    };
+    'permission.respond': {
+        request: {
+            scopeId: string;
+            sessionId: string;
+            permissionId: string;
+            decision: TFlexPermissionDecision;
+        };
+        response: {
+            accepted: true;
+        };
+    };
+    'provider.list': {
+        request: Record<string, never>;
+        response: {
+            providers: Array<{
+                providerId: 'openai';
+                displayName: string;
+                loginFlow: 'device';
+            }>;
+        };
+    };
+    'provider.login.begin': {
+        request: {
+            providerId: 'openai';
+        };
+        response: {
+            loginId: string;
+            verificationUrl: string;
+            userCode: string;
+            status: 'pending';
+        };
+    };
+    'provider.login.status': {
+        request: {
+            loginId: string;
+        };
+        response: IFlexPublicProviderConnection;
+    };
+    'provider.login.cancel': {
+        request: {
+            loginId: string;
+        };
+        response: {
+            canceled: boolean;
+        };
+    };
+    'provider.connection.list': {
+        request: Record<string, never>;
+        response: {
+            connections: IFlexPublicProviderConnection[];
+        };
+    };
+    'provider.connection.opencode-auth.get': {
+        request: {
+            providerConnectionId: string;
+        };
+        response: {
+            auth: IFlexOpenCodeOAuthAuth;
+        };
+    };
+    'provider.connection.logout.prepare': {
+        request: {
+            providerConnectionId: string;
+        };
+        response: {
+            accepted: true;
+        };
+    };
+    'provider.connection.logout': {
+        request: {
+            providerConnectionId: string;
+        };
+        response: {
+            accepted: true;
+        };
+    };
+    'provider.connection.ratelimits.get': {
+        request: {
+            providerConnectionId: string;
+        };
+        response: {
+            rateLimits: IFlexPublicProviderAccountRateLimits;
+        };
+    };
+    'provider.models.refresh': {
+        request: {
+            providerConnectionId: string;
+        };
+        response: IFlexJobAdmission;
+    };
+    'model.choice.get': {
+        request: {
+            scopeId: string;
+        };
+        response: {
+            choice: IFlexModelChoice | null;
+        };
+    };
+    'model.choice.set': {
+        request: {
+            scopeId: string;
+            choice: IFlexModelChoice;
+        };
+        response: {
+            choice: IFlexModelChoice;
+        };
+    };
+    'model.choice.validate': {
+        request: {
+            choice: IFlexModelChoice;
+        };
+        response: {
+            valid: true;
+        };
+    };
+}
+export type TFlexRequestMethod = keyof IFlexRequestMap;
+export type TFlexRequest<TMethod extends TFlexRequestMethod> = IFlexRequestMap[TMethod]['request'];
+export type TFlexResponse<TMethod extends TFlexRequestMethod> = IFlexRequestMap[TMethod]['response'];
+export interface IFlexIpcInitMessage {
+    version: typeof flexIpcProtocolVersion;
+    type: 'init';
+    init: IFlexServiceInit;
+}
+export interface IFlexIpcRequestMessage {
+    version: typeof flexIpcProtocolVersion;
+    type: 'request';
+    requestId: string;
+    method: TFlexRequestMethod;
+    payload: unknown;
+}
+export interface IFlexIpcRequestCancelMessage {
+    version: typeof flexIpcProtocolVersion;
+    type: 'request.cancel';
+    requestId: string;
+}
+export interface IFlexIpcDisposeMessage {
+    version: typeof flexIpcProtocolVersion;
+    type: 'dispose';
+    requestId: string;
+}
+export type TFlexIpcHostResponseMessage = {
+    version: typeof flexIpcProtocolVersion;
+    type: 'host.response';
+    requestId: string;
+} & ({
+    ok: true;
+    result: unknown;
+} | {
+    ok: false;
+    error: IFlexServiceError;
+});
+export interface IFlexIpcParentBrowserFrameMessage {
+    version: typeof flexIpcProtocolVersion;
+    type: 'browser.channel.frame';
+    channelId: string;
+    dataBase64: string;
+}
+export interface IFlexIpcBrowserChannelClosedMessage {
+    version: typeof flexIpcProtocolVersion;
+    type: 'browser.channel.closed';
+    channelId: string;
+}
+export type TFlexParentMessage = IFlexIpcInitMessage | IFlexIpcRequestMessage | IFlexIpcRequestCancelMessage | IFlexIpcDisposeMessage | TFlexIpcHostResponseMessage | IFlexIpcParentBrowserFrameMessage | IFlexIpcBrowserChannelClosedMessage;
+export type TFlexServiceErrorCode = 'INVALID_REQUEST' | 'NOT_READY' | 'NOT_FOUND' | 'CONFLICT' | 'BUSY' | 'TIMEOUT' | 'ABORTED' | 'OUTCOME_UNKNOWN' | 'SLASH_UNAVAILABLE' | 'LIMIT_EXCEEDED' | 'STALE_RUN' | 'PROVIDER_LOGIN_FAILED' | 'PROVIDER_REAUTH_REQUIRED' | 'MODEL_CATALOG_REQUIRED' | 'UNSUPPORTED_RUNTIME' | 'INTERNAL';
+export declare const flexServiceErrorMessages: Readonly<Record<TFlexServiceErrorCode, string>>;
+export interface IFlexServiceError {
+    name: 'FlexServiceError';
+    code: TFlexServiceErrorCode;
+    message: string;
+}
+export interface IFlexIpcStatusMessage {
+    version: typeof flexIpcProtocolVersion;
+    type: 'status';
+    status: IFlexServiceStatus;
+}
+export type TFlexIpcResponseMessage = {
+    version: typeof flexIpcProtocolVersion;
+    type: 'response';
+    requestId: string;
+} & ({
+    ok: true;
+    result: unknown;
+} | {
+    ok: false;
+    error: IFlexServiceError;
+});
+export type TFlexJobKind = 'provider.models';
+export type TFlexChildEvent = {
+    type: 'session.history.changed';
+    scopeId: string;
+    sessionId: string;
+    direction: 'undo' | 'redo' | 'branch';
+    runId?: string;
+} | {
+    type: 'sessions.changed';
+    scopeId?: string;
+    sessionId?: string;
+    coalesced: boolean;
+} | {
+    type: 'permissions.changed';
+    scopeId: string;
+    sessionId: string;
+} | {
+    type: 'tool.updated';
+    scopeId: string;
+    sessionId: string;
+    runId: string;
+    messageId: string;
+    messageIndex: number;
+    partIndex: number;
+    sequence: number;
+    timestamp: string;
+    part: TFlexToolMessagePart;
+} | {
+    type: 'reasoning.updated';
+    scopeId: string;
+    sessionId: string;
+    runId: string;
+    messageId: string;
+    messageIndex: number;
+    partIndex: number;
+    sequence: number;
+    timestamp: string;
+    part: TFlexReasoningMessagePart;
+} | {
+    type: 'text.updated';
+    scopeId: string;
+    sessionId: string;
+    runId: string;
+    messageId: string;
+    messageIndex: number;
+    partIndex: number;
+    sequence: number;
+    timestamp: string;
+    status: 'running' | 'completed';
+    part: TFlexTextMessagePart;
+} | {
+    type: 'prompt.queued';
+    scopeId: string;
+    sessionId: string;
+    queueId: string;
+    runId?: never;
+    entry: TFlexPromptQueueEntry;
+} | {
+    type: 'prompt.started' | 'prompt.running' | 'prompt.finished';
+    scopeId: string;
+    sessionId: string;
+    queueId: string;
+    runId: string;
+    entry: TFlexPromptQueueEntry;
+} | {
+    type: 'prompt.message-bound';
+    scopeId: string;
+    sessionId: string;
+    queueId: string;
+    runId: string;
+    messageId: string;
+} | {
+    type: 'job.finished';
+    jobId: string;
+    kind: TFlexJobKind;
+    status: 'completed' | 'failed' | 'cancelled';
+    models?: IFlexPublicProviderModel[];
+} | {
+    type: 'provider.connection.changed';
+    connection: IFlexPublicProviderConnection;
+};
+export interface IFlexIpcEventMessage {
+    version: typeof flexIpcProtocolVersion;
+    type: 'event';
+    event: TFlexChildEvent;
+}
+export interface IFlexIpcHostRequestMessage {
+    version: typeof flexIpcProtocolVersion;
+    type: 'host.request';
+    requestId: string;
+    method: TFlexHostRequestMethod;
+    payload: unknown;
+    timeoutMs: number;
+}
+export interface IFlexIpcHostCancelMessage {
+    version: typeof flexIpcProtocolVersion;
+    type: 'host.cancel';
+    requestId: string;
+}
+export interface IFlexIpcHostResponseAcknowledgementMessage {
+    version: typeof flexIpcProtocolVersion;
+    type: 'host.response.acknowledge';
+    requestId: string;
+}
+export interface IFlexIpcChildBrowserFrameMessage {
+    version: typeof flexIpcProtocolVersion;
+    type: 'browser.channel.frame';
+    channelId: string;
+    dataBase64: string;
+}
+export type TFlexChildMessage = IFlexIpcStatusMessage | TFlexIpcResponseMessage | IFlexIpcEventMessage | IFlexIpcHostRequestMessage | IFlexIpcHostCancelMessage | IFlexIpcHostResponseAcknowledgementMessage | IFlexIpcChildBrowserFrameMessage;
+export declare const isFlexPlainObject: (valueArg: unknown) => valueArg is Record<string, unknown>;
+export declare const hasFlexExactKeys: (valueArg: Record<string, unknown>, requiredKeysArg: readonly string[], optionalKeysArg?: readonly string[]) => boolean;
+export declare const isFlexProjectRecord: (valueArg: unknown) => valueArg is IFlexProjectRecord;
+export declare const isFlexIdentityBoundProjectRecord: (valueArg: unknown) => valueArg is IFlexIdentityBoundProjectRecord;
+export declare const isFlexDatabaseDescriptor: (valueArg: unknown) => valueArg is IFlexDatabaseDescriptor;
+export declare const isFlexServiceInit: (valueArg: unknown) => valueArg is IFlexServiceInit;
+export declare const isFlexServiceStatus: (valueArg: unknown) => valueArg is IFlexServiceStatus;
+export declare const isFlexPublicProviderConnection: (valueArg: unknown) => valueArg is IFlexPublicProviderConnection;
+export declare const isFlexPublicMessage: (valueArg: unknown) => valueArg is TFlexMessage;
+export declare const isFlexPublicSession: (valueArg: unknown) => valueArg is TFlexSession;
+export declare const isFlexRequestPayload: <TMethod extends TFlexRequestMethod>(methodArg: TMethod, valueArg: unknown) => valueArg is TFlexRequest<TMethod>;
+export declare const isFlexHostRequestPayload: <TMethod extends TFlexHostRequestMethod>(methodArg: TMethod, valueArg: unknown) => valueArg is TFlexHostRequest<TMethod>;
+export declare const isFlexHostResponseResult: <TMethod extends TFlexHostRequestMethod>(methodArg: TMethod, valueArg: unknown) => valueArg is TFlexHostResponse<TMethod>;
+export declare const isFlexResponseResult: <TMethod extends TFlexRequestMethod>(methodArg: TMethod, valueArg: unknown) => valueArg is TFlexResponse<TMethod>;
+export declare const isFlexServiceError: (valueArg: unknown) => valueArg is IFlexServiceError;
+export declare const parseFlexParentMessage: (valueArg: unknown) => TFlexParentMessage;
+export declare const parseFlexChildMessage: (valueArg: unknown) => TFlexChildMessage;
+export declare const createFlexServiceError: (codeArg: TFlexServiceErrorCode) => IFlexServiceError;
+export declare class FlexServiceError extends Error {
+    readonly code: TFlexServiceErrorCode;
+    readonly name = "FlexServiceError";
+    constructor(code: TFlexServiceErrorCode);
+}
+export {};