import * as plugins from './plugins.js';
import {
  controllerFilesystemIdentityMaximumComponents,
  controllerProjectLimit,
  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;
export type TFlexProjectManagementSessionContext =
  plugins.flexharness.IFlexProjectManagementSessionContext;
export type TFlexSubagentProvenance = plugins.flexharness.IFlexSubagentProvenance;
type TFlexJsonValue = plugins.flexharness.TJsonValue;
export type TFlexSessionGeneration = plugins.flexharness.IFlexSessionGeneration;
export type TFlexSessionGenerationCohortEntry =
  plugins.flexharness.IFlexSessionGenerationCohortEntry;
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 const flexIpcProtocolVersion = 18 as const;
export const flexIpcMaximumFrameBytes = 2 * 1024 * 1024;
export const flexIpcTargetDeltaBytes = 16 * 1024;
export const flexIpcMaximumDeltaBytes = 32 * 1024;
export const flexIpcMaximumPendingRequests = 64;
export const flexIpcMaximumBrowserChannels = 128;
export const flexIpcMaximumBrowserFrameBytes = 256 * 1024 + 4;
export const flexIpcMaximumPendingBrowserFrames = 128;
export const flexIpcMaximumPendingBrowserFrameBytes = 8 * 1024 * 1024;
export const flexIpcMaximumChildJobs = 64;
export const flexIpcMaximumPromptQueueEntries = 128;
export const flexIpcMaximumQueuedSessionChanges = 256;
export const flexIpcMaximumQueuedSessionChangeBytes = 8 * 1024 * 1024;
export const flexGenerationLeaseCleanupTimeoutMs = 30_000;
export const flexIpcControlTimeoutMs = 35_000;
export const flexIpcMaximumHostTimeoutMs = 5 * 60 * 1000;
export const flexIpcReversionMaintenanceTimeoutMs =
  flexIpcMaximumHostTimeoutMs + flexIpcControlTimeoutMs;
export const flexIpcLifecycleTimeoutMs = 30 * 60 * 1000;
export const flexIpcStartupTimeoutMs = flexIpcLifecycleTimeoutMs;
export const flexIpcDisposeTimeoutMs = 10_000;
export const flexIpcSlashTimeoutMs = flexIpcLifecycleTimeoutMs;
export const flexIpcCancellationGraceTimeoutMs = 2_000;

export interface IFlexProjectRecord {
  projectId: string;
  directory: string;
  directoryIdentity?: IControllerProjectFilesystemIdentity;
}

export interface IFlexIdentityBoundProjectRecord extends IFlexProjectRecord {
  directoryIdentity: IControllerProjectFilesystemIdentity;
}

export interface IFlexProjectCleanupCohortEntry extends TFlexSessionGenerationCohortEntry {
  cleanupRoot: boolean;
}

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 };
  sessionGenerationId: string;
  sessionGenerationSequence: number;
}

export type TFlexGenerationBoundBrowserChannelBinding = IFlexBrowserChannelBinding;

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;
  sessionGenerationId: string;
  sessionGenerationSequence: number;
  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 IFlexDelegatedRunAdmissionContext {
  scopeId: string;
  storageKey: string;
  sessionId: string;
  sessionGenerationId: string;
  sessionGenerationSequence: number;
  queueId: string;
  runId: string;
  parentSessionId: string;
  parentSessionGenerationId: string;
  parentSessionGenerationSequence: number;
  parentQueueId: string;
  parentRunId: string;
  parentToolCallId: string;
  originParentRunId: string;
  originParentToolCallId: string;
  agent: string;
  depth: number;
}

export interface IFlexDelegatedRunAdmissionCloseRequest
  extends IFlexDelegatedRunAdmissionContext {
  leaseId: string;
}

export interface IFlexHostRequestMap {
  'delegated-run-admission.acquire': {
    request: IFlexDelegatedRunAdmissionContext;
    response: { leaseId: string; model: IFlexModelChoice };
  };
  'delegated-run-admission.close': {
    request: IFlexDelegatedRunAdmissionCloseRequest;
    response: { closed: true };
  };
  '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;
      sessionGenerationId: string;
      sessionGenerationSequence: number;
    };
    response: { worktree: IFlexGitWorktreeDescriptor };
  };
  'git.worktree.list': {
    request: {
      scopeId: string;
      sessionId: string;
      sessionGenerationId: string;
      sessionGenerationSequence: number;
    };
    response: { worktrees: IFlexGitWorktreeDescriptor[] };
  };
  'git.worktree.remove': {
    request: {
      scopeId: string;
      sessionId: string;
      sessionGenerationId: string;
      sessionGenerationSequence: number;
      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;
      sessionContext: TFlexProjectManagementSessionContext;
      registrationOperationId?: string;
    };
    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;
      sessionContext: TFlexProjectManagementSessionContext;
    };
    response: TFlexProjectManagementCommitResult;
  };
  'browser.resources.resolve': {
    request: {
      scopeId: string;
      sessionId: string;
      sessionGenerationId: string;
      sessionGenerationSequence: number;
      runId: string;
    };
    response: { resources: IFlexBrowserResourceDescriptor[] };
  };
  'browser.channel.open': {
    request: {
      scopeId: string;
      sessionId: string;
      sessionGenerationId: string;
      sessionGenerationSequence: number;
      runId: string;
      resourceId: string;
      attachmentRevision: number;
      channelId: string;
    };
    response: { binding: TFlexGenerationBoundBrowserChannelBinding; capabilityToken: string };
  };
  'browser.channel.close': {
    request: {
      channelId: string;
      sessionGenerationId: string;
      sessionGenerationSequence: number;
    };
    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 TFlexRetainedHostSuccessMethod =
  | 'delegated-run-admission.acquire'
  | 'git.worktree.create';

export const isFlexRetainedHostSuccessMethod = (
  methodArg: TFlexHostRequestMethod,
): methodArg is TFlexRetainedHostSuccessMethod => methodArg === 'delegated-run-admission.acquire'
  || methodArg === 'git.worktree.create';

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.register': {
    request: {
      project: IFlexIdentityBoundProjectRecord;
      registrationOperationId: string;
    };
    response: { registered: true; added: boolean };
  };
  'project.remove': {
    request: {
      project: IFlexIdentityBoundProjectRecord;
      removalOperationId: string;
      cleanupCohort: IFlexProjectCleanupCohortEntry[];
    };
    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 & {
        sessionId: string;
        sessionGenerationId: string;
      };
    };
    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;
      root: TFlexSessionGenerationCohortEntry;
      authorizedCohort: TFlexSessionGenerationCohortEntry[];
    };
    response: { matched: boolean };
  };
  '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 };
    response: { permissions: TFlexPermissionRequest[] };
  };
  'permission.respond': {
    request: {
      scopeId: string;
      sessionId: string;
      sessionGenerationId: string;
      sessionGenerationSequence: number;
      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;
  sessionGenerationId: string;
  sessionGenerationSequence: number;
}

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 const flexServiceErrorMessages: Readonly<Record<TFlexServiceErrorCode, string>> = {
  INVALID_REQUEST: 'The Flex request is invalid.',
  NOT_READY: 'The Flex service is not ready.',
  NOT_FOUND: 'The requested Flex resource was not found.',
  CONFLICT: 'The Flex operation conflicted with a concurrent change.',
  BUSY: 'The Flex resource is busy.',
  TIMEOUT: 'The Flex operation timed out.',
  ABORTED: 'The Flex operation was aborted.',
  OUTCOME_UNKNOWN: 'The Flex operation outcome is unknown.',
  SLASH_UNAVAILABLE: 'The Flex slash command is unavailable.',
  LIMIT_EXCEEDED: 'The Flex service limit was reached.',
  STALE_RUN: 'The requested Flex run is no longer current.',
  PROVIDER_LOGIN_FAILED: 'The provider login did not complete.',
  PROVIDER_REAUTH_REQUIRED: 'The provider connection requires authentication.',
  MODEL_CATALOG_REQUIRED: 'The provider model catalog must be refreshed.',
  UNSUPPORTED_RUNTIME: 'The Flex child runtime is unsupported.',
  INTERNAL: 'The Flex operation failed.',
};

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';

type TFlexChildSessionEvent = TFlexSessionGeneration & {
  scopeId: string;
  sessionId: string;
};

export type TFlexChildEvent =
  | (TFlexChildSessionEvent & {
      type: 'session.history.changed';
      direction: 'undo' | 'redo' | 'branch';
      runId?: string;
    })
  | {
      type: 'sessions.changed';
      coalesced: true;
    }
  | (TFlexChildSessionEvent & {
      type: 'sessions.changed';
      coalesced: boolean;
    })
  | (TFlexChildSessionEvent & {
      type: 'permissions.changed';
    })
  | (TFlexChildSessionEvent & {
      type: 'tool.updated';
      runId: string;
      messageId: string;
      messageIndex: number;
      partIndex: number;
      sequence: number;
      timestamp: string;
      part: TFlexToolMessagePart;
    })
  | (TFlexChildSessionEvent & {
      type: 'reasoning.updated';
      runId: string;
      messageId: string;
      messageIndex: number;
      partIndex: number;
      sequence: number;
      timestamp: string;
      part: TFlexReasoningMessagePart;
    })
  | (TFlexChildSessionEvent & {
      type: 'text.updated';
      runId: string;
      messageId: string;
      messageIndex: number;
      partIndex: number;
      sequence: number;
      timestamp: string;
      status: 'running' | 'completed';
      part: TFlexTextMessagePart;
    })
  | (TFlexChildSessionEvent & {
      type: 'part.delta';
      runId: string;
      messageId: string;
      messageIndex: number;
      partId: string;
      partIndex: number;
      sequence: number;
      timestamp: string;
      partType: 'text' | 'reasoning';
      delta: string;
      baseTextUtf8Bytes: number;
      textUtf8Bytes: number;
    })
  | (TFlexChildSessionEvent & {
      type: 'prompt.queued';
      queueId: string;
      runId?: never;
      entry: TFlexPromptQueueEntry;
    })
  | (TFlexChildSessionEvent & {
      type: 'prompt.started' | 'prompt.running' | 'prompt.finished';
      queueId: string;
      runId: string;
      entry: TFlexPromptQueueEntry;
    })
  | (TFlexChildSessionEvent & {
      type: 'prompt.message-bound';
      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;

const requestMethods: ReadonlySet<string> = new Set<TFlexRequestMethod>([
  'service.status',
  'project.register',
  'project.remove',
  'intelligence.start',
  'intelligence.get',
  'intelligence.cancel',
  'session.list',
  'session.create',
  'session.get',
  'session.update',
  'session.delete',
  'session.compact',
  'session.reversion.info',
  'slash.list',
  'slash.execute',
  'message.page',
  'message.get',
  'prompt.start',
  'prompt.acknowledge',
  'prompt.get',
  'prompt.list',
  'prompt.cancel',
  'permission.list',
  'permission.respond',
  'provider.list',
  'provider.login.begin',
  'provider.login.status',
  'provider.login.cancel',
  'provider.connection.list',
  'provider.connection.opencode-auth.get',
  'provider.connection.logout.prepare',
  'provider.connection.logout',
  'provider.connection.ratelimits.get',
  'provider.models.refresh',
  'model.choice.get',
  'model.choice.set',
  'model.choice.validate',
]);
const hostRequestMethods: ReadonlySet<string> = new Set<TFlexHostRequestMethod>([
  'delegated-run-admission.acquire',
  'delegated-run-admission.close',
  'reversion.prepare',
  'reversion.inspect-capture',
  'reversion.finalize',
  'reversion.inspect-apply',
  'reversion.apply',
  'reversion.release',
  'git.worktree.create',
  'git.worktree.list',
  'git.worktree.remove',
  'crossharness.chats.list',
  'crossharness.chat.read',
  'project-management.load',
  'project-management.save',
  'project-management.tombstone',
  'browser.resources.resolve',
  'browser.channel.open',
  'browser.channel.close',
]);
const serviceStates: ReadonlySet<string> = new Set<TFlexServiceState>([
  'starting', 'ready', 'unsupported', 'failed', 'stopping', 'stopped',
]);
const serviceStatusCodes: ReadonlySet<string> = new Set<TFlexServiceStatusCode>([
  'UNSUPPORTED_RUNTIME', 'INITIALIZATION_FAILED', 'SERVICE_STOPPED',
]);
const serviceErrorCodes: ReadonlySet<string> = new Set<TFlexServiceErrorCode>(
  Object.keys(flexServiceErrorMessages) as TFlexServiceErrorCode[],
);
const identifierPattern = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,511}$/u;
const projectIdPattern = /^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/u;
const requestIdPattern = /^[A-Za-z0-9_-]{22}$/u;
const qualifiedIdPattern = /^flex:(?:job|provider:openai):[A-Za-z0-9_-]{22}$/u;
const intelligenceCapabilityTokenPattern = /^[A-Za-z0-9_-]{43}$/u;
const delegatedRunAdmissionLeaseIdPattern = /^[A-Za-z0-9_-]{43}$/u;

export const isFlexDelegatedRunAdmissionLeaseId = (valueArg: unknown): valueArg is string => {
  if (typeof valueArg !== 'string' || !delegatedRunAdmissionLeaseIdPattern.test(valueArg)) {
    return false;
  }
  const decoded = Buffer.from(valueArg, 'base64url');
  return decoded.byteLength === 32 && decoded.toString('base64url') === valueArg;
};
const operationIdPattern = /^[A-Za-z0-9_-]{32}$/u;
const controlCharacterPattern = /[\u0000-\u001f\u007f]/u;

export const isFlexPlainObject = (valueArg: unknown): valueArg is Record<string, unknown> =>
  typeof valueArg === 'object'
  && valueArg !== null
  && !Array.isArray(valueArg)
  && (
    Object.getPrototypeOf(valueArg) === Object.prototype
    || Object.getPrototypeOf(valueArg) === null
  );

export const hasFlexExactKeys = (
  valueArg: Record<string, unknown>,
  requiredKeysArg: readonly string[],
  optionalKeysArg: readonly string[] = [],
): boolean => {
  const keys = Object.keys(valueArg);
  return requiredKeysArg.every((key) => Object.hasOwn(valueArg, key))
    && keys.every((key) => requiredKeysArg.includes(key) || optionalKeysArg.includes(key));
};

const isBoundedString = (
  valueArg: unknown,
  maximumBytesArg: number,
  allowEmptyArg = false,
): valueArg is string => typeof valueArg === 'string'
  && (allowEmptyArg || valueArg.length > 0)
  && Buffer.byteLength(valueArg, 'utf8') <= maximumBytesArg;

const hasExactDeltaUtf8Coordinates = (
  deltaArg: string,
  baseTextUtf8BytesArg: number,
  textUtf8BytesArg: number,
): boolean => {
  const encodedDeltaBytes = Buffer.byteLength(deltaArg, 'utf8');
  const increment = textUtf8BytesArg - baseTextUtf8BytesArg;
  if (increment === encodedDeltaBytes) return true;
  const firstCodeUnit = deltaArg.charCodeAt(0);
  return firstCodeUnit >= 0xDC00
    && firstCodeUnit <= 0xDFFF
    && increment === encodedDeltaBytes - 2;
};

const isIdentifier = (valueArg: unknown): valueArg is string =>
  isBoundedString(valueArg, 512) && identifierPattern.test(valueArg);

const isRequestId = (valueArg: unknown): valueArg is string =>
  typeof valueArg === 'string' && requestIdPattern.test(valueArg);

const isChannelId = (valueArg: unknown): valueArg is string =>
  typeof valueArg === 'string' && identifierPattern.test(valueArg);

const isCanonicalBrowserFrame = (valueArg: unknown): valueArg is string => {
  if (typeof valueArg !== 'string' || valueArg.length === 0) return false;
  const bytes = Buffer.from(valueArg, 'base64');
  return bytes.byteLength >= 1
    && bytes.byteLength <= flexIpcMaximumBrowserFrameBytes
    && bytes.toString('base64') === valueArg;
};

const isQualifiedId = (valueArg: unknown): valueArg is string =>
  typeof valueArg === 'string' && qualifiedIdPattern.test(valueArg);

const isIntelligenceCapabilityToken = (valueArg: unknown): valueArg is string =>
  typeof valueArg === 'string' && intelligenceCapabilityTokenPattern.test(valueArg);

const isIsoDate = (valueArg: unknown): valueArg is string =>
  isBoundedString(valueArg, 64)
  && Number.isFinite(Date.parse(valueArg))
  && new Date(valueArg).toISOString() === valueArg;

const isNonNegativeInteger = (valueArg: unknown): valueArg is number =>
  Number.isSafeInteger(valueArg) && (valueArg as number) >= 0;

const isFlexIntelligenceSessionId = (
  valueArg: unknown,
): valueArg is IFlexIntelligenceSessionId => isFlexPlainObject(valueArg)
  && hasFlexExactKeys(valueArg, ['harnessId', 'nativeId'])
  && (valueArg.harnessId === 'opencode' || valueArg.harnessId === 'flex')
  && isIdentifier(valueArg.nativeId);

const isFlexIntelligenceChatSummary = (
  valueArg: unknown,
): valueArg is IFlexIntelligenceChatSummary => isFlexPlainObject(valueArg)
  && hasFlexExactKeys(valueArg, ['sessionId', 'title', 'updatedAt'], ['isActive'])
  && isFlexIntelligenceSessionId(valueArg.sessionId)
  && isBoundedString(valueArg.title, 4096, true)
  && isIsoDate(valueArg.updatedAt)
  && (valueArg.isActive === undefined || typeof valueArg.isActive === 'boolean');

const isFlexIntelligenceChatMessage = (
  valueArg: unknown,
): valueArg is IFlexIntelligenceChatMessage => isFlexPlainObject(valueArg)
  && hasFlexExactKeys(valueArg, ['role', 'text'], ['timestamp'])
  && isBoundedString(valueArg.role, 128)
  && isBoundedString(valueArg.text, 16 * 1024, true)
  && (valueArg.timestamp === undefined || isIsoDate(valueArg.timestamp));

const isFlexIntelligenceChatTranscript = (
  valueArg: unknown,
): valueArg is IFlexIntelligenceChatTranscript => isFlexPlainObject(valueArg)
  && hasFlexExactKeys(valueArg, ['sessionId', 'title', 'messages'], ['totalMessages'])
  && isFlexIntelligenceSessionId(valueArg.sessionId)
  && isBoundedString(valueArg.title, 4096, true)
  && Array.isArray(valueArg.messages)
  && valueArg.messages.length <= 50
  && valueArg.messages.every(isFlexIntelligenceChatMessage)
  && (valueArg.totalMessages === undefined || isNonNegativeInteger(valueArg.totalMessages))
  && Buffer.byteLength(JSON.stringify(valueArg), 'utf8') <= 256 * 1024;

const isFlexIntelligenceResult = (valueArg: unknown): valueArg is IFlexIntelligenceResult => (
  isFlexPlainObject(valueArg)
  && hasFlexExactKeys(valueArg, ['answer', 'scratchpad', 'model'])
  && isBoundedString(valueArg.answer, 128 * 1024, true)
  && isBoundedString(valueArg.scratchpad, 128 * 1024, true)
  && valueArg.answer.length <= 32_768
  && valueArg.scratchpad.length <= 32_768
  && valueArg.model === 'openai/gpt-5.6-luna'
);

const isJsonValue = (valueArg: unknown, depthArg = 0): boolean => {
  if (depthArg > 20) return false;
  if (
    valueArg === null
    || typeof valueArg === 'string'
    || typeof valueArg === 'boolean'
    || (typeof valueArg === 'number' && Number.isFinite(valueArg))
  ) return true;
  if (Array.isArray(valueArg)) {
    return valueArg.length <= 4096 && valueArg.every((entry) => isJsonValue(entry, depthArg + 1));
  }
  if (!isFlexPlainObject(valueArg) || Object.keys(valueArg).length > 4096) return false;
  return Object.values(valueArg).every((entry) => isJsonValue(entry, depthArg + 1));
};

const isFlexSessionGeneration = (valueArg: Record<string, unknown>): boolean =>
  isBoundedString(
    valueArg.sessionGenerationId,
    plugins.flexharness.FLEX_SESSION_GENERATION_ID_MAX_BYTES,
  )
  && String(valueArg.sessionGenerationId).trim().length > 0
  && !controlCharacterPattern.test(String(valueArg.sessionGenerationId))
  && isNonNegativeInteger(valueArg.sessionGenerationSequence)
  && Number(valueArg.sessionGenerationSequence) >= 1;

const isFlexSessionGenerationCohortEntry = (
  valueArg: unknown,
): valueArg is TFlexSessionGenerationCohortEntry => isFlexPlainObject(valueArg)
  && hasFlexExactKeys(
    valueArg,
    ['sessionId', 'sessionGenerationId', 'sessionGenerationSequence'],
  )
  && isIdentifier(valueArg.sessionId)
  && isFlexSessionGeneration(valueArg);

const isFlexProjectCleanupCohortEntry = (
  valueArg: unknown,
): valueArg is IFlexProjectCleanupCohortEntry => isFlexPlainObject(valueArg)
  && hasFlexExactKeys(
    valueArg,
    ['sessionId', 'sessionGenerationId', 'sessionGenerationSequence', 'cleanupRoot'],
  )
  && isIdentifier(valueArg.sessionId)
  && isFlexSessionGeneration(valueArg)
  && typeof valueArg.cleanupRoot === 'boolean';

const isStrictlyOrderedFlexCohort = <TEntry extends { sessionId: string }>(
  valueArg: unknown,
  entryCheckArg: (entryArg: unknown) => entryArg is TEntry,
): valueArg is TEntry[] => {
  if (
    !Array.isArray(valueArg)
    || valueArg.length > plugins.flexharness.FLEX_SESSION_GENERATION_COHORT_MAX_ENTRIES
  ) return false;
  let previousSessionId: string | undefined;
  for (const entry of valueArg) {
    if (
      !entryCheckArg(entry)
      || (previousSessionId !== undefined && previousSessionId >= entry.sessionId)
    ) return false;
    previousSessionId = entry.sessionId;
  }
  return true;
};

const isFlexProjectManagementRecord = (
  valueArg: unknown,
): valueArg is TFlexProjectManagementRecord => {
  try {
    plugins.flexharness.assertFlexProjectManagementRecord(valueArg);
    return true;
  } catch {
    return false;
  }
};

const isFlexProjectManagementSnapshot = (
  valueArg: unknown,
): valueArg is TFlexProjectManagementSnapshot => {
  try {
    plugins.flexharness.assertFlexProjectManagementSnapshot(valueArg);
    return true;
  } catch {
    return false;
  }
};

const isFlexProjectManagementTombstone = (
  valueArg: unknown,
): valueArg is TFlexProjectManagementTombstone => {
  try {
    plugins.flexharness.assertFlexProjectManagementTombstone(valueArg);
    return true;
  } catch {
    return false;
  }
};

const isFlexProjectManagementWriteContext = (
  valueArg: unknown,
): valueArg is TFlexProjectManagementWriteContext => isFlexPlainObject(valueArg)
  && hasFlexExactKeys(valueArg, ['actor'], ['runId', 'agent', 'toolCallId'])
  && (valueArg.actor === 'agent' || valueArg.actor === 'application')
  && ['runId', 'agent', 'toolCallId'].every((key) => (
    valueArg[key] === undefined || isBoundedString(valueArg[key], 512)
  ));

const isFlexSubagentProvenance = (
  valueArg: unknown,
): valueArg is TFlexSubagentProvenance => isFlexPlainObject(valueArg)
  && hasFlexExactKeys(valueArg, [
    'parentSessionId',
    'parentSessionGenerationId',
    'parentSessionGenerationSequence',
    'originParentRunId',
    'originParentToolCallId',
    'agent',
    'depth',
  ])
  && isIdentifier(valueArg.parentSessionId)
  && isFlexSessionGeneration({
    sessionGenerationId: valueArg.parentSessionGenerationId,
    sessionGenerationSequence: valueArg.parentSessionGenerationSequence,
  })
  && isIdentifier(valueArg.originParentRunId)
  && isIdentifier(valueArg.originParentToolCallId)
  && isBoundedString(valueArg.agent, 128)
  && Number.isSafeInteger(valueArg.depth)
  && Number(valueArg.depth) >= 1
  && Number(valueArg.depth) <= 8;

const isFlexProjectManagementSessionContext = (
  valueArg: unknown,
): valueArg is TFlexProjectManagementSessionContext => isFlexPlainObject(valueArg)
  && hasFlexExactKeys(
    valueArg,
    ['sessionGenerationId', 'sessionGenerationSequence'],
    ['subagent'],
  )
  && isFlexSessionGeneration(valueArg)
  && (valueArg.subagent === undefined || isFlexSubagentProvenance(valueArg.subagent));

const isFlexProjectManagementCommitResult = (
  valueArg: unknown,
): valueArg is TFlexProjectManagementCommitResult => isFlexPlainObject(valueArg)
  && (
    (hasFlexExactKeys(valueArg, ['committed']) && valueArg.committed === true)
    || (
      hasFlexExactKeys(valueArg, ['committed', 'actualRevision'])
      && valueArg.committed === false
      && isNonNegativeInteger(valueArg.actualRevision)
    )
  );

export const isFlexProjectRecord = (valueArg: unknown): valueArg is IFlexProjectRecord => {
  if (!isFlexPlainObject(valueArg) || !hasFlexExactKeys(
    valueArg,
    ['projectId', 'directory'],
    ['directoryIdentity'],
  )) {
    return false;
  }
  if (
    typeof valueArg.projectId !== 'string'
    || !projectIdPattern.test(valueArg.projectId)
    || !isBoundedString(valueArg.directory, 4096)
    || valueArg.directory.includes('\0')
    || !plugins.path.isAbsolute(valueArg.directory)
    || plugins.path.normalize(valueArg.directory) !== valueArg.directory
  ) return false;
  if (valueArg.directoryIdentity === undefined) return true;
  const directoryIdentity = valueArg.directoryIdentity;
  if (!isFlexPlainObject(directoryIdentity) || !Array.isArray(directoryIdentity.ancestry)) {
    return false;
  }
  const ancestry = directoryIdentity.ancestry;
  return hasFlexExactKeys(directoryIdentity, ['ancestry'])
    && ancestry.length === 1
      + valueArg.directory.slice(1).split('/').filter(Boolean).length
    && ancestry.length <= controllerFilesystemIdentityMaximumComponents
    && ancestry.every((component) => (
      isFlexPlainObject(component)
      && hasFlexExactKeys(component, ['device', 'inode', 'type'])
      && typeof component.device === 'string'
      && /^(?:0|[1-9][0-9]{0,31})$/u.test(component.device)
      && typeof component.inode === 'string'
      && /^(?:0|[1-9][0-9]{0,31})$/u.test(component.inode)
      && component.type === 'directory'
    ));
};

export const isFlexIdentityBoundProjectRecord = (
  valueArg: unknown,
): valueArg is IFlexIdentityBoundProjectRecord => isFlexProjectRecord(valueArg)
  && valueArg.directoryIdentity !== undefined;

export const isFlexDatabaseDescriptor = (
  valueArg: unknown,
): valueArg is IFlexDatabaseDescriptor => isFlexPlainObject(valueArg)
  && hasFlexExactKeys(valueArg, ['mongoDbUrl', 'mongoDbName'])
  && isBoundedString(valueArg.mongoDbUrl, 4096)
  && /^(?:mongodb|mongodb\+srv):\/\//u.test(valueArg.mongoDbUrl)
  && typeof valueArg.mongoDbName === 'string'
  && /^[A-Za-z0-9_-]{1,63}$/u.test(valueArg.mongoDbName);

const isFlexCredentialDirectory = (valueArg: unknown): valueArg is string => {
  if (
    !isBoundedString(valueArg, 4096)
    || !valueArg.startsWith('/')
    || valueArg.includes('\0')
    || valueArg === '/'
  ) return false;
  const segments = valueArg.split('/');
  return !segments.some((segment, index) => (
    index > 0 && (segment === '' || segment === '.' || segment === '..')
  ));
};

export const isFlexServiceInit = (valueArg: unknown): valueArg is IFlexServiceInit => {
  if (
    !isFlexPlainObject(valueArg)
    || !hasFlexExactKeys(valueArg, [
      'controllerId', 'database', 'flexCredentialDirectory', 'projects',
    ])
    || !isIdentifier(valueArg.controllerId)
    || !isFlexDatabaseDescriptor(valueArg.database)
    || !isFlexCredentialDirectory(valueArg.flexCredentialDirectory)
    || !Array.isArray(valueArg.projects)
    || valueArg.projects.length > controllerProjectLimit
    || !valueArg.projects.every(isFlexProjectRecord)
  ) return false;
  return new Set(valueArg.projects.map((project) => project.projectId)).size
    === valueArg.projects.length;
};

export const isFlexServiceStatus = (valueArg: unknown): valueArg is IFlexServiceStatus => {
  if (
    !isFlexPlainObject(valueArg)
    || !hasFlexExactKeys(valueArg, ['state', 'ready'], ['code', 'startedAt'])
    || typeof valueArg.state !== 'string'
    || !serviceStates.has(valueArg.state)
    || typeof valueArg.ready !== 'boolean'
    || (valueArg.code !== undefined
      && (typeof valueArg.code !== 'string' || !serviceStatusCodes.has(valueArg.code)))
    || (valueArg.startedAt !== undefined && !isIsoDate(valueArg.startedAt))
  ) return false;
  if (valueArg.state === 'ready') return valueArg.ready && valueArg.code === undefined;
  return !valueArg.ready;
};

const isAccountSummary = (valueArg: unknown): valueArg is IFlexPublicAccountSummary =>
  isFlexPlainObject(valueArg)
  && hasFlexExactKeys(valueArg, ['providerId', 'authKind'], ['accountId', 'email', 'plan'])
  && valueArg.providerId === 'openai'
  && valueArg.authKind === 'chatgptOAuth'
  && ['accountId', 'email', 'plan'].every((key) => (
    valueArg[key] === undefined || isBoundedString(valueArg[key], 512)
  ));

export const isFlexPublicProviderConnection = (
  valueArg: unknown,
): valueArg is IFlexPublicProviderConnection => isFlexPlainObject(valueArg)
  && hasFlexExactKeys(valueArg, ['loginId', 'providerId', 'status'], ['account'])
  && isQualifiedId(valueArg.loginId)
  && valueArg.providerId === 'openai'
  && ['pending', 'active', 'deleting', 'reauthRequired'].includes(String(valueArg.status))
  && (valueArg.account === undefined || isAccountSummary(valueArg.account));

const isOpenCodeOAuthAuth = (valueArg: unknown): valueArg is IFlexOpenCodeOAuthAuth => (
  isFlexPlainObject(valueArg)
  && hasFlexExactKeys(valueArg, ['type', 'access', 'refresh', 'expires'], ['accountId'])
  && valueArg.type === 'oauth'
  && isBoundedString(valueArg.access, 16 * 1024)
  && isBoundedString(valueArg.refresh, 16 * 1024)
  && isNonNegativeInteger(valueArg.expires)
  && (valueArg.accountId === undefined || isBoundedString(valueArg.accountId, 512))
  && Buffer.byteLength(JSON.stringify(valueArg), 'utf8') <= 48 * 1024
);

const isModelChoice = (valueArg: unknown): valueArg is IFlexModelChoice =>
  isFlexPlainObject(valueArg)
  && hasFlexExactKeys(valueArg, ['providerConnectionId', 'modelId'], ['variant'])
  && isQualifiedId(valueArg.providerConnectionId)
  && isBoundedString(valueArg.modelId, 256)
  && (valueArg.variant === undefined || isBoundedString(valueArg.variant, 128));

const isModelIdentity = (valueArg: unknown): boolean => isFlexPlainObject(valueArg)
  && hasFlexExactKeys(valueArg, ['provider', 'model'], ['displayName', 'variant'])
  && isBoundedString(valueArg.provider, 256)
  && isBoundedString(valueArg.model, 256)
  && (valueArg.displayName === undefined || isBoundedString(valueArg.displayName, 512))
  && (valueArg.variant === undefined || isBoundedString(valueArg.variant, 128));

const isUsage = (valueArg: unknown): boolean => isFlexPlainObject(valueArg)
  && hasFlexExactKeys(valueArg, [
    'inputTokens', 'outputTokens', 'totalTokens', 'cacheReadTokens', 'cacheWriteTokens',
  ])
  && Object.values(valueArg).every(isNonNegativeInteger);

const isMessagePart = (valueArg: unknown, textByteLimitArg = 96 * 1024): boolean => {
  if (!isFlexPlainObject(valueArg) || !isIdentifier(valueArg.partId)) return false;
  switch (valueArg.type) {
    case 'text':
      return hasFlexExactKeys(valueArg, ['partId', 'type', 'text'])
        && isBoundedString(valueArg.text, textByteLimitArg, true);
    case 'reasoning':
      return hasFlexExactKeys(valueArg, ['partId', 'type', 'text', 'status'])
        && isBoundedString(valueArg.text, textByteLimitArg, true)
        && ['running', 'completed', 'cancelled'].includes(String(valueArg.status));
    case 'tool':
      return hasFlexExactKeys(
        valueArg,
        ['partId', 'type', 'toolCallId', 'toolName', 'status', 'input'],
        ['output', 'error', 'childSessionId', 'model'],
      )
        && isIdentifier(valueArg.toolCallId)
        && isBoundedString(valueArg.toolName, 512)
        && ['running', 'completed', 'failed', 'cancelled'].includes(String(valueArg.status))
        && isJsonValue(valueArg.input)
        && (valueArg.output === undefined || isJsonValue(valueArg.output))
        && (valueArg.error === undefined || isBoundedString(valueArg.error, 2048))
        && (valueArg.childSessionId === undefined || isIdentifier(valueArg.childSessionId))
        && (valueArg.model === undefined || (
          valueArg.childSessionId !== undefined && isModelIdentity(valueArg.model)
        ));
    case 'attachment':
      return hasFlexExactKeys(
        valueArg,
        ['partId', 'type', 'attachmentType', 'source'],
        ['sizeBytes', 'mediaType', 'name'],
      )
        && ['image', 'file'].includes(String(valueArg.attachmentType))
        && ['inline-base64', 'data-url', 'remote-url'].includes(String(valueArg.source))
        && (valueArg.sizeBytes === undefined || isNonNegativeInteger(valueArg.sizeBytes))
        && (valueArg.mediaType === undefined || isBoundedString(valueArg.mediaType, 512))
        && (valueArg.name === undefined || isBoundedString(valueArg.name, 1024));
    default:
      return false;
  }
};

export const isFlexPublicMessage = (valueArg: unknown): valueArg is TFlexMessage =>
  isFlexPlainObject(valueArg)
  && hasFlexExactKeys(
    valueArg,
    ['messageId', 'sessionId', 'runId', 'role', 'status', 'createdAt', 'parts'],
    ['completedAt', 'model', 'usage', 'error'],
  )
  && isIdentifier(valueArg.messageId)
  && isIdentifier(valueArg.sessionId)
  && isIdentifier(valueArg.runId)
  && ['user', 'assistant'].includes(String(valueArg.role))
  && ['streaming', 'completed', 'failed', 'cancelled'].includes(String(valueArg.status))
  && isIsoDate(valueArg.createdAt)
  && (valueArg.completedAt === undefined || isIsoDate(valueArg.completedAt))
  && Array.isArray(valueArg.parts)
  && valueArg.parts.length <= 2000
  && valueArg.parts.every((partArg) => isMessagePart(partArg))
  && (valueArg.model === undefined || isModelIdentity(valueArg.model))
  && (valueArg.usage === undefined || isUsage(valueArg.usage))
  && (valueArg.error === undefined || isBoundedString(valueArg.error, 2048));

export const isFlexPublicSession = (valueArg: unknown): valueArg is TFlexSession => {
  if (
    !isFlexPlainObject(valueArg)
    || !hasFlexExactKeys(
      valueArg,
      ['scopeId', 'sessionId', 'createdAt', 'updatedAt', 'status', 'activity'],
      [
        'sessionGenerationId', 'sessionGenerationSequence',
        'title', 'archivedAt', 'parentSessionId', 'parentRunId',
        'parentToolCallId', 'agent', 'depth',
      ],
    )
    || !isIdentifier(valueArg.scopeId)
    || !isIdentifier(valueArg.sessionId)
    || !isIsoDate(valueArg.createdAt)
    || !isIsoDate(valueArg.updatedAt)
    || (valueArg.title !== undefined || Object.hasOwn(valueArg, 'title'))
      && !isBoundedString(valueArg.title, 4096, true)
    || (valueArg.archivedAt !== undefined && !isIsoDate(valueArg.archivedAt))
    || !['idle', 'scheduled', 'running', 'waiting_permission', 'failed', 'cancelled']
      .includes(String(valueArg.status))
    || !isFlexPlainObject(valueArg.activity)
    || !hasFlexExactKeys(valueArg.activity, ['status'], [
      'runId', 'startedAt', 'completedAt', 'error',
    ])
    || !['idle', 'scheduled', 'running', 'waiting_permission', 'failed', 'cancelled']
      .includes(String(valueArg.activity.status))
  ) return false;
  const hasGenerationId = valueArg.sessionGenerationId !== undefined;
  const hasGenerationSequence = valueArg.sessionGenerationSequence !== undefined;
  if (
    hasGenerationId !== hasGenerationSequence
    || (hasGenerationId && !isFlexSessionGeneration(valueArg))
  ) return false;
  const relationship = [
    valueArg.parentSessionId,
    valueArg.parentRunId,
    valueArg.parentToolCallId,
    valueArg.agent,
  ];
  const relationshipCount = relationship.filter((entry) => entry !== undefined).length;
  return (valueArg.activity.runId === undefined || isIdentifier(valueArg.activity.runId))
    && (valueArg.activity.startedAt === undefined || isIsoDate(valueArg.activity.startedAt))
    && (valueArg.activity.completedAt === undefined || isIsoDate(valueArg.activity.completedAt))
    && (valueArg.activity.error === undefined || isBoundedString(valueArg.activity.error, 2048))
    && (relationshipCount === 0 || relationshipCount === relationship.length)
    && (valueArg.parentSessionId === undefined || isIdentifier(valueArg.parentSessionId))
    && (valueArg.parentRunId === undefined || isIdentifier(valueArg.parentRunId))
    && (valueArg.parentToolCallId === undefined || isIdentifier(valueArg.parentToolCallId))
    && (valueArg.agent === undefined || isBoundedString(valueArg.agent, 128))
    && (
      relationshipCount === 0
        ? valueArg.depth === undefined || valueArg.depth === 0
        : Number.isSafeInteger(valueArg.depth)
          && Number(valueArg.depth) >= 1
          && Number(valueArg.depth) <= 8
    );
};

const isPromptQueueEntry = (valueArg: unknown): valueArg is TFlexPromptQueueEntry => (
  isFlexPlainObject(valueArg)
  && hasFlexExactKeys(
    valueArg,
    ['queueId', 'queueSequence', 'scopeId', 'sessionId', 'status', 'queuedAt'],
    ['runId', 'scheduleKey', 'startedAt', 'finishedAt', 'error'],
  )
  && isIdentifier(valueArg.queueId)
  && isNonNegativeInteger(valueArg.queueSequence)
  && valueArg.queueSequence >= 1
  && isIdentifier(valueArg.scopeId)
  && isIdentifier(valueArg.sessionId)
  && ['queued', 'starting', 'scheduled', 'running', 'completed', 'failed', 'cancelled']
    .includes(String(valueArg.status))
  && isIsoDate(valueArg.queuedAt)
  && (valueArg.runId === undefined || isIdentifier(valueArg.runId))
  && (valueArg.scheduleKey === undefined || isIdentifier(valueArg.scheduleKey))
  && (valueArg.startedAt === undefined || isIsoDate(valueArg.startedAt))
  && (valueArg.finishedAt === undefined || isIsoDate(valueArg.finishedAt))
  && (valueArg.error === undefined || (
    isFlexPlainObject(valueArg.error)
    && hasFlexExactKeys(valueArg.error, ['name', 'message'], ['code'])
    && isBoundedString(valueArg.error.name, 128)
    && isBoundedString(valueArg.error.message, 2048)
    && (valueArg.error.code === undefined || isBoundedString(valueArg.error.code, 128))
  ))
);

const isPermissionRequest = (valueArg: unknown): valueArg is TFlexPermissionRequest =>
  isFlexPlainObject(valueArg)
  && hasFlexExactKeys(
    valueArg,
    [
      'permissionId', 'scopeId', 'sessionId',
      'sessionGenerationId', 'sessionGenerationSequence',
      'runId', 'createdAt', 'kind', 'description',
    ],
    ['toolCallId', 'rememberKey', 'metadata'],
  )
  && isIdentifier(valueArg.permissionId)
  && isIdentifier(valueArg.scopeId)
  && isIdentifier(valueArg.sessionId)
  && isFlexSessionGeneration(valueArg)
  && isIdentifier(valueArg.runId)
  && isIsoDate(valueArg.createdAt)
  && isBoundedString(valueArg.kind, 128)
  && isBoundedString(valueArg.description, 2048)
  && (valueArg.toolCallId === undefined || isIdentifier(valueArg.toolCallId))
  && (valueArg.rememberKey === undefined || isBoundedString(valueArg.rememberKey, 512))
  && (valueArg.metadata === undefined || isJsonValue(valueArg.metadata));

const isPrompt = (valueArg: unknown): valueArg is TFlexPrompt => {
  if (isBoundedString(valueArg, 768 * 1024, true)) return true;
  if (!Array.isArray(valueArg) || valueArg.length < 1 || valueArg.length > 128) return false;
  return valueArg.every((part) => {
    if (!isFlexPlainObject(part)) return false;
    if (part.type === 'text') {
      return hasFlexExactKeys(part, ['type', 'text'])
        && isBoundedString(part.text, 768 * 1024, true);
    }
    if (part.type === 'image') {
      return hasFlexExactKeys(part, ['type', 'data'], ['mediaType', 'name'])
        && isBoundedString(part.data, 768 * 1024)
        && (part.mediaType === undefined || isBoundedString(part.mediaType, 512))
        && (part.name === undefined || isBoundedString(part.name, 1024));
    }
    if (part.type === 'file') {
      return hasFlexExactKeys(part, ['type', 'data', 'mediaType'], ['name'])
        && isBoundedString(part.data, 768 * 1024)
        && isBoundedString(part.mediaType, 512)
        && (part.name === undefined || isBoundedString(part.name, 1024));
    }
    return false;
  });
};

const isPromptOptions = (valueArg: unknown): valueArg is TFlexPromptOptions =>
  isFlexPlainObject(valueArg)
  && hasFlexExactKeys(valueArg, [], ['modelHint', 'system', 'maxSteps'])
  && (valueArg.modelHint === undefined || isBoundedString(valueArg.modelHint, 512))
  && (valueArg.system === undefined || isBoundedString(valueArg.system, 128 * 1024, true))
  && (valueArg.maxSteps === undefined
    || (Number.isSafeInteger(valueArg.maxSteps) && Number(valueArg.maxSteps) >= 1
      && Number(valueArg.maxSteps) <= 1000));

const isCreateSessionOptions = (valueArg: unknown): valueArg is TFlexCreateSessionOptions =>
  isFlexPlainObject(valueArg)
  && hasFlexExactKeys(valueArg, ['sessionId', 'sessionGenerationId'], ['title'])
  && isIdentifier(valueArg.sessionId)
  && isFlexSessionGeneration({
    sessionGenerationId: valueArg.sessionGenerationId,
    sessionGenerationSequence: 1,
  })
  && (valueArg.title === undefined || isBoundedString(valueArg.title, 4096, true));

const isUpdateSessionOptions = (valueArg: unknown): valueArg is TFlexUpdateSessionOptions =>
  isFlexPlainObject(valueArg)
  && hasFlexExactKeys(valueArg, [], ['title', 'archived'])
  && (valueArg.title === undefined || valueArg.title === null
    || isBoundedString(valueArg.title, 4096, true))
  && (valueArg.archived === undefined || typeof valueArg.archived === 'boolean');

const isScopeAndSession = (valueArg: Record<string, unknown>): boolean =>
  isIdentifier(valueArg.scopeId) && isIdentifier(valueArg.sessionId);

export const flexDelegatedRunAdmissionContextKeys = [
  'scopeId',
  'storageKey',
  'sessionId',
  'sessionGenerationId',
  'sessionGenerationSequence',
  'queueId',
  'runId',
  'parentSessionId',
  'parentSessionGenerationId',
  'parentSessionGenerationSequence',
  'parentQueueId',
  'parentRunId',
  'parentToolCallId',
  'originParentRunId',
  'originParentToolCallId',
  'agent',
  'depth',
] as const;

const isFlexDelegatedRunAdmissionContext = (
  valueArg: Record<string, unknown>,
  extraRequiredKeysArg: readonly string[] = [],
): boolean => hasFlexExactKeys(
  valueArg,
  [...flexDelegatedRunAdmissionContextKeys, ...extraRequiredKeysArg],
)
  && isIdentifier(valueArg.scopeId)
  && isIdentifier(valueArg.storageKey)
  && isIdentifier(valueArg.sessionId)
  && isFlexSessionGeneration(valueArg)
  && isIdentifier(valueArg.queueId)
  && isIdentifier(valueArg.runId)
  && isIdentifier(valueArg.parentSessionId)
  && isFlexSessionGeneration({
    sessionGenerationId: valueArg.parentSessionGenerationId,
    sessionGenerationSequence: valueArg.parentSessionGenerationSequence,
  })
  && isIdentifier(valueArg.parentQueueId)
  && isIdentifier(valueArg.parentRunId)
  && isIdentifier(valueArg.parentToolCallId)
  && isIdentifier(valueArg.originParentRunId)
  && isIdentifier(valueArg.originParentToolCallId)
  && isBoundedString(valueArg.agent, 128)
  && Number.isSafeInteger(valueArg.depth)
  && Number(valueArg.depth) >= 1
  && Number(valueArg.depth) <= 8
  && (extraRequiredKeysArg.length === 0
    || isFlexDelegatedRunAdmissionLeaseId(valueArg.leaseId));

const isAffectedWorkspace = (valueArg: unknown): boolean => isFlexPlainObject(valueArg)
  && hasFlexExactKeys(valueArg, ['id', 'label'])
  && isBoundedString(valueArg.id, 512)
  && valueArg.id.trim().length > 0
  && isBoundedString(valueArg.label, 2048)
  && valueArg.label.trim().length > 0;

const isReversionOutcome = (
  valueArg: unknown,
): valueArg is TFlexTurnReversionFinalizedOutcome => {
  if (!isFlexPlainObject(valueArg) || !isJsonValue(valueArg.reference)) return false;
  if (valueArg.disposition === 'no-change') {
    return hasFlexExactKeys(valueArg, ['disposition', 'reference'], ['affectedWorkspaces'])
      && (valueArg.affectedWorkspaces === undefined
        || (Array.isArray(valueArg.affectedWorkspaces) && valueArg.affectedWorkspaces.length === 0));
  }
  if (valueArg.disposition === 'revertible') {
    return hasFlexExactKeys(valueArg, ['disposition', 'reference', 'affectedWorkspaces'])
      && Array.isArray(valueArg.affectedWorkspaces)
      && valueArg.affectedWorkspaces.length >= 1
      && valueArg.affectedWorkspaces.length <= 64
      && valueArg.affectedWorkspaces.every(isAffectedWorkspace)
      && new Set(valueArg.affectedWorkspaces.map((entry) => (
        entry as { id: string }
      ).id)).size === valueArg.affectedWorkspaces.length;
  }
  return valueArg.disposition === 'nonrevertible'
    && hasFlexExactKeys(
      valueArg,
      ['disposition', 'reference', 'reasonCode'],
      ['affectedWorkspaces'],
    )
    && isBoundedString(valueArg.reasonCode, 128)
    && /^[A-Za-z0-9][A-Za-z0-9._-]*$/u.test(valueArg.reasonCode)
    && (valueArg.affectedWorkspaces === undefined || (
      Array.isArray(valueArg.affectedWorkspaces)
      && valueArg.affectedWorkspaces.length <= 64
      && valueArg.affectedWorkspaces.every(isAffectedWorkspace)
    ));
};

const isSlashDescriptor = (valueArg: unknown): valueArg is TFlexSlashCommandDescriptor => (
  isFlexPlainObject(valueArg)
  && hasFlexExactKeys(
    valueArg,
    ['name', 'description', 'kind', 'hints', 'available', 'workspaceReversion'],
    ['unavailableReason'],
  )
  && typeof valueArg.name === 'string'
  && /^[a-z][a-z0-9-]{0,63}$/u.test(valueArg.name)
  && isBoundedString(valueArg.description, 2048, true)
  && ['builtin', 'template', 'handler'].includes(String(valueArg.kind))
  && Array.isArray(valueArg.hints)
  && valueArg.hints.length <= 64
  && valueArg.hints.every((hint) => isBoundedString(hint, 128))
  && typeof valueArg.available === 'boolean'
  && (valueArg.unavailableReason === undefined
    || isBoundedString(valueArg.unavailableReason, 2048))
  && ['supported', 'unsupported', 'not-applicable'].includes(
    String(valueArg.workspaceReversion),
  )
);

const isSlashInvocation = (valueArg: Record<string, unknown>): boolean => (
  isBoundedString(valueArg.input, 768 * 1024)
  && typeof valueArg.name === 'string'
  && /^[a-z][a-z0-9-]{0,63}$/u.test(valueArg.name)
  && isBoundedString(valueArg.rawArguments, 768 * 1024, true)
  && Array.isArray(valueArg.arguments)
  && valueArg.arguments.length <= 4096
  && valueArg.arguments.every((entry) => isBoundedString(entry, 768 * 1024, true))
);

const isSlashExecutionResult = (valueArg: unknown): valueArg is TFlexSlashExecutionResult => {
  if (!isFlexPlainObject(valueArg) || typeof valueArg.type !== 'string') return false;
  if (valueArg.type === 'not-command') return hasFlexExactKeys(valueArg, ['type']);
  if (valueArg.type === 'malformed') {
    return hasFlexExactKeys(valueArg, ['type', 'reason'])
      && isBoundedString(valueArg.reason, 2048);
  }
  if (valueArg.type === 'unknown') {
    return hasFlexExactKeys(valueArg, ['type', 'input', 'name', 'rawArguments', 'arguments'])
      && isSlashInvocation(valueArg);
  }
  if (valueArg.type === 'operation') {
    return hasFlexExactKeys(valueArg, ['type', 'name'])
      && typeof valueArg.name === 'string'
      && /^[a-z][a-z0-9-]{0,63}$/u.test(valueArg.name);
  }
  if (valueArg.type === 'handler-result') {
    return hasFlexExactKeys(valueArg, ['type', 'name', 'result'])
      && typeof valueArg.name === 'string'
      && /^[a-z][a-z0-9-]{0,63}$/u.test(valueArg.name)
      && isJsonValue(valueArg.result);
  }
  return valueArg.type === 'prompt-admission'
    && hasFlexExactKeys(valueArg, ['type', 'name', 'admission'])
    && typeof valueArg.name === 'string'
    && /^[a-z][a-z0-9-]{0,63}$/u.test(valueArg.name)
    && isFlexPlainObject(valueArg.admission)
    && hasFlexExactKeys(valueArg.admission, ['queueId', 'runId'])
    && isIdentifier(valueArg.admission.queueId)
    && isIdentifier(valueArg.admission.runId);
};

const isSessionReversionInfo = (valueArg: unknown): valueArg is TFlexSessionReversionInfo => (
  isFlexPlainObject(valueArg)
  && hasFlexExactKeys(valueArg, ['undoAvailable', 'redoAvailable', 'groups'])
  && typeof valueArg.undoAvailable === 'boolean'
  && typeof valueArg.redoAvailable === 'boolean'
  && Array.isArray(valueArg.groups)
  && valueArg.groups.length <= 3000
  && valueArg.groups.every((entry) => isFlexPlainObject(entry)
    && hasFlexExactKeys(entry, [
      'runId', 'kind', 'visibility', 'affectedWorkspaces', 'affectedWorkspacesTruncated',
    ])
    && isIdentifier(entry.runId)
    && ['candidate', 'barrier', 'no-change'].includes(String(entry.kind))
    && ['visible', 'hidden'].includes(String(entry.visibility))
    && Array.isArray(entry.affectedWorkspaces)
    && entry.affectedWorkspaces.length <= 64
    && entry.affectedWorkspaces.every(isAffectedWorkspace)
    && typeof entry.affectedWorkspacesTruncated === 'boolean')
);

export const isFlexRequestPayload = <TMethod extends TFlexRequestMethod>(
  methodArg: TMethod,
  valueArg: unknown,
): valueArg is TFlexRequest<TMethod> => {
  if (!isFlexPlainObject(valueArg)) return false;
  switch (methodArg) {
    case 'service.status':
    case 'provider.list':
    case 'provider.connection.list':
      return hasFlexExactKeys(valueArg, []);
    case 'project.register':
      return hasFlexExactKeys(valueArg, ['project', 'registrationOperationId'])
        && isFlexIdentityBoundProjectRecord(valueArg.project)
        && typeof valueArg.registrationOperationId === 'string'
        && operationIdPattern.test(valueArg.registrationOperationId);
    case 'project.remove':
      return hasFlexExactKeys(valueArg, ['project', 'removalOperationId', 'cleanupCohort'])
        && isFlexIdentityBoundProjectRecord(valueArg.project)
        && typeof valueArg.removalOperationId === 'string'
        && operationIdPattern.test(valueArg.removalOperationId)
        && isStrictlyOrderedFlexCohort(
          valueArg.cleanupCohort,
          isFlexProjectCleanupCohortEntry,
        )
        && (
          valueArg.cleanupCohort.length === 0
          || valueArg.cleanupCohort.some((entry) => entry.cleanupRoot)
        );
    case 'intelligence.start':
      return hasFlexExactKeys(valueArg, [
        'scopeId', 'sourceSessionId', 'question', 'scratchpad', 'model', 'capabilityToken',
      ])
        && isIdentifier(valueArg.scopeId)
        && isFlexIntelligenceSessionId(valueArg.sourceSessionId)
        && isBoundedString(valueArg.question, 32 * 1024)
        && valueArg.question.length <= 8_192
        && String(valueArg.question).trim().length > 0
        && isBoundedString(valueArg.scratchpad, 128 * 1024, true)
        && valueArg.scratchpad.length <= 32_768
        && isModelChoice(valueArg.model)
        && valueArg.model.modelId === 'gpt-5.6-luna'
        && valueArg.model.variant === undefined
        && isIntelligenceCapabilityToken(valueArg.capabilityToken);
    case 'intelligence.get':
      return hasFlexExactKeys(valueArg, ['scopeId', 'jobId', 'capabilityToken'])
        && isIdentifier(valueArg.scopeId)
        && isQualifiedId(valueArg.jobId)
        && isIntelligenceCapabilityToken(valueArg.capabilityToken);
    case 'intelligence.cancel':
      return hasFlexExactKeys(valueArg, ['scopeId', 'capabilityToken'])
        && isIdentifier(valueArg.scopeId)
        && isIntelligenceCapabilityToken(valueArg.capabilityToken);
    case 'session.list':
      return hasFlexExactKeys(valueArg, ['scopeId'], ['offset', 'limit'])
        && isIdentifier(valueArg.scopeId)
        && (valueArg.offset === undefined || isNonNegativeInteger(valueArg.offset))
        && (valueArg.limit === undefined
          || (Number.isSafeInteger(valueArg.limit) && Number(valueArg.limit) >= 1
            && Number(valueArg.limit) <= 50));
    case 'session.create':
      return hasFlexExactKeys(valueArg, ['scopeId', 'options'])
        && isIdentifier(valueArg.scopeId)
        && isCreateSessionOptions(valueArg.options);
    case 'session.get':
    case 'session.reversion.info':
    case 'slash.list':
    case 'prompt.list':
      return hasFlexExactKeys(valueArg, ['scopeId', 'sessionId'])
        && isScopeAndSession(valueArg);
    case 'session.delete':
      return hasFlexExactKeys(valueArg, ['scopeId', 'root', 'authorizedCohort'])
        && isIdentifier(valueArg.scopeId)
        && isFlexSessionGenerationCohortEntry(valueArg.root)
        && isStrictlyOrderedFlexCohort(
          valueArg.authorizedCohort,
          isFlexSessionGenerationCohortEntry,
        )
        && valueArg.authorizedCohort.some((entry) => (
          entry.sessionId === (valueArg.root as TFlexSessionGenerationCohortEntry).sessionId
          && entry.sessionGenerationId
            === (valueArg.root as TFlexSessionGenerationCohortEntry).sessionGenerationId
          && entry.sessionGenerationSequence
            === (valueArg.root as TFlexSessionGenerationCohortEntry).sessionGenerationSequence
        ));
    case 'session.compact':
      return hasFlexExactKeys(valueArg, ['scopeId', 'sessionId'], ['model'])
        && isScopeAndSession(valueArg)
        && (valueArg.model === undefined || isModelChoice(valueArg.model));
    case 'slash.execute':
      return hasFlexExactKeys(valueArg, ['scopeId', 'sessionId', 'input'], ['model'])
        && isScopeAndSession(valueArg)
        && isBoundedString(valueArg.input, 768 * 1024)
        && (valueArg.model === undefined || isModelChoice(valueArg.model));
    case 'session.update':
      return hasFlexExactKeys(valueArg, ['scopeId', 'sessionId', 'options'])
        && isScopeAndSession(valueArg)
        && isUpdateSessionOptions(valueArg.options);
    case 'message.page':
      return hasFlexExactKeys(valueArg, ['scopeId', 'sessionId'], ['limit', 'before'])
        && isScopeAndSession(valueArg)
        && (valueArg.limit === undefined
          || (Number.isSafeInteger(valueArg.limit) && Number(valueArg.limit) >= 1
            && Number(valueArg.limit) <= 50))
        && (valueArg.before === undefined || isBoundedString(valueArg.before, 4096));
    case 'message.get':
      return hasFlexExactKeys(valueArg, ['scopeId', 'sessionId', 'messageId'])
        && isScopeAndSession(valueArg) && isIdentifier(valueArg.messageId);
    case 'prompt.start':
      return hasFlexExactKeys(
        valueArg,
        ['scopeId', 'sessionId', 'prompt'],
        ['options', 'model', 'upload'],
      )
        && isScopeAndSession(valueArg)
        && isPrompt(valueArg.prompt)
        && (valueArg.options === undefined || isPromptOptions(valueArg.options))
        && (valueArg.model === undefined || isModelChoice(valueArg.model))
        && (valueArg.upload === undefined || (
          isFlexPlainObject(valueArg.upload)
          && hasFlexExactKeys(valueArg.upload, ['operationId', 'directory'])
          && isIdentifier(valueArg.upload.operationId)
          && isBoundedString(valueArg.upload.directory, 4096)
          && plugins.path.isAbsolute(valueArg.upload.directory)
        ));
    case 'prompt.get':
    case 'prompt.cancel':
      return hasFlexExactKeys(valueArg, ['scopeId', 'sessionId', 'queueId'])
        && isScopeAndSession(valueArg) && isIdentifier(valueArg.queueId);
    case 'prompt.acknowledge':
      return hasFlexExactKeys(valueArg, ['scopeId', 'sessionId', 'queueId', 'runId'])
        && isScopeAndSession(valueArg)
        && isIdentifier(valueArg.queueId)
        && isIdentifier(valueArg.runId);
    case 'permission.list':
      return hasFlexExactKeys(valueArg, ['scopeId'], ['sessionId'])
        && isIdentifier(valueArg.scopeId)
        && (valueArg.sessionId === undefined || isIdentifier(valueArg.sessionId));
    case 'permission.respond':
      return hasFlexExactKeys(
        valueArg,
        [
          'scopeId', 'sessionId', 'sessionGenerationId', 'sessionGenerationSequence',
          'permissionId', 'decision',
        ],
      )
        && isScopeAndSession(valueArg)
        && isFlexSessionGeneration(valueArg)
        && isIdentifier(valueArg.permissionId)
        && ['once', 'always', 'reject'].includes(String(valueArg.decision));
    case 'provider.login.begin':
      return hasFlexExactKeys(valueArg, ['providerId']) && valueArg.providerId === 'openai';
    case 'provider.login.status':
    case 'provider.login.cancel':
      return hasFlexExactKeys(valueArg, ['loginId']) && isQualifiedId(valueArg.loginId);
    case 'provider.connection.logout.prepare':
    case 'provider.connection.logout':
    case 'provider.connection.opencode-auth.get':
    case 'provider.connection.ratelimits.get':
    case 'provider.models.refresh':
      return hasFlexExactKeys(valueArg, ['providerConnectionId'])
        && isQualifiedId(valueArg.providerConnectionId);
    case 'model.choice.get':
      return hasFlexExactKeys(valueArg, ['scopeId']) && isIdentifier(valueArg.scopeId);
    case 'model.choice.set':
      return hasFlexExactKeys(valueArg, ['scopeId', 'choice'])
        && isIdentifier(valueArg.scopeId) && isModelChoice(valueArg.choice);
    case 'model.choice.validate':
      return hasFlexExactKeys(valueArg, ['choice']) && isModelChoice(valueArg.choice);
    default:
      return false;
  }
};

export const isFlexHostRequestPayload = <TMethod extends TFlexHostRequestMethod>(
  methodArg: TMethod,
  valueArg: unknown,
): valueArg is TFlexHostRequest<TMethod> => {
  if (!isFlexPlainObject(valueArg)) return false;
  if (methodArg === 'delegated-run-admission.acquire') {
    return isFlexDelegatedRunAdmissionContext(valueArg);
  }
  if (methodArg === 'delegated-run-admission.close') {
    return isFlexDelegatedRunAdmissionContext(valueArg, ['leaseId']);
  }
  const reversionBase = (optionalKeysArg: readonly string[] = []) => (
    hasFlexExactKeys(
      valueArg,
      [
        'scopeId', 'storageKey', 'sessionId',
        'sessionGenerationId', 'sessionGenerationSequence',
        'runId', 'captureId',
      ],
      optionalKeysArg,
    )
    && isIdentifier(valueArg.scopeId)
    && isIdentifier(valueArg.storageKey)
    && isIdentifier(valueArg.sessionId)
    && isFlexSessionGeneration(valueArg)
    && isIdentifier(valueArg.runId)
    && isIdentifier(valueArg.captureId)
  );
  if (
    methodArg === 'reversion.prepare'
    || methodArg === 'reversion.inspect-capture'
    || methodArg === 'reversion.finalize'
  ) return reversionBase();
  if (methodArg === 'reversion.inspect-apply' || methodArg === 'reversion.apply') {
    return reversionBase(['reference', 'operationId', 'direction'])
      && Object.hasOwn(valueArg, 'reference')
      && isJsonValue(valueArg.reference)
      && Buffer.byteLength(JSON.stringify(valueArg.reference), 'utf8') <= 256 * 1024
      && isIdentifier(valueArg.operationId)
      && (valueArg.direction === 'undo' || valueArg.direction === 'redo');
  }
  if (methodArg === 'reversion.release') {
    return reversionBase(['reference'])
      && Object.hasOwn(valueArg, 'reference')
      && isJsonValue(valueArg.reference)
      && Buffer.byteLength(JSON.stringify(valueArg.reference), 'utf8') <= 256 * 1024;
  }
  if (methodArg === 'git.worktree.create' || methodArg === 'git.worktree.list') {
    return hasFlexExactKeys(valueArg, [
      'scopeId', 'sessionId', 'sessionGenerationId', 'sessionGenerationSequence',
    ])
      && isIdentifier(valueArg.scopeId)
      && isIdentifier(valueArg.sessionId)
      && isFlexSessionGeneration(valueArg);
  }
  if (methodArg === 'git.worktree.remove') {
    const compensating = Object.hasOwn(valueArg, 'compensate');
    return hasFlexExactKeys(
      valueArg,
      [
        'scopeId', 'sessionId', 'sessionGenerationId', 'sessionGenerationSequence',
        'worktreeId', ...(compensating ? ['compensate'] : []),
      ],
    )
      && isIdentifier(valueArg.scopeId)
      && isIdentifier(valueArg.sessionId)
      && isFlexSessionGeneration(valueArg)
      && isIdentifier(valueArg.worktreeId)
      && (!compensating || valueArg.compensate === true);
  }
  if (methodArg === 'crossharness.chats.list') {
    return hasFlexExactKeys(valueArg, ['capabilityToken', 'limit'])
      && isIntelligenceCapabilityToken(valueArg.capabilityToken)
      && Number.isSafeInteger(valueArg.limit)
      && Number(valueArg.limit) >= 1
      && Number(valueArg.limit) <= 50;
  }
  if (methodArg === 'crossharness.chat.read') {
    return hasFlexExactKeys(
      valueArg,
      ['capabilityToken', 'sessionId', 'limit', 'maxChars'],
    )
      && isIntelligenceCapabilityToken(valueArg.capabilityToken)
      && isFlexIntelligenceSessionId(valueArg.sessionId)
      && Number.isSafeInteger(valueArg.limit)
      && Number(valueArg.limit) >= 1
      && Number(valueArg.limit) <= 50
      && Number.isSafeInteger(valueArg.maxChars)
      && Number(valueArg.maxChars) >= 128
      && Number(valueArg.maxChars) <= 4096;
  }
  if (methodArg === 'project-management.load') {
    return hasFlexExactKeys(
      valueArg,
      ['storageKey', 'sessionId', 'sessionContext'],
      ['registrationOperationId'],
    )
      && isIdentifier(valueArg.storageKey)
      && isIdentifier(valueArg.sessionId)
      && isFlexProjectManagementSessionContext(valueArg.sessionContext)
      && (
        valueArg.registrationOperationId === undefined
        || (
          typeof valueArg.registrationOperationId === 'string'
          && operationIdPattern.test(valueArg.registrationOperationId)
        )
      );
  }
  if (methodArg === 'project-management.save') {
    return hasFlexExactKeys(valueArg, [
      'storageKey',
      'sessionId',
      'snapshot',
      'expectedRevision',
      'writeContext',
    ])
      && isIdentifier(valueArg.storageKey)
      && isIdentifier(valueArg.sessionId)
      && isFlexProjectManagementSnapshot(valueArg.snapshot)
      && isNonNegativeInteger(valueArg.expectedRevision)
      && valueArg.snapshot.revision === Number(valueArg.expectedRevision) + 1
      && isFlexProjectManagementWriteContext(valueArg.writeContext);
  }
  if (methodArg === 'project-management.tombstone') {
    return hasFlexExactKeys(valueArg, [
      'storageKey',
      'sessionId',
      'tombstone',
      'expectedRevision',
      'sessionContext',
    ])
      && isIdentifier(valueArg.storageKey)
      && isIdentifier(valueArg.sessionId)
      && isFlexProjectManagementTombstone(valueArg.tombstone)
      && isNonNegativeInteger(valueArg.expectedRevision)
      && valueArg.tombstone.revision === Number(valueArg.expectedRevision) + 1
      && isFlexProjectManagementSessionContext(valueArg.sessionContext)
      && valueArg.sessionContext.sessionGenerationId
        === valueArg.tombstone.sessionGenerationId
      && valueArg.sessionContext.sessionGenerationSequence
        === valueArg.tombstone.sessionGenerationSequence;
  }
  if (methodArg === 'browser.channel.close') {
    return hasFlexExactKeys(valueArg, [
      'channelId', 'sessionGenerationId', 'sessionGenerationSequence',
    ])
      && isChannelId(valueArg.channelId)
      && isFlexSessionGeneration(valueArg);
  }
  const common = hasFlexExactKeys(
    valueArg,
    methodArg === 'browser.resources.resolve'
      ? [
          'scopeId', 'sessionId', 'sessionGenerationId', 'sessionGenerationSequence', 'runId',
        ]
      : [
          'scopeId', 'sessionId', 'sessionGenerationId', 'sessionGenerationSequence', 'runId',
          'resourceId', 'attachmentRevision', 'channelId',
        ],
  )
    && isBoundedString(valueArg.scopeId, 128)
    && identifierPattern.test(String(valueArg.scopeId))
    && isBoundedString(valueArg.sessionId, 128)
    && identifierPattern.test(String(valueArg.sessionId))
    && isFlexSessionGeneration(valueArg)
    && isBoundedString(valueArg.runId, 512)
    && identifierPattern.test(String(valueArg.runId));
  if (!common || methodArg === 'browser.resources.resolve') return common;
  return isBoundedString(valueArg.resourceId, 256)
    && Buffer.byteLength(String(valueArg.resourceId), 'utf8') >= 16
    && identifierPattern.test(String(valueArg.resourceId))
    && isNonNegativeInteger(valueArg.attachmentRevision)
    && isChannelId(valueArg.channelId);
};

const isGitWorktreeDescriptor = (
  valueArg: unknown,
): valueArg is IFlexGitWorktreeDescriptor => isFlexPlainObject(valueArg)
  && hasFlexExactKeys(valueArg, [
    'worktreeId', 'projectId', 'sessionId', 'path', 'repositoryId', 'createdAt',
  ])
  && isIdentifier(valueArg.worktreeId)
  && typeof valueArg.projectId === 'string'
  && projectIdPattern.test(valueArg.projectId)
  && isIdentifier(valueArg.sessionId)
  && isBoundedString(valueArg.path, 4096)
  && !valueArg.path.includes('\0')
  && plugins.path.isAbsolute(valueArg.path)
  && plugins.path.normalize(valueArg.path) === valueArg.path
  && isIdentifier(valueArg.repositoryId)
  && isIsoDate(valueArg.createdAt);

const isFlexBrowserResourceDescriptor = (
  valueArg: unknown,
): valueArg is IFlexBrowserResourceDescriptor => isFlexPlainObject(valueArg)
  && hasFlexExactKeys(valueArg, ['resourceId', 'attachmentRevision'])
  && isBoundedString(valueArg.resourceId, 256)
  && Buffer.byteLength(valueArg.resourceId, 'utf8') >= 16
  && identifierPattern.test(valueArg.resourceId)
  && isNonNegativeInteger(valueArg.attachmentRevision);

const isFlexBrowserChannelBinding = (
  valueArg: unknown,
): valueArg is TFlexGenerationBoundBrowserChannelBinding => isFlexPlainObject(valueArg)
  && hasFlexExactKeys(valueArg, [
    'projectId',
    'browserResourceId',
    'attachmentAuthorityId',
    'attachmentRevision',
    'actorId',
    'peerId',
    'role',
    'source',
    'scopeId',
    'channelId',
    'runId',
    'sessionId',
    'sessionGenerationId',
    'sessionGenerationSequence',
  ])
  && isBoundedString(valueArg.projectId, 128)
  && isBoundedString(valueArg.browserResourceId, 256)
  && Buffer.byteLength(valueArg.browserResourceId, 'utf8') >= 16
  && isBoundedString(valueArg.attachmentAuthorityId, 256)
  && isNonNegativeInteger(valueArg.attachmentRevision)
  && isBoundedString(valueArg.actorId, 256)
  && isBoundedString(valueArg.peerId, 256)
  && valueArg.role === 'agent'
  && valueArg.source === 'flex'
  && isBoundedString(valueArg.scopeId, 128)
  && isChannelId(valueArg.channelId)
  && isBoundedString(valueArg.runId, 512)
  && identifierPattern.test(valueArg.runId)
  && isFlexPlainObject(valueArg.sessionId)
  && hasFlexExactKeys(valueArg.sessionId, ['harnessId', 'nativeId'])
  && valueArg.sessionId.harnessId === 'flex'
  && isBoundedString(valueArg.sessionId.nativeId, 128)
  && isFlexSessionGeneration(valueArg);

export const isFlexHostResponseResult = <TMethod extends TFlexHostRequestMethod>(
  methodArg: TMethod,
  valueArg: unknown,
): valueArg is TFlexHostResponse<TMethod> => {
  if (!isFlexPlainObject(valueArg)) return false;
  if (methodArg === 'delegated-run-admission.acquire') {
    return hasFlexExactKeys(valueArg, ['leaseId', 'model'])
      && isFlexDelegatedRunAdmissionLeaseId(valueArg.leaseId)
      && isModelChoice(valueArg.model);
  }
  if (methodArg === 'delegated-run-admission.close') {
    return hasFlexExactKeys(valueArg, ['closed']) && valueArg.closed === true;
  }
  if (methodArg === 'reversion.prepare') {
    return hasFlexExactKeys(valueArg, ['prepared']) && valueArg.prepared === true;
  }
  if (methodArg === 'reversion.inspect-capture') {
    if (valueArg.status === 'finalized') {
      return hasFlexExactKeys(valueArg, ['status', 'outcome'])
        && isReversionOutcome(valueArg.outcome);
    }
    return hasFlexExactKeys(valueArg, ['status'])
      && ['missing', 'prepared', 'unknown'].includes(String(valueArg.status));
  }
  if (methodArg === 'reversion.finalize') return isReversionOutcome(valueArg);
  if (methodArg === 'reversion.inspect-apply') {
    return hasFlexExactKeys(valueArg, ['status'])
      && ['not-applied', 'applied', 'unknown'].includes(String(valueArg.status));
  }
  if (methodArg === 'reversion.apply') {
    return hasFlexExactKeys(valueArg, ['applied']) && valueArg.applied === true;
  }
  if (methodArg === 'reversion.release') {
    return hasFlexExactKeys(valueArg, ['released']) && valueArg.released === true;
  }
  if (methodArg === 'git.worktree.create') {
    return hasFlexExactKeys(valueArg, ['worktree'])
      && isGitWorktreeDescriptor(valueArg.worktree);
  }
  if (methodArg === 'git.worktree.list') {
    return hasFlexExactKeys(valueArg, ['worktrees'])
      && Array.isArray(valueArg.worktrees)
      && valueArg.worktrees.length <= 128
      && valueArg.worktrees.every(isGitWorktreeDescriptor);
  }
  if (methodArg === 'git.worktree.remove') {
    return hasFlexExactKeys(valueArg, ['removed']) && valueArg.removed === true;
  }
  if (methodArg === 'crossharness.chats.list') {
    return hasFlexExactKeys(valueArg, ['chats'])
      && Array.isArray(valueArg.chats)
      && valueArg.chats.length <= 50
      && valueArg.chats.every(isFlexIntelligenceChatSummary)
      && Buffer.byteLength(JSON.stringify(valueArg), 'utf8') <= 256 * 1024;
  }
  if (methodArg === 'crossharness.chat.read') {
    return hasFlexExactKeys(valueArg, ['transcript'])
      && isFlexIntelligenceChatTranscript(valueArg.transcript);
  }
  if (methodArg === 'project-management.load') {
    return hasFlexExactKeys(valueArg, ['record'])
      && (valueArg.record === null || isFlexProjectManagementRecord(valueArg.record));
  }
  if (
    methodArg === 'project-management.save'
    || methodArg === 'project-management.tombstone'
  ) return isFlexProjectManagementCommitResult(valueArg);
  if (methodArg === 'browser.resources.resolve') {
    return hasFlexExactKeys(valueArg, ['resources'])
      && Array.isArray(valueArg.resources)
      && valueArg.resources.length <= flexIpcMaximumBrowserChannels
      && valueArg.resources.every(isFlexBrowserResourceDescriptor)
      && new Set(valueArg.resources.map((entry) => entry.resourceId)).size
        === valueArg.resources.length;
  }
  if (methodArg === 'browser.channel.open') {
    return hasFlexExactKeys(valueArg, ['binding', 'capabilityToken'])
      && isFlexBrowserChannelBinding(valueArg.binding)
      && isBoundedString(valueArg.capabilityToken, 512)
      && Buffer.byteLength(valueArg.capabilityToken, 'utf8') >= 16;
  }
  return hasFlexExactKeys(valueArg, ['closed']) && valueArg.closed === true;
};

const isPublicProviderModel = (valueArg: unknown): valueArg is IFlexPublicProviderModel => {
  if (
    !isFlexPlainObject(valueArg)
    || !hasFlexExactKeys(
      valueArg,
      [
        'providerId', 'modelId', 'displayName', 'description', 'hidden',
        'reasoningEfforts', 'defaultReasoningEffort', 'inputModalities',
        'supportsPersonality', 'serviceTiers', 'isDefault',
      ],
      ['defaultServiceTier'],
    )
    || valueArg.providerId !== 'openai'
    || !isBoundedString(valueArg.modelId, 256)
    || !isBoundedString(valueArg.displayName, 512)
    || !isBoundedString(valueArg.description, 2048, true)
    || typeof valueArg.hidden !== 'boolean'
    || !Array.isArray(valueArg.reasoningEfforts)
    || valueArg.reasoningEfforts.length > 16
    || !valueArg.reasoningEfforts.every((entry) => isFlexPlainObject(entry)
      && hasFlexExactKeys(entry, ['effort', 'description'])
      && isBoundedString(entry.effort, 128)
      && isBoundedString(entry.description, 1024, true))
    || !isBoundedString(valueArg.defaultReasoningEffort, 128)
    || !Array.isArray(valueArg.inputModalities)
    || valueArg.inputModalities.length > 3
    || !valueArg.inputModalities.every((entry) => ['text', 'image', 'audio'].includes(String(entry)))
    || typeof valueArg.supportsPersonality !== 'boolean'
    || !Array.isArray(valueArg.serviceTiers)
    || valueArg.serviceTiers.length > 16
    || !valueArg.serviceTiers.every((entry) => isFlexPlainObject(entry)
      && hasFlexExactKeys(entry, ['id', 'name', 'description'])
      && isBoundedString(entry.id, 128)
      && isBoundedString(entry.name, 256)
      && isBoundedString(entry.description, 1024, true))
    || (valueArg.defaultServiceTier !== undefined
      && !isBoundedString(valueArg.defaultServiceTier, 128))
    || typeof valueArg.isDefault !== 'boolean'
  ) return false;
  return true;
};

const isRateLimitWindow = (valueArg: unknown): valueArg is IFlexPublicProviderRateLimitWindow => (
  isFlexPlainObject(valueArg)
  && hasFlexExactKeys(valueArg, [
    'usedPercent', 'limitWindowSeconds', 'resetAfterSeconds', 'resetsAt',
  ])
  && isNonNegativeInteger(valueArg.usedPercent)
  && valueArg.usedPercent <= 100
  && isNonNegativeInteger(valueArg.limitWindowSeconds)
  && valueArg.limitWindowSeconds >= 1
  && isNonNegativeInteger(valueArg.resetAfterSeconds)
  && isNonNegativeInteger(valueArg.resetsAt)
);

const isRateLimitDetails = (valueArg: unknown): valueArg is IFlexPublicProviderRateLimitDetails => (
  isFlexPlainObject(valueArg)
  && hasFlexExactKeys(valueArg, ['allowed', 'limitReached'], ['primaryWindow', 'secondaryWindow'])
  && typeof valueArg.allowed === 'boolean'
  && typeof valueArg.limitReached === 'boolean'
  && (valueArg.primaryWindow === undefined || isRateLimitWindow(valueArg.primaryWindow))
  && (valueArg.secondaryWindow === undefined || isRateLimitWindow(valueArg.secondaryWindow))
);

const isAccountRateLimits = (
  valueArg: unknown,
): valueArg is IFlexPublicProviderAccountRateLimits => isFlexPlainObject(valueArg)
  && hasFlexExactKeys(
    valueArg,
    ['providerId', 'plan', 'observedAt', 'additionalRateLimits'],
    ['rateLimit', 'rateLimitReachedType', 'rateLimitResetCreditsAvailableCount'],
  )
  && valueArg.providerId === 'openai'
  && isBoundedString(valueArg.plan, 256)
  && isIsoDate(valueArg.observedAt)
  && (valueArg.rateLimit === undefined || isRateLimitDetails(valueArg.rateLimit))
  && Array.isArray(valueArg.additionalRateLimits)
  && valueArg.additionalRateLimits.length <= 64
  && valueArg.additionalRateLimits.every((entry) => isFlexPlainObject(entry)
    && hasFlexExactKeys(entry, ['limitName', 'meteredFeature'], ['rateLimit'])
    && isBoundedString(entry.limitName, 256)
    && isBoundedString(entry.meteredFeature, 256)
    && (entry.rateLimit === undefined || isRateLimitDetails(entry.rateLimit)))
  && (valueArg.rateLimitReachedType === undefined
    || isBoundedString(valueArg.rateLimitReachedType, 256))
  && (valueArg.rateLimitResetCreditsAvailableCount === undefined
    || isNonNegativeInteger(valueArg.rateLimitResetCreditsAvailableCount));

export const isFlexResponseResult = <TMethod extends TFlexRequestMethod>(
  methodArg: TMethod,
  valueArg: unknown,
): valueArg is TFlexResponse<TMethod> => {
  switch (methodArg) {
    case 'service.status':
      return isFlexServiceStatus(valueArg);
    case 'project.register':
      return isFlexPlainObject(valueArg)
        && hasFlexExactKeys(valueArg, ['registered', 'added'])
        && valueArg.registered === true
        && typeof valueArg.added === 'boolean';
    case 'project.remove':
      return isFlexPlainObject(valueArg)
        && hasFlexExactKeys(valueArg, ['removed'])
        && valueArg.removed === true;
    case 'intelligence.start':
      return isFlexPlainObject(valueArg)
        && hasFlexExactKeys(valueArg, ['jobId', 'workerSessionId'])
        && isQualifiedId(valueArg.jobId)
        && isIdentifier(valueArg.workerSessionId);
    case 'intelligence.get':
      if (
        !isFlexPlainObject(valueArg)
        || !hasFlexExactKeys(
          valueArg,
          ['status', 'workerSessionId'],
          ['result', 'error'],
        )
        || !['running', 'completed', 'failed', 'cancelled'].includes(String(valueArg.status))
        || !isIdentifier(valueArg.workerSessionId)
        || (valueArg.result !== undefined && !isFlexIntelligenceResult(valueArg.result))
        || (valueArg.error !== undefined && valueArg.error !== 'Session Intelligence failed.')
      ) return false;
      return (valueArg.status === 'completed' && valueArg.result !== undefined
          && valueArg.error === undefined)
        || (valueArg.status === 'failed' && valueArg.result === undefined
          && valueArg.error === 'Session Intelligence failed.')
        || (valueArg.status === 'cancelled' && valueArg.result === undefined
          && valueArg.error === undefined)
        || (valueArg.status === 'running' && valueArg.result === undefined
          && valueArg.error === undefined);
    case 'intelligence.cancel':
      return isFlexPlainObject(valueArg)
        && hasFlexExactKeys(valueArg, ['cancelled'])
        && typeof valueArg.cancelled === 'boolean';
    case 'session.list':
      return isFlexPlainObject(valueArg)
        && hasFlexExactKeys(valueArg, ['sessions', 'total', 'truncated'])
        && Array.isArray(valueArg.sessions) && valueArg.sessions.length <= 50
        && valueArg.sessions.every(isFlexPublicSession)
        && isNonNegativeInteger(valueArg.total)
        && typeof valueArg.truncated === 'boolean';
    case 'session.create':
    case 'session.get':
    case 'session.update':
      return isFlexPublicSession(valueArg);
    case 'session.delete':
      return isFlexPlainObject(valueArg) && hasFlexExactKeys(valueArg, ['matched'])
        && typeof valueArg.matched === 'boolean';
    case 'session.compact':
      return isFlexPlainObject(valueArg) && hasFlexExactKeys(valueArg, ['compacted'])
        && valueArg.compacted === true;
    case 'session.reversion.info':
      return isSessionReversionInfo(valueArg);
    case 'slash.list':
      return isFlexPlainObject(valueArg)
        && hasFlexExactKeys(valueArg, ['commands'])
        && Array.isArray(valueArg.commands)
        && valueArg.commands.length <= 132
        && valueArg.commands.every(isSlashDescriptor);
    case 'slash.execute':
      return isSlashExecutionResult(valueArg);
    case 'message.page':
      return isFlexPlainObject(valueArg)
        && hasFlexExactKeys(valueArg, ['messages'], ['nextCursor'])
        && Array.isArray(valueArg.messages) && valueArg.messages.length <= 50
        && valueArg.messages.every(isFlexPublicMessage)
        && (valueArg.nextCursor === undefined || isBoundedString(valueArg.nextCursor, 4096));
    case 'message.get':
      return isFlexPublicMessage(valueArg);
    case 'prompt.start':
      return isFlexPlainObject(valueArg)
        && hasFlexExactKeys(valueArg, ['queueId', 'runId'])
        && isIdentifier(valueArg.queueId)
        && isIdentifier(valueArg.runId);
    case 'prompt.acknowledge':
      return isFlexPlainObject(valueArg)
        && hasFlexExactKeys(valueArg, ['acknowledged'])
        && valueArg.acknowledged === true;
    case 'prompt.get':
      return isFlexPlainObject(valueArg)
        && hasFlexExactKeys(valueArg, ['entry'])
        && isPromptQueueEntry(valueArg.entry);
    case 'prompt.list':
      return isFlexPlainObject(valueArg)
        && hasFlexExactKeys(valueArg, ['entries'])
        && Array.isArray(valueArg.entries)
        && valueArg.entries.length <= flexIpcMaximumPromptQueueEntries
        && valueArg.entries.every(isPromptQueueEntry);
    case 'prompt.cancel':
      return isFlexPlainObject(valueArg) && hasFlexExactKeys(valueArg, ['accepted'])
        && typeof valueArg.accepted === 'boolean';
    case 'permission.list':
      return isFlexPlainObject(valueArg) && hasFlexExactKeys(valueArg, ['permissions'])
        && Array.isArray(valueArg.permissions) && valueArg.permissions.length <= 64
        && valueArg.permissions.every(isPermissionRequest);
    case 'permission.respond':
    case 'provider.connection.logout.prepare':
    case 'provider.connection.logout':
      return isFlexPlainObject(valueArg) && hasFlexExactKeys(valueArg, ['accepted'])
        && valueArg.accepted === true;
    case 'provider.connection.ratelimits.get':
      return isFlexPlainObject(valueArg)
        && hasFlexExactKeys(valueArg, ['rateLimits'])
        && isAccountRateLimits(valueArg.rateLimits);
    case 'provider.list':
      return isFlexPlainObject(valueArg) && hasFlexExactKeys(valueArg, ['providers'])
        && Array.isArray(valueArg.providers) && valueArg.providers.length === 1
        && isFlexPlainObject(valueArg.providers[0])
        && hasFlexExactKeys(valueArg.providers[0], ['providerId', 'displayName', 'loginFlow'])
        && valueArg.providers[0].providerId === 'openai'
        && isBoundedString(valueArg.providers[0].displayName, 256)
        && valueArg.providers[0].loginFlow === 'device';
    case 'provider.login.begin':
      return isFlexPlainObject(valueArg)
        && hasFlexExactKeys(
          valueArg,
          ['loginId', 'verificationUrl', 'userCode', 'status'],
        )
        && isQualifiedId(valueArg.loginId)
        && isBoundedString(valueArg.verificationUrl, 4096)
        && isBoundedString(valueArg.userCode, 256)
        && valueArg.status === 'pending';
    case 'provider.login.status':
      return isFlexPublicProviderConnection(valueArg);
    case 'provider.login.cancel':
      return isFlexPlainObject(valueArg) && hasFlexExactKeys(valueArg, ['canceled'])
        && typeof valueArg.canceled === 'boolean';
    case 'provider.connection.list':
      return isFlexPlainObject(valueArg) && hasFlexExactKeys(valueArg, ['connections'])
        && Array.isArray(valueArg.connections) && valueArg.connections.length <= 512
        && valueArg.connections.every(isFlexPublicProviderConnection);
    case 'provider.connection.opencode-auth.get':
      return isFlexPlainObject(valueArg) && hasFlexExactKeys(valueArg, ['auth'])
        && isOpenCodeOAuthAuth(valueArg.auth);
    case 'provider.models.refresh':
      return isFlexPlainObject(valueArg) && hasFlexExactKeys(valueArg, ['jobId'])
        && isQualifiedId(valueArg.jobId);
    case 'model.choice.get':
      return isFlexPlainObject(valueArg) && hasFlexExactKeys(valueArg, ['choice'])
        && (valueArg.choice === null || isModelChoice(valueArg.choice));
    case 'model.choice.set':
      return isFlexPlainObject(valueArg) && hasFlexExactKeys(valueArg, ['choice'])
        && isModelChoice(valueArg.choice);
    case 'model.choice.validate':
      return isFlexPlainObject(valueArg)
        && hasFlexExactKeys(valueArg, ['valid'])
        && valueArg.valid === true;
    default:
      return false;
  }
};

export const isFlexServiceError = (valueArg: unknown): valueArg is IFlexServiceError =>
  isFlexPlainObject(valueArg)
  && hasFlexExactKeys(valueArg, ['name', 'code', 'message'])
  && valueArg.name === 'FlexServiceError'
  && typeof valueArg.code === 'string'
  && serviceErrorCodes.has(valueArg.code)
  && valueArg.message === flexServiceErrorMessages[valueArg.code as TFlexServiceErrorCode];

const isFlexChildEvent = (valueArg: unknown): valueArg is TFlexChildEvent => {
  if (!isFlexPlainObject(valueArg)) return false;
  switch (valueArg.type) {
    case 'session.history.changed':
      return hasFlexExactKeys(
        valueArg,
        [
          'type', 'scopeId', 'sessionId',
          'sessionGenerationId', 'sessionGenerationSequence', 'direction',
        ],
        ['runId'],
      )
        && isIdentifier(valueArg.scopeId)
        && isIdentifier(valueArg.sessionId)
        && isFlexSessionGeneration(valueArg)
        && ['undo', 'redo', 'branch'].includes(String(valueArg.direction))
        && (valueArg.runId === undefined || isIdentifier(valueArg.runId))
        && (valueArg.direction === 'branch'
          ? valueArg.runId === undefined
          : valueArg.runId !== undefined);
    case 'sessions.changed':
      return (
        hasFlexExactKeys(valueArg, ['type', 'coalesced'])
        && valueArg.coalesced === true
      ) || (
        hasFlexExactKeys(valueArg, [
          'type', 'scopeId', 'sessionId',
          'sessionGenerationId', 'sessionGenerationSequence', 'coalesced',
        ])
        && isIdentifier(valueArg.scopeId)
        && isIdentifier(valueArg.sessionId)
        && isFlexSessionGeneration(valueArg)
        && typeof valueArg.coalesced === 'boolean'
      );
    case 'permissions.changed':
      return hasFlexExactKeys(valueArg, [
        'type', 'scopeId', 'sessionId', 'sessionGenerationId', 'sessionGenerationSequence',
      ])
        && isIdentifier(valueArg.scopeId)
        && isIdentifier(valueArg.sessionId)
        && isFlexSessionGeneration(valueArg);
    case 'tool.updated':
      return hasFlexExactKeys(valueArg, [
        'type', 'scopeId', 'sessionId', 'sessionGenerationId', 'sessionGenerationSequence',
        'runId', 'messageId',
        'messageIndex', 'partIndex', 'sequence', 'timestamp', 'part',
      ])
        && isIdentifier(valueArg.scopeId)
        && isIdentifier(valueArg.sessionId)
        && isFlexSessionGeneration(valueArg)
        && isIdentifier(valueArg.runId)
        && isIdentifier(valueArg.messageId)
        && isNonNegativeInteger(valueArg.messageIndex)
        && isNonNegativeInteger(valueArg.partIndex)
        && isNonNegativeInteger(valueArg.sequence)
        && valueArg.sequence >= 1
        && isIsoDate(valueArg.timestamp)
        && isFlexPlainObject(valueArg.part)
         && valueArg.part.type === 'tool'
         && isMessagePart(valueArg.part);
    case 'reasoning.updated':
      return hasFlexExactKeys(valueArg, [
        'type', 'scopeId', 'sessionId', 'sessionGenerationId', 'sessionGenerationSequence',
        'runId', 'messageId',
        'messageIndex', 'partIndex', 'sequence', 'timestamp', 'part',
      ])
        && isIdentifier(valueArg.scopeId)
        && isIdentifier(valueArg.sessionId)
        && isFlexSessionGeneration(valueArg)
        && isIdentifier(valueArg.runId)
        && isIdentifier(valueArg.messageId)
        && isNonNegativeInteger(valueArg.messageIndex)
        && isNonNegativeInteger(valueArg.partIndex)
        && isNonNegativeInteger(valueArg.sequence)
        && valueArg.sequence >= 1
        && isIsoDate(valueArg.timestamp)
        && isFlexPlainObject(valueArg.part)
        && valueArg.part.type === 'reasoning'
        && isMessagePart(valueArg.part, flexIpcMaximumFrameBytes - (16 * 1024));
    case 'text.updated':
      return hasFlexExactKeys(valueArg, [
        'type', 'scopeId', 'sessionId', 'sessionGenerationId', 'sessionGenerationSequence',
        'runId', 'messageId',
        'messageIndex', 'partIndex', 'sequence', 'timestamp', 'status', 'part',
      ])
        && isIdentifier(valueArg.scopeId)
        && isIdentifier(valueArg.sessionId)
        && isFlexSessionGeneration(valueArg)
        && isIdentifier(valueArg.runId)
        && isIdentifier(valueArg.messageId)
        && isNonNegativeInteger(valueArg.messageIndex)
        && isNonNegativeInteger(valueArg.partIndex)
        && isNonNegativeInteger(valueArg.sequence)
        && valueArg.sequence >= 1
        && isIsoDate(valueArg.timestamp)
        && ['running', 'completed'].includes(String(valueArg.status))
        && isFlexPlainObject(valueArg.part)
        && valueArg.part.type === 'text'
        && isMessagePart(valueArg.part, flexIpcMaximumFrameBytes - (16 * 1024));
    case 'part.delta':
      return hasFlexExactKeys(valueArg, [
        'type', 'scopeId', 'sessionId', 'sessionGenerationId', 'sessionGenerationSequence',
        'runId', 'messageId', 'messageIndex', 'partId',
        'partIndex', 'sequence', 'timestamp', 'partType', 'delta',
        'baseTextUtf8Bytes', 'textUtf8Bytes',
      ])
        && isIdentifier(valueArg.scopeId)
        && isIdentifier(valueArg.sessionId)
        && isFlexSessionGeneration(valueArg)
        && isIdentifier(valueArg.runId)
        && isIdentifier(valueArg.messageId)
        && isIdentifier(valueArg.partId)
        && isNonNegativeInteger(valueArg.messageIndex)
        && isNonNegativeInteger(valueArg.partIndex)
        && isNonNegativeInteger(valueArg.sequence)
        && valueArg.sequence >= 1
        && isIsoDate(valueArg.timestamp)
        && (valueArg.partType === 'text' || valueArg.partType === 'reasoning')
        && isBoundedString(valueArg.delta, flexIpcMaximumDeltaBytes)
        && isNonNegativeInteger(valueArg.baseTextUtf8Bytes)
        && isNonNegativeInteger(valueArg.textUtf8Bytes)
        && valueArg.textUtf8Bytes > valueArg.baseTextUtf8Bytes
        && hasExactDeltaUtf8Coordinates(
          valueArg.delta,
          valueArg.baseTextUtf8Bytes,
          valueArg.textUtf8Bytes,
        );
    case 'prompt.queued':
    case 'prompt.started':
    case 'prompt.running':
    case 'prompt.finished':
      return hasFlexExactKeys(
        valueArg,
        [
          'type', 'scopeId', 'sessionId', 'sessionGenerationId',
          'sessionGenerationSequence', 'queueId', 'entry',
        ],
        ['runId'],
      )
        && isIdentifier(valueArg.scopeId)
        && isIdentifier(valueArg.sessionId)
        && isFlexSessionGeneration(valueArg)
        && isIdentifier(valueArg.queueId)
        && (valueArg.runId === undefined || isIdentifier(valueArg.runId))
        && isPromptQueueEntry(valueArg.entry)
        && valueArg.entry.scopeId === valueArg.scopeId
        && valueArg.entry.sessionId === valueArg.sessionId
        && valueArg.entry.queueId === valueArg.queueId
        && valueArg.entry.runId === valueArg.runId
        && (
          (valueArg.type === 'prompt.queued'
            && valueArg.runId === undefined
            && valueArg.entry.status === 'queued')
          || (valueArg.type === 'prompt.started'
            && valueArg.runId !== undefined
            && ['starting', 'scheduled'].includes(valueArg.entry.status))
          || (valueArg.type === 'prompt.running'
            && valueArg.runId !== undefined
            && valueArg.entry.status === 'running')
          || (valueArg.type === 'prompt.finished'
            && valueArg.runId !== undefined
            && ['completed', 'failed', 'cancelled'].includes(valueArg.entry.status))
        );
    case 'prompt.message-bound':
      return hasFlexExactKeys(valueArg, [
        'type', 'scopeId', 'sessionId', 'sessionGenerationId', 'sessionGenerationSequence',
        'queueId', 'runId', 'messageId',
      ])
        && isIdentifier(valueArg.scopeId)
        && isIdentifier(valueArg.sessionId)
        && isFlexSessionGeneration(valueArg)
        && isIdentifier(valueArg.queueId)
        && isIdentifier(valueArg.runId)
        && isIdentifier(valueArg.messageId);
    case 'job.finished':
      return hasFlexExactKeys(
        valueArg,
        ['type', 'jobId', 'kind', 'status'],
        ['models'],
      )
        && isQualifiedId(valueArg.jobId)
        && valueArg.kind === 'provider.models'
        && ['completed', 'failed', 'cancelled'].includes(String(valueArg.status))
        && (valueArg.models === undefined || (
          valueArg.status === 'completed'
          && Array.isArray(valueArg.models)
          && valueArg.models.length <= 256
          && valueArg.models.every(isPublicProviderModel)
        ));
    case 'provider.connection.changed':
      return hasFlexExactKeys(valueArg, ['type', 'connection'])
        && isFlexPublicProviderConnection(valueArg.connection);
    default:
      return false;
  }
};

export const parseFlexParentMessage = (valueArg: unknown): TFlexParentMessage => {
  if (
    !isFlexPlainObject(valueArg)
    || valueArg.version !== flexIpcProtocolVersion
    || typeof valueArg.type !== 'string'
  ) throw new Error('Invalid Flex parent message.');
  if (valueArg.type === 'init') {
    if (!hasFlexExactKeys(valueArg, ['version', 'type', 'init']) || !isFlexServiceInit(valueArg.init)) {
      throw new Error('Invalid Flex init message.');
    }
    return valueArg as unknown as IFlexIpcInitMessage;
  }
  if (valueArg.type === 'request') {
    if (
      !hasFlexExactKeys(valueArg, ['version', 'type', 'requestId', 'method', 'payload'])
      || !isRequestId(valueArg.requestId)
      || typeof valueArg.method !== 'string'
      || !requestMethods.has(valueArg.method)
      || !isFlexRequestPayload(valueArg.method as TFlexRequestMethod, valueArg.payload)
    ) throw new Error('Invalid Flex request message.');
    return valueArg as unknown as IFlexIpcRequestMessage;
  }
  if (valueArg.type === 'request.cancel') {
    if (
      !hasFlexExactKeys(valueArg, ['version', 'type', 'requestId'])
      || !isRequestId(valueArg.requestId)
    ) throw new Error('Invalid Flex request cancellation message.');
    return valueArg as unknown as IFlexIpcRequestCancelMessage;
  }
  if (valueArg.type === 'dispose') {
    if (!hasFlexExactKeys(valueArg, ['version', 'type', 'requestId']) || !isRequestId(valueArg.requestId)) {
      throw new Error('Invalid Flex dispose message.');
    }
    return valueArg as unknown as IFlexIpcDisposeMessage;
  }
  if (valueArg.type === 'host.response') {
    if (!isRequestId(valueArg.requestId) || typeof valueArg.ok !== 'boolean') {
      throw new Error('Invalid Flex host response message.');
    }
    if (valueArg.ok) {
      if (!hasFlexExactKeys(valueArg, ['version', 'type', 'requestId', 'ok', 'result'])) {
        throw new Error('Invalid successful Flex host response message.');
      }
    } else if (
      !hasFlexExactKeys(valueArg, ['version', 'type', 'requestId', 'ok', 'error'])
      || !isFlexServiceError(valueArg.error)
    ) {
      throw new Error('Invalid failed Flex host response message.');
    }
    return valueArg as unknown as TFlexIpcHostResponseMessage;
  }
  if (valueArg.type === 'browser.channel.frame') {
    if (
      !hasFlexExactKeys(valueArg, ['version', 'type', 'channelId', 'dataBase64'])
      || !isChannelId(valueArg.channelId)
      || !isCanonicalBrowserFrame(valueArg.dataBase64)
    ) throw new Error('Invalid Flex browser channel frame.');
    return valueArg as unknown as IFlexIpcParentBrowserFrameMessage;
  }
  if (valueArg.type === 'browser.channel.closed') {
    if (
      !hasFlexExactKeys(valueArg, [
        'version', 'type', 'channelId', 'sessionGenerationId', 'sessionGenerationSequence',
      ])
      || !isChannelId(valueArg.channelId)
      || !isFlexSessionGeneration(valueArg)
    ) throw new Error('Invalid Flex browser channel close message.');
    return valueArg as unknown as IFlexIpcBrowserChannelClosedMessage;
  }
  throw new Error('Invalid Flex parent message type.');
};

export const parseFlexChildMessage = (valueArg: unknown): TFlexChildMessage => {
  if (
    !isFlexPlainObject(valueArg)
    || valueArg.version !== flexIpcProtocolVersion
    || typeof valueArg.type !== 'string'
  ) throw new Error('Invalid Flex child message.');
  if (valueArg.type === 'status') {
    if (!hasFlexExactKeys(valueArg, ['version', 'type', 'status']) || !isFlexServiceStatus(valueArg.status)) {
      throw new Error('Invalid Flex status message.');
    }
    return valueArg as unknown as IFlexIpcStatusMessage;
  }
  if (valueArg.type === 'response') {
    if (!isRequestId(valueArg.requestId) || typeof valueArg.ok !== 'boolean') {
      throw new Error('Invalid Flex response message.');
    }
    if (valueArg.ok) {
      if (!hasFlexExactKeys(valueArg, ['version', 'type', 'requestId', 'ok', 'result'])) {
        throw new Error('Invalid successful Flex response message.');
      }
    } else if (
      !hasFlexExactKeys(valueArg, ['version', 'type', 'requestId', 'ok', 'error'])
      || !isFlexServiceError(valueArg.error)
    ) {
      throw new Error('Invalid failed Flex response message.');
    }
    return valueArg as unknown as TFlexIpcResponseMessage;
  }
  if (valueArg.type === 'event') {
    if (!hasFlexExactKeys(valueArg, ['version', 'type', 'event']) || !isFlexChildEvent(valueArg.event)) {
      throw new Error('Invalid Flex event message.');
    }
    return valueArg as unknown as IFlexIpcEventMessage;
  }
  if (valueArg.type === 'host.request') {
    if (
      !hasFlexExactKeys(
        valueArg,
        ['version', 'type', 'requestId', 'method', 'payload', 'timeoutMs'],
      )
      || !isRequestId(valueArg.requestId)
      || typeof valueArg.method !== 'string'
      || !hostRequestMethods.has(valueArg.method)
      || !Number.isSafeInteger(valueArg.timeoutMs)
      || Number(valueArg.timeoutMs) < 1
      || Number(valueArg.timeoutMs) > flexIpcMaximumHostTimeoutMs
      || !isFlexHostRequestPayload(
        valueArg.method as TFlexHostRequestMethod,
        valueArg.payload,
      )
    ) throw new Error('Invalid Flex host request message.');
    return valueArg as unknown as IFlexIpcHostRequestMessage;
  }
  if (valueArg.type === 'host.cancel') {
    if (
      !hasFlexExactKeys(valueArg, ['version', 'type', 'requestId'])
      || !isRequestId(valueArg.requestId)
    ) throw new Error('Invalid Flex host cancellation message.');
    return valueArg as unknown as IFlexIpcHostCancelMessage;
  }
  if (valueArg.type === 'host.response.acknowledge') {
    if (
      !hasFlexExactKeys(valueArg, ['version', 'type', 'requestId'])
      || !isRequestId(valueArg.requestId)
    ) throw new Error('Invalid Flex host response acknowledgement message.');
    return valueArg as unknown as IFlexIpcHostResponseAcknowledgementMessage;
  }
  if (valueArg.type === 'browser.channel.frame') {
    if (
      !hasFlexExactKeys(valueArg, ['version', 'type', 'channelId', 'dataBase64'])
      || !isChannelId(valueArg.channelId)
      || !isCanonicalBrowserFrame(valueArg.dataBase64)
    ) throw new Error('Invalid Flex browser channel frame.');
    return valueArg as unknown as IFlexIpcChildBrowserFrameMessage;
  }
  throw new Error('Invalid Flex child message type.');
};

export const createFlexServiceError = (
  codeArg: TFlexServiceErrorCode,
): IFlexServiceError => ({
  name: 'FlexServiceError',
  code: codeArg,
  message: flexServiceErrorMessages[codeArg],
});

export class FlexServiceError extends Error {
  public readonly name = 'FlexServiceError';

  constructor(public readonly code: TFlexServiceErrorCode) {
    super(flexServiceErrorMessages[code]);
  }
}