@opengeni/contracts 0.50.0 → 1.0.0

package/dist/session-history-import.d.ts

@@ -0,0 +1,947 @@
+import { z } from "zod";
+/** Import is a server-side migration boundary, not an execution/history API. */
+export declare const SESSION_HISTORY_IMPORT_MAX_EVENTS = 100;
+export declare const SESSION_HISTORY_IMPORT_MAX_BODY_BYTES = 1048576;
+export declare const SESSION_HISTORY_IMPORT_MAX_EVENT_BYTES = 262144;
+/** Historical facts only: no approval, credential, control or execution inputs. */
+export declare const ARCHIVED_SESSION_IMPORT_EVENT_TYPES: readonly ["user.message", "agent.message.delta", "agent.message.completed", "agent.reasoning.delta", "agent.toolCall.created", "agent.toolCall.output", "artifact.created", "turn.started", "turn.completed", "turn.failed", "turn.cancelled", "turn.superseded", "goal.set", "goal.updated", "goal.progress", "goal.completed", "goal.paused", "goal.resumed", "goal.cleared"];
+export declare const SessionImportedArchive: z.ZodObject<{
+    importId: z.ZodString;
+    importedAt: z.ZodISODateTime;
+    readOnly: z.ZodLiteral<true>;
+}, z.core.$strict>;
+export type SessionImportedArchive = z.infer<typeof SessionImportedArchive>;
+export declare const ArchivedSessionImportEvent: z.ZodObject<{
+    type: z.ZodEnum<{
+        "agent.message.completed": "agent.message.completed";
+        "agent.message.delta": "agent.message.delta";
+        "agent.reasoning.delta": "agent.reasoning.delta";
+        "agent.toolCall.created": "agent.toolCall.created";
+        "agent.toolCall.output": "agent.toolCall.output";
+        "artifact.created": "artifact.created";
+        "goal.cleared": "goal.cleared";
+        "goal.completed": "goal.completed";
+        "goal.paused": "goal.paused";
+        "goal.progress": "goal.progress";
+        "goal.resumed": "goal.resumed";
+        "goal.set": "goal.set";
+        "goal.updated": "goal.updated";
+        "turn.cancelled": "turn.cancelled";
+        "turn.completed": "turn.completed";
+        "turn.failed": "turn.failed";
+        "turn.started": "turn.started";
+        "turn.superseded": "turn.superseded";
+        "user.message": "user.message";
+    }>;
+    createdAt: z.ZodISODateTime;
+    turnId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strict>;
+export type ArchivedSessionImportEvent = z.infer<typeof ArchivedSessionImportEvent>;
+export declare const ImportArchivedSessionRequest: z.ZodObject<{
+    importId: z.ZodString;
+    title: z.ZodString;
+    createdAt: z.ZodISODateTime;
+    visibility: z.ZodOptional<z.ZodEnum<{
+        user_private: "user_private";
+        workspace_shared: "workspace_shared";
+    }>>;
+    events: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<{
+            "agent.message.completed": "agent.message.completed";
+            "agent.message.delta": "agent.message.delta";
+            "agent.reasoning.delta": "agent.reasoning.delta";
+            "agent.toolCall.created": "agent.toolCall.created";
+            "agent.toolCall.output": "agent.toolCall.output";
+            "artifact.created": "artifact.created";
+            "goal.cleared": "goal.cleared";
+            "goal.completed": "goal.completed";
+            "goal.paused": "goal.paused";
+            "goal.progress": "goal.progress";
+            "goal.resumed": "goal.resumed";
+            "goal.set": "goal.set";
+            "goal.updated": "goal.updated";
+            "turn.cancelled": "turn.cancelled";
+            "turn.completed": "turn.completed";
+            "turn.failed": "turn.failed";
+            "turn.started": "turn.started";
+            "turn.superseded": "turn.superseded";
+            "user.message": "user.message";
+        }>;
+        createdAt: z.ZodISODateTime;
+        turnId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export type ImportArchivedSessionRequest = z.input<typeof ImportArchivedSessionRequest>;
+export declare const AppendArchivedSessionEventsRequest: z.ZodObject<{
+    batchId: z.ZodString;
+    offset: z.ZodNumber;
+    events: z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<{
+            "agent.message.completed": "agent.message.completed";
+            "agent.message.delta": "agent.message.delta";
+            "agent.reasoning.delta": "agent.reasoning.delta";
+            "agent.toolCall.created": "agent.toolCall.created";
+            "agent.toolCall.output": "agent.toolCall.output";
+            "artifact.created": "artifact.created";
+            "goal.cleared": "goal.cleared";
+            "goal.completed": "goal.completed";
+            "goal.paused": "goal.paused";
+            "goal.progress": "goal.progress";
+            "goal.resumed": "goal.resumed";
+            "goal.set": "goal.set";
+            "goal.updated": "goal.updated";
+            "turn.cancelled": "turn.cancelled";
+            "turn.completed": "turn.completed";
+            "turn.failed": "turn.failed";
+            "turn.started": "turn.started";
+            "turn.superseded": "turn.superseded";
+            "user.message": "user.message";
+        }>;
+        createdAt: z.ZodISODateTime;
+        turnId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type AppendArchivedSessionEventsRequest = z.infer<typeof AppendArchivedSessionEventsRequest>;
+export declare const ImportArchivedSessionResponse: z.ZodObject<{
+    session: z.ZodLazy<z.ZodObject<{
+        bundledSkillIds: z.ZodOptional<z.ZodPipe<z.ZodArray<z.ZodEnum<{
+            "builtin:document-parsing": "builtin:document-parsing";
+            "builtin:opengeni-client": "builtin:opengeni-client";
+            "builtin:opengeni-documents": "builtin:opengeni-documents";
+            "builtin:opengeni-help": "builtin:opengeni-help";
+            "builtin:opengeni-presentations": "builtin:opengeni-presentations";
+            "builtin:opengeni-projects": "builtin:opengeni-projects";
+            "builtin:opengeni-schedules": "builtin:opengeni-schedules";
+            "builtin:opengeni-sites": "builtin:opengeni-sites";
+            "builtin:opengeni-skills": "builtin:opengeni-skills";
+            "builtin:opengeni-spreadsheets": "builtin:opengeni-spreadsheets";
+            "builtin:opengeni-video-generation": "builtin:opengeni-video-generation";
+            "builtin:opengeni-visualize": "builtin:opengeni-visualize";
+        }>>, z.ZodTransform<("builtin:document-parsing" | "builtin:opengeni-client" | "builtin:opengeni-documents" | "builtin:opengeni-help" | "builtin:opengeni-presentations" | "builtin:opengeni-projects" | "builtin:opengeni-schedules" | "builtin:opengeni-sites" | "builtin:opengeni-skills" | "builtin:opengeni-spreadsheets" | "builtin:opengeni-video-generation" | "builtin:opengeni-visualize")[], ("builtin:document-parsing" | "builtin:opengeni-client" | "builtin:opengeni-documents" | "builtin:opengeni-help" | "builtin:opengeni-presentations" | "builtin:opengeni-projects" | "builtin:opengeni-schedules" | "builtin:opengeni-sites" | "builtin:opengeni-skills" | "builtin:opengeni-spreadsheets" | "builtin:opengeni-video-generation" | "builtin:opengeni-visualize")[]>>>;
+        id: z.ZodString;
+        workspaceId: z.ZodString;
+        accountId: z.ZodString;
+        status: z.ZodEnum<{
+            cancelled: "cancelled";
+            failed: "failed";
+            idle: "idle";
+            queued: "queued";
+            recovering: "recovering";
+            requires_action: "requires_action";
+            running: "running";
+            waiting_capacity: "waiting_capacity";
+        }>;
+        admissionBlock: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            reason: z.ZodEnum<{
+                database_claim_rejected: "database_claim_rejected";
+                initiator_membership_required: "initiator_membership_required";
+                personal_resource_grant_required: "personal_resource_grant_required";
+            }>;
+            sqlState: z.ZodNullable<z.ZodString>;
+            retryPolicy: z.ZodLiteral<"explicit_recheck">;
+            blockedAt: z.ZodString;
+        }, z.core.$strict>>>;
+        dispatchWait: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            state: z.ZodEnum<{
+                acknowledged: "acknowledged";
+                pending: "pending";
+                unavailable: "unavailable";
+            }>;
+            attempts: z.ZodNumber;
+            nextAttemptAt: z.ZodNullable<z.ZodString>;
+            lastError: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>>;
+        failureDiagnostics: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            eventId: z.ZodString;
+            sequence: z.ZodNumber;
+            turnId: z.ZodNullable<z.ZodString>;
+            occurredAt: z.ZodString;
+            payload: z.ZodUnknown;
+        }, z.core.$strip>>>;
+        backgroundCommandActivity: z.ZodOptional<z.ZodObject<{
+            state: z.ZodEnum<{
+                running: "running";
+                stopping: "stopping";
+            }>;
+            count: z.ZodNumber;
+            unavailableCount: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+        hasSchedules: z.ZodOptional<z.ZodBoolean>;
+        initialMessage: z.ZodString;
+        title: z.ZodNullable<z.ZodString>;
+        titleSource: z.ZodNullable<z.ZodEnum<{
+            agent: "agent";
+            user: "user";
+        }>>;
+        instructions: z.ZodNullable<z.ZodString>;
+        policyRole: z.ZodDefault<z.ZodNullable<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>>>;
+        agentAccess: z.ZodDefault<z.ZodEnum<{
+            session: "session";
+            user: "user";
+            workspace: "workspace";
+        }>>;
+        scopeSubjectId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        memoryScope: z.ZodDefault<z.ZodEnum<{
+            off: "off";
+            user: "user";
+            workspace: "workspace";
+        }>>;
+        resources: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"repository">;
+            uri: z.ZodString;
+            ref: z.ZodString;
+            expectedCommitSha: z.ZodOptional<z.ZodString>;
+            mountPath: z.ZodOptional<z.ZodString>;
+            subpath: z.ZodOptional<z.ZodString>;
+            provider: z.ZodOptional<z.ZodEnum<{
+                azure_devops: "azure_devops";
+                github: "github";
+                gitlab: "gitlab";
+            }>>;
+            connectionType: z.ZodOptional<z.ZodLiteral<"github_personal">>;
+            credentialBindingId: z.ZodOptional<z.ZodString>;
+            access: z.ZodOptional<z.ZodEnum<{
+                read: "read";
+                write: "write";
+            }>>;
+            repositoryId: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+            installationId: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+            projectId: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+            connectionId: z.ZodOptional<z.ZodString>;
+            githubInstallationId: z.ZodOptional<z.ZodNumber>;
+            githubRepositoryId: z.ZodOptional<z.ZodNumber>;
+            optional: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"file">;
+            fileId: z.ZodString;
+            mountPath: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>], "kind">>;
+        skills: z.ZodDefault<z.ZodPipe<z.ZodArray<z.ZodPipe<z.ZodPipe<z.ZodObject<{
+            name: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            activationMode: z.ZodOptional<z.ZodEnum<{
+                session_selected: "session_selected";
+                workspace_managed: "workspace_managed";
+            }>>;
+            files: z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                content: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, z.ZodTransform<{
+            name: string;
+            description: string;
+            activationMode?: "session_selected" | "workspace_managed" | undefined;
+            files: {
+                path: string;
+                content: string;
+            }[];
+        }, {
+            name?: string | undefined;
+            description?: string | undefined;
+            activationMode?: "session_selected" | "workspace_managed" | undefined;
+            files: {
+                path: string;
+                content: string;
+            }[];
+        }>>, z.ZodTransform<{
+            name: string;
+            description: string;
+            files: {
+                path: string;
+                content: string;
+            }[];
+        }, {
+            name: string;
+            description: string;
+            activationMode?: "session_selected" | "workspace_managed" | undefined;
+            files: {
+                path: string;
+                content: string;
+            }[];
+        }>>>, z.ZodTransform<{
+            name: string;
+            description: string;
+            files: {
+                path: string;
+                content: string;
+            }[];
+        }[], {
+            name: string;
+            description: string;
+            files: {
+                path: string;
+                content: string;
+            }[];
+        }[]>>>;
+        tools: z.ZodArray<z.ZodObject<{
+            kind: z.ZodLiteral<"mcp">;
+            id: z.ZodString;
+            eager: z.ZodOptional<z.ZodBoolean>;
+            optional: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        toolPolicy: z.ZodObject<{
+            mode: z.ZodEnum<{
+                explicit: "explicit";
+                inherited: "inherited";
+                workspace_default: "workspace_default";
+            }>;
+            inheritedFromSessionId: z.ZodNullable<z.ZodString>;
+            excludedMcpServerIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>;
+        toolPolicyVersion: z.ZodNumber;
+        effectiveToolPolicy: z.ZodOptional<z.ZodObject<{
+            mode: z.ZodEnum<{
+                explicit: "explicit";
+                inherited: "inherited";
+                workspace_default: "workspace_default";
+            }>;
+            inheritedFromSessionId: z.ZodNullable<z.ZodString>;
+            selectedIds: z.ZodArray<z.ZodString>;
+            effectiveIds: z.ZodArray<z.ZodString>;
+            mandatoryIds: z.ZodArray<z.ZodString>;
+            lazyRouter: z.ZodObject<{
+                state: z.ZodEnum<{
+                    disabled: "disabled";
+                    required: "required";
+                }>;
+                deferredIds: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>;
+            configuredIds: z.ZodArray<z.ZodString>;
+            droppedIds: z.ZodArray<z.ZodString>;
+            counts: z.ZodObject<{
+                selected: z.ZodNumber;
+                effective: z.ZodNumber;
+                mandatory: z.ZodNumber;
+                deferred: z.ZodNumber;
+                configured: z.ZodNumber;
+                dropped: z.ZodNumber;
+            }, z.core.$strict>;
+            idsTruncated: z.ZodBoolean;
+        }, z.core.$strict>>;
+        metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        tenancy: z.ZodOptional<z.ZodObject<{
+            visibility: z.ZodEnum<{
+                private: "private";
+                workspace: "workspace";
+            }>;
+            authorityEpoch: z.ZodNumber;
+            ownedByCurrentUser: z.ZodBoolean;
+            fork: z.ZodNullable<z.ZodObject<{
+                sourceVisibility: z.ZodEnum<{
+                    private: "private";
+                    workspace: "workspace";
+                }>;
+                sourceAuthorityEpoch: z.ZodNumber;
+                forkedAt: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        createdBy: z.ZodObject<{
+            subjectId: z.ZodString;
+            label: z.ZodOptional<z.ZodString>;
+            kind: z.ZodEnum<{
+                service: "service";
+                subject: "subject";
+            }>;
+        }, z.core.$strip>;
+        createdByContext: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        model: z.ZodString;
+        reasoningEffort: z.ZodEnum<{
+            high: "high";
+            low: "low";
+            max: "max";
+            medium: "medium";
+            minimal: "minimal";
+            none: "none";
+            xhigh: "xhigh";
+        }>;
+        latencyMode: z.ZodEnum<{
+            fast: "fast";
+            priority: "priority";
+            standard: "standard";
+        }>;
+        sandboxBackend: z.ZodEnum<{
+            blaxel: "blaxel";
+            cloudflare: "cloudflare";
+            daytona: "daytona";
+            docker: "docker";
+            e2b: "e2b";
+            local: "local";
+            modal: "modal";
+            none: "none";
+            opensandbox: "opensandbox";
+            runloop: "runloop";
+            selfhosted: "selfhosted";
+            vercel: "vercel";
+        }>;
+        sandboxOs: z.ZodEnum<{
+            linux: "linux";
+            macos: "macos";
+            windows: "windows";
+        }>;
+        sandboxGroupId: z.ZodString;
+        activeSandboxId: z.ZodNullable<z.ZodString>;
+        activeEpoch: z.ZodNumber;
+        workingDir: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        variableSetIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        variableSetId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        environmentId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        rigId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        rigVersionId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        channelId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        firstPartyMcpPermissions: z.ZodNullable<z.ZodArray<z.ZodEnum<{
+            "account:admin": "account:admin";
+            "account:read": "account:read";
+            "api_keys:manage": "api_keys:manage";
+            "artifacts:publish": "artifacts:publish";
+            "artifacts:read": "artifacts:read";
+            "billing:manage": "billing:manage";
+            "billing:read": "billing:read";
+            "capabilities:manage": "capabilities:manage";
+            "codemode:call": "codemode:call";
+            "connections:read": "connections:read";
+            "connections:write": "connections:write";
+            "documents:manage": "documents:manage";
+            "documents:search": "documents:search";
+            "enrollments:manage": "enrollments:manage";
+            "enrollments:read": "enrollments:read";
+            "environments:manage": "environments:manage";
+            "environments:use": "environments:use";
+            "files:read": "files:read";
+            "files:upload": "files:upload";
+            "files:write": "files:write";
+            "github:manage": "github:manage";
+            "github:use": "github:use";
+            "goals:manage": "goals:manage";
+            "mcp_servers:attach": "mcp_servers:attach";
+            "members:manage": "members:manage";
+            "rigs:manage": "rigs:manage";
+            "rigs:use": "rigs:use";
+            "scheduled_tasks:manage": "scheduled_tasks:manage";
+            "scheduled_tasks:run": "scheduled_tasks:run";
+            "secrets:list": "secrets:list";
+            "secrets:read": "secrets:read";
+            "secrets:write": "secrets:write";
+            "sessions:control": "sessions:control";
+            "sessions:create": "sessions:create";
+            "sessions:read": "sessions:read";
+            "stream:acknowledge": "stream:acknowledge";
+            "stream:control": "stream:control";
+            "stream:view": "stream:view";
+            "terminal:attach": "terminal:attach";
+            "usage_allowances:manage": "usage_allowances:manage";
+            "variable-sets:attach": "variable-sets:attach";
+            "variable-sets:list": "variable-sets:list";
+            "variable-sets:manage": "variable-sets:manage";
+            "variable-sets:read": "variable-sets:read";
+            "variable-sets:use": "variable-sets:use";
+            "variable-sets:write": "variable-sets:write";
+            "workspace:admin": "workspace:admin";
+            "workspace:create": "workspace:create";
+            "workspace:read": "workspace:read";
+        }>>>;
+        firstPartyMcpTools: z.ZodArray<z.ZodEnum<{
+            artifacts_archive: "artifacts_archive";
+            artifacts_create: "artifacts_create";
+            artifacts_get_source: "artifacts_get_source";
+            artifacts_list: "artifacts_list";
+            artifacts_prepare_upload: "artifacts_prepare_upload";
+            artifacts_publish: "artifacts_publish";
+            artifacts_restore: "artifacts_restore";
+            artifacts_rollback: "artifacts_rollback";
+            atlassian_get: "atlassian_get";
+            atlassian_search: "atlassian_search";
+            atlassian_sources_list: "atlassian_sources_list";
+            browser_act: "browser_act";
+            browser_auth: "browser_auth";
+            browser_clipboard: "browser_clipboard";
+            browser_debug: "browser_debug";
+            browser_download_save: "browser_download_save";
+            browser_downloads: "browser_downloads";
+            browser_identity: "browser_identity";
+            browser_lifecycle: "browser_lifecycle";
+            browser_observe: "browser_observe";
+            browser_open: "browser_open";
+            browser_publish: "browser_publish";
+            browser_read: "browser_read";
+            browser_screenshot: "browser_screenshot";
+            browser_tabs: "browser_tabs";
+            capability_authorization_request: "capability_authorization_request";
+            capability_catalog_search: "capability_catalog_search";
+            command_read: "command_read";
+            command_wait: "command_wait";
+            company_profile_confirm: "company_profile_confirm";
+            company_profile_propose: "company_profile_propose";
+            computer_act: "computer_act";
+            computer_clipboard: "computer_clipboard";
+            computer_lifecycle: "computer_lifecycle";
+            computer_observe: "computer_observe";
+            computer_open: "computer_open";
+            computer_targets: "computer_targets";
+            connected_machine_enroll_token: "connected_machine_enroll_token";
+            connected_machine_remove: "connected_machine_remove";
+            custom_mcp_setup_request: "custom_mcp_setup_request";
+            editable_artifact_apply: "editable_artifact_apply";
+            editable_artifact_create: "editable_artifact_create";
+            editable_artifact_export: "editable_artifact_export";
+            editable_artifact_export_status: "editable_artifact_export_status";
+            editable_artifact_get: "editable_artifact_get";
+            editable_artifact_import: "editable_artifact_import";
+            editable_artifact_inspect: "editable_artifact_inspect";
+            editable_artifact_list: "editable_artifact_list";
+            environment_list: "environment_list";
+            environment_set_variable: "environment_set_variable";
+            fiken_bank_accounts_list: "fiken_bank_accounts_list";
+            fiken_companies_list: "fiken_companies_list";
+            fiken_contact_create: "fiken_contact_create";
+            fiken_contacts_list: "fiken_contacts_list";
+            fiken_invoice_draft_create: "fiken_invoice_draft_create";
+            fiken_invoice_get: "fiken_invoice_get";
+            fiken_invoices_list: "fiken_invoices_list";
+            fiken_products_list: "fiken_products_list";
+            fiken_purchases_list: "fiken_purchases_list";
+            fiken_sales_list: "fiken_sales_list";
+            github_connect_link: "github_connect_link";
+            github_repositories_list: "github_repositories_list";
+            goal_complete: "goal_complete";
+            goal_pause: "goal_pause";
+            goal_progress: "goal_progress";
+            goal_resume: "goal_resume";
+            goal_set: "goal_set";
+            goal_update: "goal_update";
+            instruction_policy_get: "instruction_policy_get";
+            instruction_policy_propose: "instruction_policy_propose";
+            instruction_policy_save: "instruction_policy_save";
+            interaction_discover: "interaction_discover";
+            interaction_request_human: "interaction_request_human";
+            knowledge_archive: "knowledge_archive";
+            knowledge_browse: "knowledge_browse";
+            knowledge_correct: "knowledge_correct";
+            knowledge_get: "knowledge_get";
+            knowledge_prepare_save: "knowledge_prepare_save";
+            knowledge_propose: "knowledge_propose";
+            knowledge_retain_file: "knowledge_retain_file";
+            knowledge_retain_message: "knowledge_retain_message";
+            knowledge_save: "knowledge_save";
+            knowledge_search: "knowledge_search";
+            memory_correct: "memory_correct";
+            memory_save: "memory_save";
+            memory_search: "memory_search";
+            preference_propose: "preference_propose";
+            preference_registry_get: "preference_registry_get";
+            preference_registry_summary: "preference_registry_summary";
+            project_create: "project_create";
+            project_delete: "project_delete";
+            project_get: "project_get";
+            project_list: "project_list";
+            project_reorder: "project_reorder";
+            project_update: "project_update";
+            reddit_accounts_list: "reddit_accounts_list";
+            reddit_mentions_live: "reddit_mentions_live";
+            reddit_post_reply: "reddit_post_reply";
+            reddit_posts_sync: "reddit_posts_sync";
+            reddit_search_live: "reddit_search_live";
+            reddit_thread_fetch: "reddit_thread_fetch";
+            remember: "remember";
+            remember_confirm: "remember_confirm";
+            rig_get: "rig_get";
+            rig_list: "rig_list";
+            rig_promote: "rig_promote";
+            rig_propose_change: "rig_propose_change";
+            rig_verify: "rig_verify";
+            run_on: "run_on";
+            sandbox_attach: "sandbox_attach";
+            sandbox_file_publish: "sandbox_file_publish";
+            sandbox_provision: "sandbox_provision";
+            sandbox_swap: "sandbox_swap";
+            sandboxes_list: "sandboxes_list";
+            scheduled_task_runs_list: "scheduled_task_runs_list";
+            scheduled_tasks_create: "scheduled_tasks_create";
+            scheduled_tasks_delete: "scheduled_tasks_delete";
+            scheduled_tasks_get: "scheduled_tasks_get";
+            scheduled_tasks_list: "scheduled_tasks_list";
+            scheduled_tasks_pause: "scheduled_tasks_pause";
+            scheduled_tasks_resume: "scheduled_tasks_resume";
+            scheduled_tasks_trigger: "scheduled_tasks_trigger";
+            scheduled_tasks_update: "scheduled_tasks_update";
+            session_create: "session_create";
+            session_events: "session_events";
+            session_get: "session_get";
+            session_human_input_respond: "session_human_input_respond";
+            session_pause: "session_pause";
+            session_resume: "session_resume";
+            session_send_message: "session_send_message";
+            session_set_model: "session_set_model";
+            session_set_project: "session_set_project";
+            session_steer: "session_steer";
+            session_wait: "session_wait";
+            sessions_list: "sessions_list";
+            set_other_session_title: "set_other_session_title";
+            set_session_title: "set_session_title";
+            slack_bot_channel_history: "slack_bot_channel_history";
+            slack_bot_delete_message: "slack_bot_delete_message";
+            slack_bot_file_content: "slack_bot_file_content";
+            slack_bot_file_info: "slack_bot_file_info";
+            slack_bot_list_channels: "slack_bot_list_channels";
+            slack_bot_list_files: "slack_bot_list_files";
+            slack_bot_list_users: "slack_bot_list_users";
+            slack_bot_post_message: "slack_bot_post_message";
+            slack_bot_prepare_message: "slack_bot_prepare_message";
+            slack_bot_search: "slack_bot_search";
+            slack_bot_send_prepared_message: "slack_bot_send_prepared_message";
+            slack_bot_thread_replies: "slack_bot_thread_replies";
+            slack_bot_upload_file: "slack_bot_upload_file";
+            social_connections_list: "social_connections_list";
+            social_daily_analysis_context: "social_daily_analysis_context";
+            social_mentions_live: "social_mentions_live";
+            social_post_reply: "social_post_reply";
+            social_posts_recent: "social_posts_recent";
+            social_posts_sync: "social_posts_sync";
+            social_search_live: "social_search_live";
+            social_thread_fetch: "social_thread_fetch";
+            task_note_archive: "task_note_archive";
+            task_note_promote_instruction_policy: "task_note_promote_instruction_policy";
+            task_note_promote_knowledge: "task_note_promote_knowledge";
+            task_note_promote_preference: "task_note_promote_preference";
+            task_note_replace: "task_note_replace";
+            task_note_save: "task_note_save";
+            task_notes_list: "task_notes_list";
+            variable_set_get_variable: "variable_set_get_variable";
+            variable_set_list: "variable_set_list";
+            variable_set_set_variable: "variable_set_set_variable";
+            wait_for_input: "wait_for_input";
+            work_claim_release: "work_claim_release";
+            work_claim_upsert: "work_claim_upsert";
+            x_accounts_list: "x_accounts_list";
+            x_mentions_live: "x_mentions_live";
+            x_post_reply: "x_post_reply";
+            x_posts_sync: "x_posts_sync";
+            x_search_live: "x_search_live";
+            x_thread_fetch: "x_thread_fetch";
+        }>>;
+        agent: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+            version: z.ZodLiteral<1>;
+            from: z.ZodEnum<{
+                all: "all";
+                none: "none";
+            }>;
+            capabilities: z.ZodObject<{
+                webSearch: z.ZodBoolean;
+                humanInput: z.ZodBoolean;
+                skills: z.ZodUnion<readonly [z.ZodLiteral<"read">, z.ZodLiteral<"manage">, z.ZodLiteral<false>]>;
+                goals: z.ZodBoolean;
+                subagents: z.ZodBoolean;
+                knowledge: z.ZodBoolean;
+                schedules: z.ZodBoolean;
+                artifacts: z.ZodBoolean;
+                browser: z.ZodBoolean;
+                media: z.ZodBoolean;
+                workspaceFiles: z.ZodBoolean;
+                workspaceConnectors: z.ZodBoolean;
+                workspaceAdmin: z.ZodBoolean;
+            }, z.core.$strict>;
+            unavailable: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+                artifacts: "artifacts";
+                browser: "browser";
+                goals: "goals";
+                humanInput: "humanInput";
+                knowledge: "knowledge";
+                media: "media";
+                schedules: "schedules";
+                skills: "skills";
+                subagents: "subagents";
+                webSearch: "webSearch";
+                workspaceAdmin: "workspaceAdmin";
+                workspaceConnectors: "workspaceConnectors";
+                workspaceFiles: "workspaceFiles";
+            }>>>;
+            identity: z.ZodNullable<z.ZodString>;
+            renderer: z.ZodEnum<{
+                markdown: "markdown";
+                opengeni: "opengeni";
+            }>;
+            source: z.ZodEnum<{
+                deployment_default: "deployment_default";
+                inherited: "inherited";
+                legacy_conversion: "legacy_conversion";
+                request: "request";
+                workspace_default: "workspace_default";
+            }>;
+        }, z.core.$strict>>>;
+        effectiveTools: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            capabilities: z.ZodObject<{
+                webSearch: z.ZodBoolean;
+                humanInput: z.ZodBoolean;
+                skills: z.ZodUnion<readonly [z.ZodLiteral<"read">, z.ZodLiteral<"manage">, z.ZodLiteral<false>]>;
+                goals: z.ZodBoolean;
+                subagents: z.ZodBoolean;
+                knowledge: z.ZodBoolean;
+                schedules: z.ZodBoolean;
+                artifacts: z.ZodBoolean;
+                browser: z.ZodBoolean;
+                media: z.ZodBoolean;
+                workspaceFiles: z.ZodBoolean;
+                workspaceConnectors: z.ZodBoolean;
+                workspaceAdmin: z.ZodBoolean;
+            }, z.core.$strict>;
+            unavailable: z.ZodArray<z.ZodEnum<{
+                artifacts: "artifacts";
+                browser: "browser";
+                goals: "goals";
+                humanInput: "humanInput";
+                knowledge: "knowledge";
+                media: "media";
+                schedules: "schedules";
+                skills: "skills";
+                subagents: "subagents";
+                webSearch: "webSearch";
+                workspaceAdmin: "workspaceAdmin";
+                workspaceConnectors: "workspaceConnectors";
+                workspaceFiles: "workspaceFiles";
+            }>>;
+            mediaToolsKnown: z.ZodOptional<z.ZodBoolean>;
+            tools: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                capability: z.ZodUnion<readonly [z.ZodEnum<{
+                    artifacts: "artifacts";
+                    browser: "browser";
+                    goals: "goals";
+                    humanInput: "humanInput";
+                    knowledge: "knowledge";
+                    media: "media";
+                    schedules: "schedules";
+                    skills: "skills";
+                    subagents: "subagents";
+                    webSearch: "webSearch";
+                    workspaceAdmin: "workspaceAdmin";
+                    workspaceConnectors: "workspaceConnectors";
+                    workspaceFiles: "workspaceFiles";
+                }>, z.ZodLiteral<"runtime">, z.ZodLiteral<"sandbox">, z.ZodLiteral<"product">]>;
+                source: z.ZodEnum<{
+                    first_party: "first_party";
+                    hosted: "hosted";
+                    mcp: "mcp";
+                    runtime: "runtime";
+                    sandbox: "sandbox";
+                }>;
+                visibility: z.ZodOptional<z.ZodEnum<{
+                    search: "search";
+                    upfront: "upfront";
+                }>>;
+            }, z.core.$strict>>;
+            mcpServers: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                capability: z.ZodUnion<readonly [z.ZodEnum<{
+                    artifacts: "artifacts";
+                    browser: "browser";
+                    goals: "goals";
+                    humanInput: "humanInput";
+                    knowledge: "knowledge";
+                    media: "media";
+                    schedules: "schedules";
+                    skills: "skills";
+                    subagents: "subagents";
+                    webSearch: "webSearch";
+                    workspaceAdmin: "workspaceAdmin";
+                    workspaceConnectors: "workspaceConnectors";
+                    workspaceFiles: "workspaceFiles";
+                }>, z.ZodLiteral<"runtime">, z.ZodLiteral<"product">]>;
+                toolsKnown: z.ZodBoolean;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>>;
+        mcpServers: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodNullable<z.ZodString>;
+            url: z.ZodString;
+            headerNames: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            credentialVersion: z.ZodNumber;
+            requireApproval: z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodPipe<z.ZodArray<z.ZodString>, z.ZodTransform<string[], string[]>>]>>;
+            connectionRef: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+                connectionId: z.ZodOptional<z.ZodString>;
+                accountSelection: z.ZodOptional<z.ZodLiteral<"all_eligible">>;
+                authoritySource: z.ZodOptional<z.ZodLiteral<"host">>;
+                hostBinding: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                    bindingId: z.ZodString;
+                    generation: z.ZodNumber;
+                }, z.core.$strict>, z.ZodObject<{
+                    selection: z.ZodLiteral<"accepted_turn">;
+                }, z.core.$strict>]>>;
+                provider: z.ZodOptional<z.ZodString>;
+                providerDomain: z.ZodString;
+                kind: z.ZodOptional<z.ZodEnum<{
+                    api_key: "api_key";
+                    app_install: "app_install";
+                    delegated: "delegated";
+                    oauth2: "oauth2";
+                }>>;
+                scopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                resource: z.ZodOptional<z.ZodString>;
+                selectedResources: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    kind: z.ZodLiteral<"repository">;
+                }, z.core.$strict>>>;
+                subjectScope: z.ZodOptional<z.ZodEnum<{
+                    subject: "subject";
+                    workspace: "workspace";
+                }>>;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>>>;
+        mcpApprovalPolicies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodBoolean, z.ZodPipe<z.ZodArray<z.ZodString>, z.ZodTransform<string[], string[]>>]>>>;
+        parentSessionId: z.ZodNullable<z.ZodString>;
+        rootSessionId: z.ZodString;
+        nestedAgentDepth: z.ZodNumber;
+        maxNestedAgentDepthOverride: z.ZodNullable<z.ZodNumber>;
+        effectiveMaxNestedAgentDepth: z.ZodNumber;
+        nestedAgentDepthPolicySource: z.ZodEnum<{
+            default: "default";
+            deployment: "deployment";
+            session: "session";
+            workspace: "workspace";
+        }>;
+        nestedAgentDepthPolicySessionId: z.ZodNullable<z.ZodString>;
+        createIdempotencyKey: z.ZodNullable<z.ZodString>;
+        temporalWorkflowId: z.ZodNullable<z.ZodString>;
+        activeTurnId: z.ZodNullable<z.ZodString>;
+        lastInputTokens: z.ZodNullable<z.ZodNumber>;
+        queueVersion: z.ZodNumber;
+        queueHeadPosition: z.ZodNumber;
+        queueTailPosition: z.ZodNumber;
+        effectiveControl: z.ZodObject<{
+            state: z.ZodEnum<{
+                active: "active";
+                paused: "paused";
+            }>;
+            controlVersion: z.ZodNumber;
+            controlEtag: z.ZodString;
+            directState: z.ZodEnum<{
+                active: "active";
+                paused: "paused";
+            }>;
+            primaryBlocker: z.ZodNullable<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    session: "session";
+                    workspace: "workspace";
+                }>;
+                sessionId: z.ZodOptional<z.ZodString>;
+                displayName: z.ZodString;
+                actor: z.ZodNullable<z.ZodString>;
+                reason: z.ZodNullable<z.ZodString>;
+                changedAt: z.ZodNullable<z.ZodString>;
+                revision: z.ZodNumber;
+            }, z.core.$strip>>;
+            additionalBlockerCount: z.ZodNumber;
+            blockers: z.ZodArray<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    session: "session";
+                    workspace: "workspace";
+                }>;
+                sessionId: z.ZodOptional<z.ZodString>;
+                displayName: z.ZodString;
+                actor: z.ZodNullable<z.ZodString>;
+                reason: z.ZodNullable<z.ZodString>;
+                changedAt: z.ZodNullable<z.ZodString>;
+                revision: z.ZodNumber;
+            }, z.core.$strip>>;
+            resumeOptions: z.ZodArray<z.ZodObject<{
+                scope: z.ZodEnum<{
+                    selected: "selected";
+                    session: "session";
+                    workspace: "workspace";
+                }>;
+                targetId: z.ZodOptional<z.ZodString>;
+                selectedStateAfter: z.ZodEnum<{
+                    active: "active";
+                    paused: "paused";
+                }>;
+                remainingPrimaryBlocker: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodEnum<{
+                        session: "session";
+                        workspace: "workspace";
+                    }>;
+                    sessionId: z.ZodOptional<z.ZodString>;
+                    displayName: z.ZodString;
+                    actor: z.ZodNullable<z.ZodString>;
+                    reason: z.ZodNullable<z.ZodString>;
+                    changedAt: z.ZodNullable<z.ZodString>;
+                    revision: z.ZodNumber;
+                }, z.core.$strip>>;
+                impactCopy: z.ZodString;
+            }, z.core.$strip>>;
+            override: z.ZodNullable<z.ZodObject<{
+                rootSessionId: z.ZodString;
+                revision: z.ZodNumber;
+            }, z.core.$strip>>;
+            settlement: z.ZodNullable<z.ZodObject<{
+                state: z.ZodLiteral<"stopping">;
+                attemptCount: z.ZodNumber;
+                interruptionPendingCount: z.ZodNumber;
+                quiescencePendingCount: z.ZodNumber;
+            }, z.core.$strip>>;
+            backgroundCommandSettlement: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                state: z.ZodLiteral<"stopping">;
+                commandCount: z.ZodNumber;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>;
+        inputWait: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            deadlineAt: z.ZodString;
+            reason: z.ZodString;
+        }, z.core.$strip>>>;
+        lastSequence: z.ZodNumber;
+        codexPinnedCredentialId: z.ZodNullable<z.ZodString>;
+        codexLastCredentialId: z.ZodNullable<z.ZodString>;
+        codexCurrentSelection: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            credentialId: z.ZodNullable<z.ZodString>;
+            waiting: z.ZodBoolean;
+        }, z.core.$strip>>>;
+        codexCompactionMode: z.ZodEnum<{
+            portable: "portable";
+            remote_v2: "remote_v2";
+        }>;
+        codeSearchEnabled: z.ZodDefault<z.ZodBoolean>;
+        pinned: z.ZodDefault<z.ZodBoolean>;
+        pinnedAt: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        pinVersion: z.ZodDefault<z.ZodNumber>;
+        unread: z.ZodDefault<z.ZodBoolean>;
+        activelyWorking: z.ZodDefault<z.ZodBoolean>;
+        attentionVersion: z.ZodDefault<z.ZodNumber>;
+        archived: z.ZodDefault<z.ZodBoolean>;
+        archivedAt: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        importedArchive: z.ZodOptional<z.ZodLazy<z.ZodObject<{
+            importId: z.ZodString;
+            importedAt: z.ZodISODateTime;
+            readOnly: z.ZodLiteral<true>;
+        }, z.core.$strict>>>;
+        archiveVersion: z.ZodDefault<z.ZodNumber>;
+        treeStats: z.ZodOptional<z.ZodObject<{
+            directChildren: z.ZodNumber;
+            totalDescendants: z.ZodNumber;
+            runningDescendants: z.ZodNumber;
+            queuedDescendants: z.ZodNumber;
+            waitingDescendants: z.ZodOptional<z.ZodNumber>;
+            attentionDescendants: z.ZodNumber;
+            pausedDescendants: z.ZodNumber;
+            failedDescendants: z.ZodNumber;
+            unreadDescendants: z.ZodOptional<z.ZodNumber>;
+            unreadFailedDescendants: z.ZodOptional<z.ZodNumber>;
+            activelyWorkingDescendants: z.ZodOptional<z.ZodNumber>;
+            attentionSince: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            truncated: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        requiresActionSince: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+    }, z.core.$strip>>;
+    importId: z.ZodString;
+    created: z.ZodBoolean;
+    nextOffset: z.ZodNumber;
+}, z.core.$strip>;
+export type ImportArchivedSessionResponse = z.infer<typeof ImportArchivedSessionResponse>;
+export declare const AppendArchivedSessionEventsResponse: z.ZodObject<{
+    sessionId: z.ZodString;
+    importId: z.ZodString;
+    nextOffset: z.ZodNumber;
+    replayed: z.ZodBoolean;
+}, z.core.$strip>;
+export type AppendArchivedSessionEventsResponse = z.infer<typeof AppendArchivedSessionEventsResponse>;