@superblocksteam/library-shared 1.99.99-next.3 → 2.0.0-SNAPSHOT.295fc0b43e332060

package/dist/types/socket.d.ts

@@ -1,38 +1,478 @@
+import type { DefaultStructureState } from "../default-structure.js";
+import type { AiAppFact, AiChangeInfoPush, AiChatGetMessagesResponse, AiChatMessage, AiGenerateRequest, AiGenerationStateSnapshot, AiInterpretPromptRequest, AiLabelAttachmentRequest, AiLabelAttachmentResponse, AiMoveAppKnowledgeRequest, AiMoveAppKnowledgeResult, AiPromptInterpretationPush, AiToolPermission, AiToolPermissionDetails, LLMProviderConfig, PromptContextIntegration, TokenRequestData } from "./ai.js";
+import type { ApiRunRecord, IApiV3Dto } from "./apis.js";
 import type { SbElement } from "./common.js";
-import type { AddEntityRequest, ApiUpdateRequest, BatchUpdateRequest, CreateRequest, DeleteEntityRequest, ReparentRequest, SetPropertiesRequest, SetPropertyRequest, UpdateEntityRequest, UpdateThemeRequest, DeleteRequest, ApiUpdateResponse, ApiDeleteRequest, ApiDeleteResponse, DeletePropertiesRequest, RenameElementRequest, RenameApiRequest, SyncronizationStatus, AiGenerateRequest } from "./edit-operations.js";
-import type { ServerError } from "./errors.js";
+/**
+ * A single live execution step emitted by a policy gate agent while it runs.
+ * Mirrors what Clark surfaces (a tool invocation or a reasoning/thinking
+ * block) so the editor can render the agent's latest activity inline under the
+ * running policy row. Only the latest step per policy is retained; these are
+ * best-effort, ephemeral, and not persisted.
+ *
+ * A step always represents the agent's *current* activity (an in-flight tool
+ * call or an ongoing thought), so the editor renders it in the present tense
+ * ("Reading `file`", "Thinking..."). Completed tool results are not surfaced.
+ */
+export type AiPolicyAgentStep = {
+    kind: "tool";
+    toolCallId: string;
+    tool: string;
+    args?: Record<string, unknown>;
+} | {
+    kind: "reasoning";
+    content: string;
+};
+export interface AiPolicyAgentStepPush {
+    applicationId: string;
+    policyId: string;
+    step: AiPolicyAgentStep;
+}
+/**
+ * Response type for SDK API execution via aiExecuteSdkApi.
+ * Used by both the library iframe (sender) and socket handler (receiver)
+ * to ensure type consistency.
+ */
+/**
+ * Per-integration-call diagnostic record captured during SDK API execution.
+ */
+export interface IntegrationCallDiagnostic {
+    integrationId: string;
+    pluginId: string;
+    inputTruncated?: string;
+    outputTruncated?: string;
+    startMs: number;
+    endMs: number;
+    durationMs: number;
+    error?: string;
+    /** Error code from the orchestrator (e.g. INTEGRATION_QUERY_TIMEOUT, INTEGRATION_NETWORK). */
+    errorCode?: string;
+    sequence: number;
+    metadata?: {
+        label?: string;
+        description?: string;
+    };
+    /** True when the input field was truncated to fit within the byte limit. */
+    inputWasTruncated?: boolean;
+    /** True when the output field was truncated to fit within the byte limit. */
+    outputWasTruncated?: boolean;
+}
+/**
+ * Breakdown of time spent in each phase of an SDK API execution.
+ * All values are milliseconds. Phases are sequential:
+ * bootstrap → discovery → fileSync → authCheck → network (fetch round-trip).
+ */
+export interface ExecutionTimingBreakdown {
+    /** Time spent waiting for the bootstrap response (app context, tokens). */
+    bootstrapMs?: number;
+    /** Time spent waiting for SDK API discovery to register the entry point. */
+    discoveryMs?: number;
+    /** Time spent flushing pending file writes to the server (ensureFilesSynced). */
+    fileSyncMs?: number;
+    /** Time spent on frontend auth checks before the orchestrator call. */
+    authCheckMs?: number;
+    /** Network round-trip time for the fetch to the orchestrator (fetch end − fetch start). */
+    networkMs?: number;
+}
+export interface SdkApiExecutionResult {
+    /** Whether execution succeeded */
+    success: boolean;
+    /** Output data if successful */
+    output?: unknown;
+    /** Error details if failed */
+    error?: {
+        code: string;
+        message: string;
+        details?: unknown;
+    };
+    /** Per-integration-call diagnostics when includeDiagnostics was requested */
+    diagnostics?: IntegrationCallDiagnostic[];
+    /** Unix epoch ms when the orchestrator started execution (from response performance.start). */
+    executionStartMs?: number;
+    /** Total execution duration in ms as measured by the orchestrator (from response performance.total). */
+    executionDurationMs?: number;
+    /** Unix epoch ms captured right before the HTTP request to the orchestrator. Used as fallback start time when orchestrator timing is unavailable. */
+    fetchStartMs?: number;
+    /** Per-phase timing breakdown for the execution. */
+    timingBreakdown?: ExecutionTimingBreakdown;
+}
+export interface AiSummarizeApiUsageRequest {
+    apiName: string;
+    jwt: string;
+    llmConfig?: LLMProviderConfig;
+    pages?: Array<{
+        name: string;
+        scopeId: string;
+    }>;
+}
+export interface AiPushApiUsageSummary {
+    apiName: string;
+    delta?: string;
+    isComplete?: boolean;
+    error?: string;
+}
+export interface AiSummarizeErrorRequest {
+    errorMessage: string;
+    pluginId: string;
+    integrationName: string;
+    input?: string;
+    summaryKey: string;
+    jwt: string;
+    llmConfig?: LLMProviderConfig;
+    apiName?: string;
+    stepLabel?: string;
+    errorCode?: string;
+}
+export interface AiPushErrorSummary {
+    summaryKey: string;
+    delta?: string;
+    isComplete?: boolean;
+    error?: string;
+}
+export interface DestructiveMigrationSummaryFinding {
+    excerpt: string;
+    fileName: string;
+    kind: string;
+}
+export interface AiSummarizeDestructiveMigrationRequest {
+    findings: DestructiveMigrationSummaryFinding[];
+    jwt: string;
+    scanUnavailable: boolean;
+    summaryKey: string;
+    llmConfig?: LLMProviderConfig;
+}
+export interface AiPushDestructiveMigrationSummary {
+    summaryKey: string;
+    delta?: string;
+    error?: string;
+    isComplete?: boolean;
+}
+/**
+ * Lifecycle state of a background task — mirrors the discriminated union
+ * the agent's TaskStore tracks (`TaskStatus`'s `state` field). Defined
+ * here (not in the agent's `tasks/types.ts`) so the UI can consume it
+ * without crossing the package boundary into agent-only code.
+ */
+export type BackgroundTaskState = "running" | "completed" | "failed" | "cancelled";
+/**
+ * Snapshot the agent pushes to the UI on every state/message change of a
+ * background task.
+ *
+ * Wire shape of `EditorClientMethods.aiPushTaskStatus`. Intentionally
+ * never includes the task's `result` — terminal results are only
+ * conveyed to the LLM via the generic checkTask/waitForTask flow, which
+ * already runs through the secret-scanning middleware. The UI surfaces
+ * `state` + `message` for live progress and `error` for failures only.
+ */
+export interface BackgroundTaskSummary {
+    taskId: string;
+    taskType: string;
+    label?: string;
+    state: BackgroundTaskState;
+    message?: string;
+    /** ms since `startedAt`. */
+    ageMs: number;
+    /** ISO timestamp for terminal states, otherwise undefined. */
+    completedAt?: string;
+    /**
+     * Short, plain-language failure reason when `state === "failed"`.
+     * Rendered directly in the chat checklist row (clamped) — keep it
+     * action-first and free of internal tool/infra jargon.
+     */
+    error?: string;
+    /**
+     * Optional fuller failure detail (classified code/message, request id,
+     * agent guidance). Surfaced to Clark via checkTask/waitForTask and as
+     * the checklist row tooltip — never as the clamped visible row text.
+     */
+    detail?: string;
+}
+import type { ApplicationEnvironmentSettings, ApplicationHashChangeSource, DegradedMode, MethodSchema, OpenApiSpec } from "@superblocksteam/shared";
+import type { ApiUpdateRequest, ApiUpdateResponse, ApiDeleteRequest, ApiDeleteResponse, RenameElementRequest, RenameApiRequest, SyncronizationStatus } from "./edit-operations.js";
+import type { RouterParseError, RuntimeErrorData, ServerError, ConsoleLogEntry } from "./errors.js";
 import type { DeleteMeLibraryApi } from "./parent-messages.js";
 import type { AppScope, SbScope } from "./scope.js";
-import type { MethodSchema } from "@superblocksteam/shared";
+export type EditorHasDefaultStructure = DefaultStructureState;
+export type EditorStructureReport = {
+    hasDefaultStructure: EditorHasDefaultStructure;
+};
 /**
  * Clients -> Server
+ *
+ * Adding a method to `editor` also requires adding its name to the registry
+ * in `./socket-method-names.ts`; the `satisfies` guard there makes the
+ * compiler enforce it.
  */
 export interface ServerMethods {
     editor: {
-        setProperties: MethodSchema<SetPropertiesRequest, any>;
-        deleteProperties: MethodSchema<DeletePropertiesRequest, void>;
-        moveComponent: MethodSchema<ReparentRequest, void>;
-        createComponent: MethodSchema<CreateRequest, SbElement | undefined>;
-        deleteComponents: MethodSchema<DeleteRequest, void>;
-        setProperty: MethodSchema<SetPropertyRequest, void>;
-        batchUpdate: MethodSchema<BatchUpdateRequest, unknown[]>;
         renameElement: MethodSchema<RenameElementRequest, void>;
         renameApi: MethodSchema<RenameApiRequest, void>;
         apiUpdate: MethodSchema<ApiUpdateRequest, ApiUpdateResponse>;
         apiDelete: MethodSchema<ApiDeleteRequest, ApiDeleteResponse | undefined>;
-        addEntity: MethodSchema<AddEntityRequest, void>;
-        updateEntity: MethodSchema<UpdateEntityRequest, void>;
-        deleteEntity: MethodSchema<DeleteEntityRequest, void>;
-        updateTheme: MethodSchema<UpdateThemeRequest, void>;
         ensureFilesSynced: MethodSchema<void, string | undefined>;
-        aiRejectDraft: MethodSchema<void, void>;
-        aiAcceptDraft: MethodSchema<void, void>;
+        aiRejectDraft: MethodSchema<{
+            silently?: boolean;
+        }, void>;
+        aiAcceptDraft: MethodSchema<{
+            silently?: boolean;
+        }, {
+            commitId: string;
+            warning?: {
+                code: "draft_state_cleanup_failed";
+                message: string;
+            };
+        }>;
+        aiUploadCheckpointScreenshot: MethodSchema<{
+            commitId: string;
+            screenshotDataUrl: string;
+        }, void>;
+        aiClearDraftState: MethodSchema<void, void>;
         aiGenerate: MethodSchema<AiGenerateRequest, void>;
+        aiGenerateWithQueue: MethodSchema<AiGenerateRequest & {
+            queueMode: "queue" | "interrupt";
+        }, {
+            /**
+             * The generation this prompt started, named the same way every
+             * `aiSetGenerationState` push for it is. A caller keeps it so it can
+             * tell its own turn ending from a generation the ai-service started
+             * on its own. Absent from dev servers that predate the field.
+             * (APPS-5161)
+             */
+            generationId?: string;
+            status: "started" | "interrupted";
+        }>;
+        releaseTurnLock: MethodSchema<{
+            headlessTurnId?: string;
+        }, void>;
+        /**
+         * Fires the invisible post-flip v2→v3 API migration turn on the
+         * ai-service. The server-side handler is idempotent (one-shot per
+         * ai-service process) and bails if no `seed_api` checklist items are
+         * pending, so the UI can call this unconditionally as soon as it
+         * observes the `translating` phase.
+         */
+        aiTriggerMigrationTurn: MethodSchema<{
+            jwt: string;
+            llmConfig: LLMProviderConfig;
+            /**
+             * When set, the turn is dispatched in debug-retry mode: the
+             * server bypasses its one-shot guard and the translation
+             * prompt is reframed around prior failures. Used after the
+             * UI's "Fix with Clark" button hits
+             * `/sb-migration-retry-unresolved`.
+             */
+            retryMode?: "focused-debug";
+        }, {
+            dispatched: boolean;
+            reason?: string;
+        }>;
         aiCancel: MethodSchema<void, void>;
+        aiNotifyIntegrationSetupClosed: MethodSchema<void | {
+            outcome: "abandoned" | "saved";
+        }, void>;
+        aiChatGetMessages: MethodSchema<{
+            force?: boolean;
+        }, AiChatGetMessagesResponse>;
+        aiNewChat: MethodSchema<void, void>;
+        aiRestoreToCommit: MethodSchema<{
+            sinceTimestamp: number;
+            commitId: string;
+            applicationId: string;
+            branchName: string;
+        }, void>;
+        aiInterpretPrompt: MethodSchema<AiInterpretPromptRequest, void>;
+        aiSummarizeApiUsage: MethodSchema<AiSummarizeApiUsageRequest, void>;
+        aiSummarizeDestructiveMigration: MethodSchema<AiSummarizeDestructiveMigrationRequest, void>;
+        aiSummarizeError: MethodSchema<AiSummarizeErrorRequest, void>;
+        aiSkipTestCase: MethodSchema<{
+            testRunId: string;
+            testCaseId: string;
+        }, void>;
+        aiRespondToToolPermission: MethodSchema<{
+            messageId: string;
+            approved: boolean;
+            alwaysAllowPermissions?: AiToolPermission[];
+            denyMessage?: string;
+            requestId?: string;
+        }, void>;
+        /**
+         * UI-initiated cancellation of a background task. The agent aborts
+         * the local poll loop and best-effort invokes the task type's
+         * `cancel` hook on the external system. Returns `{ cancelled: true }`
+         * when the task transitioned from `running` to `cancelled`, or
+         * `{ cancelled: false }` when the task was already terminal (or
+         * unknown — both surface as a no-op so the UI can dispatch this
+         * thunk optimistically).
+         */
+        aiCancelBackgroundTask: MethodSchema<{
+            taskId: string;
+        }, {
+            cancelled: boolean;
+        }>;
+        aiLabelAttachment: MethodSchema<AiLabelAttachmentRequest, AiLabelAttachmentResponse>;
+        handleRuntimeError: MethodSchema<RuntimeErrorData, void>;
+        handleClearRuntimeError: MethodSchema<{
+            id: string;
+        }, void>;
+        handleClearRuntimeErrors: MethodSchema<{
+            before?: number;
+        }, void>;
+        handleConsoleLog: MethodSchema<ConsoleLogEntry, void>;
+        handleApiRunRecord: MethodSchema<{
+            apiId: string;
+            run: ApiRunRecord;
+        }, void>;
+        handleJudgeEvaluation: MethodSchema<{
+            promptId: string;
+            prompt: string;
+            appId: string;
+            appUrl: string;
+            jwt: string;
+            llmConfig?: LLMProviderConfig;
+            options?: {
+                complexity?: "low" | "medium" | "high";
+                storageStatePath?: string;
+                playwrightServerUrl?: string;
+                connectWsEndpoint?: string;
+                storageStateData?: any;
+                sessionStorageData?: {
+                    origin: string;
+                    items: Array<{
+                        name: string;
+                        value: string;
+                    }>;
+                };
+                extraOrigins?: Array<{
+                    origin: string;
+                    localStorage: Array<{
+                        name: string;
+                        value: string;
+                    }>;
+                    sessionStorage?: Array<{
+                        name: string;
+                        value: string;
+                    }>;
+                }>;
+            };
+        }, {
+            promptId: string;
+            appId: string;
+            overallScore: number;
+            passed: boolean;
+            criteriaEvaluations: Array<{
+                criterion: string;
+                passed: boolean;
+                score: number;
+                reasoning: string;
+                evidence?: string;
+                suggestions?: string[];
+            }>;
+            summary: string;
+            suggestions: string[];
+            strengths?: string[];
+            weaknesses?: string[];
+            tokensUsed: {
+                input: number;
+                output: number;
+                cached?: number;
+                total: number;
+            };
+            evaluationDurationMs?: number;
+            confidence?: number;
+            error?: string;
+        }>;
+        ping: MethodSchema<void | {
+            isUserActive: boolean;
+        }, void>;
+        /** Enable/disable forwarding Clark (Vite plugin) logs to browser console. Use `?clark_logs=true` query param. */
+        setClarkLogsEnabled: MethodSchema<{
+            enabled: boolean;
+        }, void>;
+        /** Prime Clark with the user's inference JWT when auth hot-reload is unavailable (EE). */
+        primeClarkInferenceJwt: MethodSchema<{
+            jwt: string;
+        }, void>;
+        /** Get all saved app skill facts for the current application */
+        aiGetAppFacts: MethodSchema<void, {
+            facts: AiAppFact[];
+        }>;
+        /** Delete an app skill fact by its virtual path */
+        aiDeleteAppFact: MethodSchema<{
+            path: string;
+        }, void>;
+        /** Toggle the isEnabled field of an app skill fact */
+        aiToggleAppFact: MethodSchema<{
+            path: string;
+            isEnabled: boolean;
+        }, {
+            fact: AiAppFact;
+        }>;
+        /** Move app skill knowledge to org/user/integration scope */
+        aiMoveAppKnowledge: MethodSchema<AiMoveAppKnowledgeRequest, AiMoveAppKnowledgeResult>;
+        gitCommitLocal: MethodSchema<{
+            message: string;
+        }, {
+            sha: string;
+        }>;
+        gitPushLiveBranch: MethodSchema<void, void>;
+        gitRollbackLastCommit: MethodSchema<{
+            expectedSha: string;
+        }, {
+            rolledBack: boolean;
+        }>;
+        gitPull: MethodSchema<{
+            jwt?: string;
+        } | void, {
+            merged: boolean;
+            conflictedFiles?: string[];
+        }>;
+        gitSyncStatus: MethodSchema<void, {
+            ahead: number;
+            behind: number;
+            hasUncommittedChanges: boolean;
+            aheadOfDefaultBranch: boolean;
+            isLiveBranchMissing: boolean;
+            remoteAuthFailed?: boolean;
+        } | {
+            authFailed?: boolean;
+            bootstrapFailed: true;
+        } | null>;
+        gitChangedFiles: MethodSchema<void, Array<{
+            path: string;
+            status: "added" | "modified" | "deleted";
+        }>>;
+        gitDisconnect: MethodSchema<void, void>;
+        gitDefaultBranch: MethodSchema<void, string | null>;
+        gitBranchLog: MethodSchema<{
+            branch?: string;
+            limit?: number;
+            remote?: boolean;
+        } | void, Array<{
+            sha: string;
+            parents?: string[];
+            message: string;
+            author: string;
+            date: string;
+        }>>;
+        gitPrepareMainCommit: MethodSchema<{
+            sha: string;
+        }, {
+            directoryHash: string;
+            sha: string;
+        }>;
+        gitActivate: MethodSchema<void, {
+            activated: boolean;
+        }>;
+        gitRefreshCredentials: MethodSchema<void, {
+            refreshed: boolean;
+        }>;
     };
 }
 /**
  * Server -> Editor
+ *
+ * Adding a method here also requires adding its name to the registry in
+ * `./socket-method-names.ts`; the `satisfies` guard there makes the compiler
+ * enforce it.
  */
 export interface EditorClientMethods {
     updateScope: MethodSchema<{
@@ -46,58 +486,284 @@ export interface EditorClientMethods {
         id: string;
     }, void>;
     manualUpdateApi: MethodSchema<{
-        api: DeleteMeLibraryApi;
+        api: DeleteMeLibraryApi & {
+            scopeId: string;
+        };
+    }, void>;
+    updateApiInputs: MethodSchema<{
+        apiId: string;
+        inputs: string[];
     }, void>;
     error: MethodSchema<ServerError, void>;
+    routerParseError: MethodSchema<RouterParseError | null, void>;
     releasingLock: MethodSchema<void, void>;
+    closedByServer: MethodSchema<{
+        initiatedByEmail?: string;
+        switchingTo?: "local" | "cloud" | "none";
+    }, void>;
     syncStatus: MethodSchema<{
         status: SyncronizationStatus;
         generationNumber: number | undefined;
+        /** What caused the change, when it was an upload the dev server ran. */
+        source?: ApplicationHashChangeSource;
     }, void>;
-    aiSetLoading: MethodSchema<{
-        isLoading: boolean;
-    }, void>;
-    aiPushMessage: MethodSchema<{
-        text: string;
-        type?: "reasoning" | "text";
-    }, void>;
-    aiSetCompleted: MethodSchema<{
-        hasError?: boolean;
-        hasSuggestions?: boolean;
+    setDegradedMode: MethodSchema<{
+        degradedMode: DegradedMode | undefined;
     }, void>;
+    aiApplyApplicationEnvironmentSettings: MethodSchema<ApplicationEnvironmentSettings, void>;
+    aiSwitchSelectedEnvironment: MethodSchema<{
+        profileKey: string;
+    }, {
+        success: boolean;
+        profile?: {
+            displayName: string;
+            id: string;
+            key: string;
+        };
+        error?: string;
+    }>;
+    aiPushChangeInfo: MethodSchema<AiChangeInfoPush, void>;
+    aiPushMessage: MethodSchema<AiChatMessage, void>;
+    aiPushPromptInterpretation: MethodSchema<AiPromptInterpretationPush, void>;
     aiSetDraftState: MethodSchema<{
         hasDraft: boolean;
     }, void>;
+    aiGetOpenApiSpec: MethodSchema<{
+        ref: string;
+        integrationId: string;
+    }, OpenApiSpec | undefined>;
+    aiGetIntegration: MethodSchema<{
+        integrationId: string;
+    }, PromptContextIntegration>;
+    aiGetIntegrations: MethodSchema<void, Omit<PromptContextIntegration, "metadata">[]>;
+    aiSetGenerationState: MethodSchema<AiGenerationStateSnapshot, void>;
+    aiExecuteRequestToIntegration: MethodSchema<{
+        request: Record<string, unknown>;
+        integrationId: string;
+        integrationHint?: {
+            name: string;
+            type: string;
+            displayName?: string;
+        };
+    }, {
+        response?: string;
+        error?: string;
+    }>;
+    aiRequestToolPermission: MethodSchema<{
+        messageId: string;
+        toolName: string;
+        actionName: {
+            future: string;
+            present: string;
+            past: string;
+        } | undefined;
+        formattedInput: AiToolPermissionDetails | undefined;
+        rawInput: any;
+        permissions: AiToolPermission[];
+        signature?: string;
+    }, void>;
+    aiClearToolPermission: MethodSchema<void, void>;
+    aiPushTokenUsage: MethodSchema<TokenRequestData, void>;
+    aiPushContextUsed: MethodSchema<{
+        contextUsed: number;
+    }, void>;
+    aiPushApiUsageSummary: MethodSchema<AiPushApiUsageSummary, void>;
+    aiPushDestructiveMigrationSummary: MethodSchema<AiPushDestructiveMigrationSummary, void>;
+    aiPushErrorSummary: MethodSchema<AiPushErrorSummary, void>;
+    aiPushPolicyAgentStep: MethodSchema<AiPolicyAgentStepPush, void>;
+    /**
+     * Agent -> UI push fired on every background-task status transition
+     * (including the initial in-store snapshot after `start`) and
+     * re-emitted for every non-terminal task on socket reconnect so a
+     * fresh tab can rebuild its indicator state. Terminal summaries
+     * (`completed | failed | cancelled`) are pushed once; the UI is
+     * responsible for evicting entries on chat-clear or app-switch.
+     */
+    aiPushTaskStatus: MethodSchema<BackgroundTaskSummary, void>;
+    /**
+     * Agent -> UI push of the authoritative set of tasks the agent is
+     * actually running, sent once per socket reconnect alongside the
+     * per-task resync above (ENG-6785).
+     *
+     * `aiPushTaskStatus` is additive and cannot retire a row: when the
+     * process that owned a task is replaced, its successor has no record of
+     * the task and pushes nothing for it, which is indistinguishable from a
+     * task running quietly. The UI marks any local `running` row missing
+     * from `runningTaskIds` as no longer running. Scoped to what the
+     * reconnecting peer may see, so it never names another user's task.
+     */
+    aiSyncActiveTasks: MethodSchema<{
+        runningTaskIds: string[];
+    }, void>;
     setApiDependencies: MethodSchema<{
         apiDependencies: Record<string, string[]>;
     }, void>;
+    aiExecuteV2Api: MethodSchema<{
+        api: {
+            type: "inline";
+            definition: IApiV3Dto["apiPb"];
+        } | {
+            type: "fetch";
+            apiName: string;
+        };
+        inputs: Record<string, any>;
+        includeStepOutputs?: boolean;
+        timeout?: number;
+    }, {
+        outputs?: Record<string, any>;
+        stepOutputs?: Record<string, {
+            error?: any;
+            output?: any;
+        }>;
+        errors?: Array<{
+            message: string;
+            handled?: boolean;
+        }>;
+        systemError?: string;
+    }>;
+    aiExecuteSdkApi: MethodSchema<{
+        /** Name of the registered SDK API to execute */
+        apiName: string;
+        /** Input data for the API */
+        input: Record<string, unknown>;
+        /** Entry point resolved by the caller (used when browser discovery hasn't run yet) */
+        entryPoint?: string;
+        /** Export name for named-export APIs sharing a file */
+        exportName?: string;
+        /** Integration IDs extracted from the API source by the caller.
+         *  Used for auth preflight when the browser-side SDK discovery
+         *  hasn't registered the API in the Redux store yet. */
+        integrationIds?: string[];
+    }, SdkApiExecutionResult>;
+    aiCaptureScreenshot: MethodSchema<{
+        selector?: string;
+    } | void, {
+        dataUrl?: string;
+        error?: string;
+        /**
+         * True when no screenshot was taken because the app preview had not
+         * rendered yet (e.g. still building/migrating). The agent must treat this
+         * as "not ready / wait and retry", NOT as a visual verification result.
+         */
+        notReady?: boolean;
+    }>;
+    aiNavigatePreviewRoute: MethodSchema<{
+        hash?: string;
+        path: string;
+        queryParams?: Record<string, string>;
+        routeParams?: Record<string, string>;
+    }, {
+        error?: string;
+        path?: string;
+        success: boolean;
+    }>;
+    reloadIframe: MethodSchema<void, void>;
+    clarkLog: MethodSchema<{
+        level: "info" | "warn" | "error";
+        state: string;
+        messages: unknown[];
+        timestamp: number;
+        meta?: {
+            error: {
+                kind: string;
+                message: string;
+                stack?: string;
+            };
+        };
+    }, void>;
+    appFactsChanged: MethodSchema<void, void>;
+    requestGitRefresh: MethodSchema<void, void>;
+    notifyDeploySuccess: MethodSchema<{
+        commitId: string;
+        gitSha?: string;
+    }, void>;
+    aiGetIntegrationFormSchema: MethodSchema<{
+        pluginId: string;
+    }, {
+        success: boolean;
+        pluginId?: string;
+        pluginName?: string;
+        isTestable?: boolean;
+        fields?: Record<string, unknown>;
+        error?: string;
+    }>;
+    aiOpenIntegrationSetup: MethodSchema<{
+        pluginId: string;
+        label?: string;
+        fields?: Record<string, unknown>;
+    }, {
+        success: boolean;
+        formState?: unknown;
+        error?: string;
+    }>;
+    aiOpenExistingIntegration: MethodSchema<{
+        integrationId: string;
+        fields?: Record<string, unknown>;
+    }, {
+        success: boolean;
+        pluginId?: string;
+        integrationName?: string;
+        formState?: unknown;
+        error?: string;
+    }>;
+    aiUpdateIntegrationFields: MethodSchema<{
+        fields: Record<string, unknown>;
+        configId?: string;
+    }, {
+        success: boolean;
+        formState?: unknown;
+        error?: string;
+    }>;
+    aiTestIntegrationConnection: MethodSchema<{
+        configId?: string;
+    }, {
+        success: boolean;
+        configId?: string;
+        error?: {
+            message: string;
+            details: string;
+        };
+        formState?: unknown;
+    }>;
+    aiSaveIntegration: MethodSchema<{
+        force?: boolean;
+    }, {
+        success: boolean;
+        integrationId?: string;
+        integrationName?: string;
+        pluginId?: string;
+        testFailed?: boolean;
+        failedConfigIds?: string[];
+        error?: string;
+    }>;
+    aiCloseIntegrationSetup: MethodSchema<void, {
+        success: boolean;
+    }>;
+    aiDeleteIntegration: MethodSchema<{
+        integrationId: string;
+    }, {
+        success: boolean;
+        integrationId?: string;
+        integrationName?: string;
+        error?: string;
+    }>;
+    aiGetIntegrationDependents: MethodSchema<{
+        integrationId: string;
+    }, {
+        success: boolean;
+        appCount?: number;
+        appNames?: string[];
+        error?: string;
+    }>;
+}
+export interface GatewayClientMethods extends EditorClientMethods {
+    aiSetEditorHasDefaultStructure: MethodSchema<EditorStructureReport, void>;
 }
 /**
  * Server -> Library
  */
 export interface LibraryClientMethods {
     nonVisualEdit: MethodSchema<void, void>;
-    updateApiParams: MethodSchema<{
-        apiName: string;
-        params: string[];
-        apiDependencies: string[];
-    }, void>;
-    setApiDefinitions: MethodSchema<Record<string, {
-        api: DeleteMeLibraryApi;
-        scopeId: string;
-    }>, void>;
-    updateApi: MethodSchema<{
-        api: DeleteMeLibraryApi;
-        oldName?: string;
-        scopeId: string;
-    }, void>;
-    deleteApis: MethodSchema<{
-        apiName: string;
-        scopeId?: string;
-    }[], void>;
-    updateLocalBindingEntities: MethodSchema<{
-        entities: string[];
-    }, void>;
     renameRegisteredComponent: MethodSchema<{
         name: string;
         oldName?: string;
@@ -111,5 +777,13 @@ export interface LibraryClientMethods {
         entityId?: string;
         entityName?: string;
     }[], void>;
+    clientImport: MethodSchema<{
+        importPath: string;
+    }, Error | undefined>;
+    /** Notify library that an SDK API's source code has changed */
+    sdkApiSourceUpdated: MethodSchema<{
+        apiName: string;
+        sourceCode: string;
+    }, void>;
 }
 //# sourceMappingURL=socket.d.ts.map