Skill and tool reference

Interface snapshot: 2026-10-30.

Interface Count Contract
Callable plugin methods 98 Runtime function bindings with typed inputs and returns
Registered workflow skills 37 Instruction packages with task inputs, outputs, and backing methods
Additional on-disk skill definitions 9 Skill files without a registered activation entry
Additional guide copies 7 Alternative paths for existing workflows
Rendering contracts 9 Six named widgets and three response markup forms
Directory plugins 118 Three installed, 111 available to install, four disabled by administrator policy
Unresolved recommended integration 1 No exposed method contract or resolved directory record

Interface conventions

  • codex_apps.<namespace>.<method> identifies a plugin method. Binding gives its actual callable name; TypeScript signatures use the method's final name.
  • skills.* identifies a registered instruction package. Its backing functions retain the contracts in the method reference; the workflow itself has no independent RPC export.
  • cached.* identifies an on-disk skill definition; directory.* identifies a directory record. These names are reference locators, not function bindings.
  • render.* identifies a widget key or response markup form. Rendering produces interface content rather than an RPC return object.
  • ? marks an optional property and | null marks explicit nullability. Named structural types are defined in Shared API types. An unparameterized CallToolResult has no published operation-specific payload schema.
  • Workflow package entry points are <package>/SKILL.md. Cloud and executor packages identify separate access routes to the advertised workflow.
  • Productivity is the published plugin category. Other grouping labels indicate source placement or the absence of category metadata.

Callable plugin methods

  • Productivity

    • Pages — codex_apps.chatgpt_space (38 methods)

      • codex_apps.chatgpt_space.attach_automation_to_page - Attach an owned hosted automation to a writable Page as its controller, worker, or independent task.

        • Binding: tools.mcp__codex_apps__chatgpt_space_attach_automation_to_page.
        • TypeScript contract:
          ⎗
          ✓
          declare function attach_automation_to_page(args: {
            automation_id: string;
            automation_role?: "controller" | "task";
            controller_automation_id?: string | null;
            page_id: string;
          }): Promise<CallToolResult<AttachedAutomation | {
            message: string;
            outcome: "not_applicable";
            reason: "non_user_facing_environment";
          } | PageFailure>>;
          
        • Behavior: Requires Page edit access and an owned hosted automation. A worker references the attached controller with the same owner; configuration becomes visible to Page readers, while execution access is unchanged.
      • codex_apps.chatgpt_space.create_controller_automation - Create and attach an enabled hosted worker managed by the Page's current owned auto-update controller.

        • Binding: tools.mcp__codex_apps__chatgpt_space_create_controller_automation.
        • TypeScript contract:
          ⎗
          ✓
          declare function create_controller_automation(args: {
            controller_automation_id: string;
            default_timezone?: string | null;
            dtstart_offset_json?: string | null;
            page_id: string;
            prompt: string;
            schedule?: string;
            timing_mode?: "exact_schedule" | "flexible_schedule" | "condition_watch" | null;
            title: string;
            triggers?: Array<{ [key: string]: unknown; }> | null;
          }): Promise<CallToolResult<AttachedAutomation | PageFailure>>;
          
        • Behavior: Requires an enabled controller owned by the caller and Page edit access. Creation pauses the worker, attaches it, then enables it; no immediate run occurs.
      • codex_apps.chatgpt_space.create_page - Create a text Page privately, within a Space, beneath another Page, or linked to a Site.

        • Binding: tools.mcp__codex_apps__chatgpt_space_create_page.
        • TypeScript contract:
          ⎗
          ✓
          declare function create_page(args: {
            idempotency_key?: string | null;
            initial_blocks?: Array<string>;
            namespace?: "meeting_notes" | "data_reports" | null;
            parent_page_id?: string | null;
            position?: number | null;
            site_project_id?: string | null;
            space_id?: string | null;
            title: string;
          }): Promise<CallToolResult<{ [key: string]: unknown; } | PageFailure>>;
          
        • Behavior: Omitted destination IDs create a private Page. space_id selects a Space root; parent_page_id selects an existing Page. Site-linked Pages require a registered Site, an empty child, and an idempotency key.
      • codex_apps.chatgpt_space.create_page_visualization - Upload interactive HTML and insert or replace a visualization embed within an authorized writable Page.

        • Binding: tools.mcp__codex_apps__chatgpt_space_create_page_visualization.
        • TypeScript contract:
          ⎗
          ✓
          1
          2
          3
          4
          5
          6
          7
          8
          declare function create_page_visualization(args: {
            after_block_id?: string | null;
            base_sequence?: number | null;
            html: string;
            page_id: string;
            replace_block?: { block_id: string; expected_hash: string; } | null;
            title: string;
          }): Promise<CallToolResult>;
          
        • Behavior: HTML is limited to 256 KiB UTF-8. after_block_id inserts, replace_block replaces an observed hashed block, and omission of both appends. Only image-style visualization embeds execute viewer HTML.
        • Variants:

          • after_block_id inserts after an observed block; replace_block replaces an observed hashed block; omit both to append.
          • html is bounded at 256 KiB UTF-8. The generic return does not expose a complete typed edit receipt.
      • codex_apps.chatgpt_space.create_presentation - Create a native Spaces presentation with one blank slide at the requested private or shared destination.

        • Binding: tools.mcp__codex_apps__chatgpt_space_create_presentation.
        • TypeScript contract:
          ⎗
          ✓
          1
          2
          3
          4
          5
          6
          7
          8
          declare function create_presentation(args: {
            idempotency_key: string;
            namespace?: "meeting_notes" | "data_reports" | null;
            parent_page_id?: string | null;
            position?: number | null;
            space_id?: string | null;
            title: string;
          }): Promise<CallToolResult<{ [key: string]: unknown; } | PageFailure>>;
          
        • Behavior: Creates one empty slide. Omitted destinations are private; a Space ID selects its root and a parent Page ID creates a child. The same idempotency key identifies a retried creation.
      • codex_apps.chatgpt_space.create_space - Create a Drive-backed Space and its root Page when the account supports creating new Spaces.

        • Binding: tools.mcp__codex_apps__chatgpt_space_create_space.
        • TypeScript contract:
          ⎗
          ✓
          1
          2
          3
          4
          5
          6
          7
          8
          declare function create_space(args: { name: string; }): Promise<CallToolResult<{
            backing_type: "drive";
            id: string;
            name: string;
            project_id?: null;
            root_directory_id?: string | null;
            root_page_id: string;
          } | PageFailure>>;
          
        • Behavior: Creates a Drive-backed Space with its own root Page when Space creation is enabled.
      • codex_apps.chatgpt_space.edit_page - Apply guarded content or structural Page edits, including titles, blocks, links, metadata, and block order.

        • Binding: tools.mcp__codex_apps__chatgpt_space_edit_page.
        • TypeScript contract:
          ⎗
          ✓
          declare function edit_page(args: {
            base_sequence?: number | null;
            operations: Array<{ expected_title_hash: string; op: "set_title"; title: string; } | {
              block_id: string;
              expected_hash: string;
              op: "patch_block_markdown";
              replacements: Array<{ new: string; old: string; }>;
            }> | Array<{ expected_title_hash: string; op: "set_title"; title: string; } | {
              at: { following_block_id: string | null; kind: "between_blocks"; preceding_block_id: string | null; } | {
                anchor: { kind: "yjs_relative"; relative_position_base64: string; } | {
                  expected_block_hash: string;
                  kind: "snapshot_offset";
                  offset_utf16: number;
                };
                block_id: string;
                kind: "in_block";
              };
              block_kind?: "markdown" | "agent_instructions";
              block_units?: Array<string | {
                kind: "markdown" | "agent_instructions";
                markdown: string;
                metadata?: { [key: string]: unknown; } | null;
              }> | null;
              markdown?: string;
              op: "insert_markdown";
            } | {
              block_id: string;
              block_kind?: "markdown" | "agent_instructions" | null;
              block_units?: Array<string | {
                kind: "markdown" | "agent_instructions";
                markdown: string;
                metadata?: { [key: string]: unknown; } | null;
              }> | null;
              expected_hash?: string | null;
              markdown?: string;
              op: "replace_block_markdown";
            } | { block_id: string; expected_hash?: string | null; op: "delete_block"; } | {
              after_block_id: string | null;
              block_id: string;
              op: "move_block";
            } | {
              block_id: string;
              expected_hash?: string | null;
              metadata: { [key: string]: unknown; };
              op: "set_block_metadata";
            } | {
              at: { following_block_id: string | null; kind: "between_blocks"; preceding_block_id: string | null; } | {
                anchor: { kind: "yjs_relative"; relative_position_base64: string; } | {
                  expected_block_hash: string;
                  kind: "snapshot_offset";
                  offset_utf16: number;
                };
                block_id: string;
                kind: "in_block";
              };
              label?: string;
              op: "insert_page_link";
              target_page_id: string;
            }>;
            page_id: string;
            stream_kind?: "content" | "scratch";
          }): Promise<CallToolResult<PageEditResult>>;
          
        • Behavior: Structural operations can insert, replace, delete, or move blocks. Literal patches preserve each nonempty canonical block. Receipts report individual operation outcomes, hashes, sequence guards, and recovery information.
        • Variants:

          • operations[].op: "set_title" uses expected_title_hash and returns an operation receipt.
          • patch_block_markdown uses block_id, expected_hash, and literal replacements; it preserves canonical block structure.
          • insert_markdown uses an insertion position; replace_block_markdown uses an observed block and optional hash.
          • delete_block, move_block, and set_block_metadata use observed block identifiers and their operation-specific fields.
          • insert_page_link inserts a verified target Page link at the specified position.
          • Patch-operation arrays and structural-operation arrays are distinct branches of the input union.
      • codex_apps.chatgpt_space.execute_artifact_code - Edit native Spaces artifacts through JavaScript callbacks and report whether their changes were actually committed.

        • Binding: tools.mcp__codex_apps__chatgpt_space_execute_artifact_code.
        • TypeScript contract:
          ⎗
          ✓
          declare function execute_artifact_code(args: {
            code: string;
            font_files_to_load?: Array<string>;
            hydrate_images?: boolean;
            idempotency_key: string;
            image_references?: Array<string>;
            page_id: string;
            wait_for_persistence?: boolean;
          }): Promise<CallToolResult<ArtifactExecution | {
            error: { code?: string | null; commit_status?: string | null; message: string; retryable?: boolean | null; };
          }>>;
          
        • Behavior: Callbacks contain 1–65,536 characters and return at most 16 KiB JSON. committed confirms persistence; accepted or unknown requires status reconciliation. Each Page permits only one artifact inspection or execution at a time.
        • Variants:

          • Spreadsheet callbacks receive workbook; presentation callbacks receive presentation; Canvas callbacks receive whiteboard.
          • wait_for_persistence: false permits an accepted result; only committed confirms persistence.
          • These callback contexts are artifact SDK objects, not additional exposed top-level tools.
      • codex_apps.chatgpt_space.find_pages - Search accessible Pages by query, optionally restrict results to one Space, and follow returned pagination.

        • Binding: tools.mcp__codex_apps__chatgpt_space_find_pages.
        • TypeScript contract:
          ⎗
          ✓
          declare function find_pages(args: { cursor?: string | null; query: string; space_id?: string | null; }): Promise<CallToolResult<PageList | PageFailure>>;
          
        • Behavior: Queries contain 1–512 Unicode code points. next_cursor continues with the same query and Space; null ends continuation. Results are bounded, and an empty result does not establish absence.
      • codex_apps.chatgpt_space.get_artifact_execution_status - Check whether an earlier artifact edit committed using its original Page identifier and idempotency key.

        • Binding: tools.mcp__codex_apps__chatgpt_space_get_artifact_execution_status.
        • TypeScript contract:
          ⎗
          ✓
          1
          2
          3
          declare function get_artifact_execution_status(args: { idempotency_key: string; page_id: string; }): Promise<CallToolResult<ArtifactExecution | {
            error: { code?: string | null; commit_status?: string | null; message: string; retryable?: boolean | null; };
          }>>;
          
        • Behavior: The original Page ID and idempotency key identify an execution. Status confirms persistence, not live progress or recovery of the callback's transient return value.
      • codex_apps.chatgpt_space.get_page_auto_update - Inspect a Page's auto-update controller, current status, and permissions for enabling or disabling future updates.

        • Binding: tools.mcp__codex_apps__chatgpt_space_get_page_auto_update.
        • TypeScript contract:
          ⎗
          ✓
          1
          2
          3
          declare function get_page_auto_update(args: { page_id: string; }): Promise<CallToolResult<{
            [key: string]: unknown;
          } | PageFailure>>;
          
        • Behavior: Readers can inspect controller status. Enabling or disabling requires controller ownership and Page edit access; setup and immediate execution are separate operations.
      • codex_apps.chatgpt_space.get_page_sharing - Inspect Page sharing and permissions, including limited owner-only observations when full sharing management is unavailable.

        • Binding: tools.mcp__codex_apps__chatgpt_space_get_page_sharing.
        • TypeScript contract:
          ⎗
          ✓
          1
          2
          3
          4
          declare function get_page_sharing(args: { page_id: string; }): Promise<CallToolResult<{
            scope: "page_and_backing_library_folder" | "space_and_backing_library_folder";
            sharing_available: true;
          } | { scope: "page_owner"; sharing_available: false; } | PageFailure>>;
          
        • Behavior: Full sharing includes direct and visible inherited grants. Limited owner observations expose owner_only as true, false, or unknown without a collaborator roster; a Space root delegates sharing changes to its Space.
      • codex_apps.chatgpt_space.get_sharing_availability - Check whether the active account supports sharing management before inspecting recipients or changing collaborator access.

        • Binding: tools.mcp__codex_apps__chatgpt_space_get_sharing_availability.
        • TypeScript contract:
          ⎗
          ✓
          1
          2
          3
          declare function get_sharing_availability(args: {}): Promise<CallToolResult<{
            sharing_management_enabled: boolean;
          } | PageFailure>>;
          
        • Behavior: Reports account policy for sharing management. Disabled management does not establish resource privacy; limited owner-only Page observations can remain available.
      • codex_apps.chatgpt_space.get_space - Retrieve canonical Space metadata and its root Page identifier for subsequent navigation and content reading.

        • Binding: tools.mcp__codex_apps__chatgpt_space_get_space.
        • TypeScript contract:
          ⎗
          ✓
          declare function get_space(args: { space_id: string; }): Promise<CallToolResult>;
          
        • Behavior: The returned id identifies the Space; root_page_id identifies the root Page accepted by read_page.
      • codex_apps.chatgpt_space.get_space_sharing - Read whole-Space sharing, backing folder grants, invitations, and visible inherited access after checking sharing availability.

        • Binding: tools.mcp__codex_apps__chatgpt_space_get_space_sharing.
        • TypeScript contract:
          ⎗
          ✓
          1
          2
          3
          4
          5
          declare function get_space_sharing(args: { space_id: string; }): Promise<CallToolResult<{
            scope: "space_and_backing_library_folder";
            sharing_available: true;
            workspace_id?: string | null;
          } | { [key: string]: unknown; } | { [key: string]: unknown; } | { [key: string]: unknown; }>>;
          
        • Behavior: Requires the sharing-availability check. Includes canonical backing-folder sharing, pending invitations, workspace identity, and visible inherited access; incomplete information does not establish absence of access.
      • codex_apps.chatgpt_space.inspect_artifact - Inspect native spreadsheets, presentations, or canvases through read-only JavaScript callbacks without saving any document changes.

        • Binding: tools.mcp__codex_apps__chatgpt_space_inspect_artifact.
        • TypeScript contract:
          ⎗
          ✓
          declare function inspect_artifact(args: {
            code: string;
            font_files_to_load?: Array<string>;
            hydrate_images?: boolean;
            image_references?: Array<string>;
            page_id: string;
          }): Promise<CallToolResult<{
            committed_sequence?: number | null;
            document_type?: string | null;
            error_code?: string | null;
            error_details?: {
              category?: "semantic" | "unknown";
              message: string;
              name: string;
              stack: Array<string>;
              truncated: boolean;
            } | null;
            error_message?: string | null;
            font_loading?: {
              error_details?: {
                category?: "semantic" | "unknown";
                message: string;
                name: string;
                stack: Array<string>;
                truncated: boolean;
              } | null;
              message?: string | null;
              status: "loaded" | "disabled" | "runtime_unsupported" | "memory_limit" | "registration_failed";
            } | null;
            observed_sequence?: number | null;
            page_id: string;
            rendered_images?: Array<{ byte_length: number; file_name: string; mime_type: string; sha256: string; }> | null;
            request_id: string;
            result?: unknown;
            result_message?: string | null;
            result_omitted?: boolean;
            retryable?: boolean;
            status: "committed" | "accepted" | "no_changes" | "rejected" | "unknown" | "not_found";
          } | {
            error: { code?: string | null; commit_status?: string | null; message: string; retryable?: boolean | null; };
          }>>;
          
        • Behavior: Requires Page read access; attempted changes are rejected. Callback size is 1–65,536 characters and returned JSON is at most 16 KiB. Rendering supports up to four sequential PNGs totaling 4 MiB.
        • Variants:

          • Callbacks receive the existing artifact's workbook, presentation, or whiteboard model in a read-only session.
          • Return a bounded JSON selection; attempted document edits are rejected and discarded.
          • hydrate_images with selected image_references enables required image bytes for rendering.
      • codex_apps.chatgpt_space.inspect_page_reference - Inspect authorized Page reference metadata to determine file size and format before reading its actual content.

        • Binding: tools.mcp__codex_apps__chatgpt_space_inspect_page_reference.
        • TypeScript contract:
          ⎗
          ✓
          1
          2
          3
          4
          5
          6
          7
          8
          declare function inspect_page_reference(args: { page_id: string; reference: string; }): Promise<CallToolResult<{
            byte_size: number | null;
            guidance: string;
            metadata_available: boolean;
            mime_type: string | null;
            page_id: string;
            reference: string;
          } | PageFailure>>;
          
        • Behavior: Returns authorized MIME and byte-size metadata without reading content where possible. Unavailable advisory metadata does not establish unreadability.
      • codex_apps.chatgpt_space.list_page_automations - List attached Page automations, controllers, and workers before linking tasks or changing their management configuration.

        • Binding: tools.mcp__codex_apps__chatgpt_space_list_page_automations.
        • TypeScript contract:
          ⎗
          ✓
          1
          2
          3
          declare function list_page_automations(args: { page_id: string; }): Promise<CallToolResult<{
            [key: string]: unknown;
          } | PageFailure>>;
          
        • Behavior: Lists the attached controller, workers, and independent tasks. Attachments expose configuration to readers; private run conversations remain private.
      • codex_apps.chatgpt_space.list_page_comments - Read collaborator comment threads and message identifiers, optionally filtered by block or open and resolved state.

        • Binding: tools.mcp__codex_apps__chatgpt_space_list_page_comments.
        • TypeScript contract:
          ⎗
          ✓
          declare function list_page_comments(args: {
            block_id?: string | null;
            limit?: number;
            page_id: string;
            state?: "open" | "resolved" | null;
          }): Promise<CallToolResult<{
            page_id: string;
            sequence?: number;
            threads: Array<CommentThread>;
            truncated: boolean;
          } | PageFailure>>;
          
        • Behavior: Filters select an observed block or open/resolved state. Selection offsets are UTF-16 code units; detached context does not imply selection of an entire block.
      • codex_apps.chatgpt_space.list_pages - List accessible Pages and native artifacts, optionally scoped to a Space, parent branch, or namespace.

        • Binding: tools.mcp__codex_apps__chatgpt_space_list_pages.
        • TypeScript contract:
          ⎗
          ✓
          1
          2
          3
          4
          5
          6
          7
          8
          9
          declare function list_pages(args: {
            cursor?: string | null;
            include_has_children?: boolean;
            limit?: number;
            namespace?: "meeting_notes" | "data_reports" | null;
            parent_page_id?: string | null;
            space_id?: string | null;
            top_level_only?: boolean;
          }): Promise<CallToolResult<PageList | PageFailure>>;
          
        • Behavior: Supports Space, parent-branch, namespace, and top-level filters. document_type distinguishes native artifacts; root Page identity comes from get_space rather than the Space ID.
      • codex_apps.chatgpt_space.list_spaces - List accessible Drive-backed Spaces in the authenticated account and continue through every returned pagination cursor.

        • Binding: tools.mcp__codex_apps__chatgpt_space_list_spaces.
        • TypeScript contract:
          ⎗
          ✓
          declare function list_spaces(args: { cursor?: string | null; limit?: number; }): Promise<CallToolResult>;
          
        • Behavior: Lists accessible Drive-backed Spaces. A non-null next_cursor continues pagination even when the current page contains no items.
      • codex_apps.chatgpt_space.manage_page_comment - Add, reply to, react to, resolve, reopen, edit, or delete authorized Page comment content.

        • Binding: tools.mcp__codex_apps__chatgpt_space_manage_page_comment.
        • TypeScript contract:
          ⎗
          ✓
          declare function manage_page_comment(args: {
            action: "add" | "reply" | "react" | "resolve" | "reopen" | "edit" | "delete_message" | "delete_thread";
            active?: boolean | null;
            block_id?: string | null;
            body?: string | null;
            emoji?: string | null;
            message_id?: string | null;
            occurrence?: number | null;
            page_id: string;
            selected_text?: string | null;
            thread_id?: string | null;
          }): Promise<CallToolResult<CommentMutation | PageFailure>>;
          
        • Behavior: Reaction changes require active and one Unicode emoji. Message edits/deletions require authorship; thread deletion requires ownership of every message, including tombstones. Unknown commit outcomes require thread reconciliation.
        • Variants:

          • add uses observed block context or exact selected text; reply uses an existing thread and body.
          • react uses a thread/message, one emoji, and the required active state.
          • resolve and reopen target an observed thread.
          • edit and delete_message require message authorship; delete_thread requires ownership of every thread message.
          • Actions share the declared return union, including thread/message IDs and sequence.
      • codex_apps.chatgpt_space.move_page - Move Pages between parents or storage scopes using previews, confirmation receipts, and explicit operation recovery.

        • Binding: tools.mcp__codex_apps__chatgpt_space_move_page.
        • TypeScript contract:
          ⎗
          ✓
          declare function move_page(args: {
            action?: "move" | "confirm" | "status" | "resume";
            operation_id?: string | null;
            page_id: string;
            parent_page_id?: string | null;
            preview_token?: string | null;
            source_space_id?: string | null;
            space_id?: string | null;
          }): Promise<CallToolResult<{ [key: string]: unknown; } | { requires_confirmation: true; } | {
            result?: { page_ids: Array<string>; };
            status?: "completed";
          } | { result?: null; status?: "pending" | "recovery_required" | "cancelled"; } | PageFailure>>;
          
        • Behavior: Same-scope moves require an explicit parent, including null for the personal root. Cross-scope moves return an access preview requiring confirmation. Original operation identifiers support status and recovery; pending is not completion.
        • Variants:

          • action: "move" (default): supply an explicit parent_page_id, including null for the personal root; returns a move result or cross-scope preview.
          • action: "confirm": supply the original preview_token and page_id; omit source, operation, parent, and Space fields.
          • action: "status" or "resume": use the original source_space_id and operation_id for reconciliation or recovery.
          • pending is acceptance; completed confirms success. These actions are not separate exposed functions.
      • codex_apps.chatgpt_space.patch_page - Replace literal text within existing canonical Markdown blocks while preserving block identity, order, and count.

        • Binding: tools.mcp__codex_apps__chatgpt_space_patch_page.
        • TypeScript contract:
          ⎗
          ✓
          declare function patch_page(args: {
            changes: Array<{
              block_id: string;
              block_index?: null;
              expected_hash: string;
              replacements: Array<{ new: string; old: string; } | { new_code_text: string; old_code_block: string; }>;
            }> | Array<{
              block_id?: null;
              block_index: number;
              expected_hash?: null;
              replacements: Array<{ new: string; old: string; } | { new_code_text: string; old_code_block: string; }>;
            }>;
            observed_sequence?: number | null;
            page_id: string;
            stream_kind?: "content" | "scratch";
          }): Promise<CallToolResult<PageEditResult>>;
          
        • Behavior: ID mode uses observed block IDs and hashes. Legacy index mode requires the observed sequence and whole-Page indexes. Empty replacement text deletes a span; structural changes use edit_page.
        • Variants:

          • changes targets either block IDs with expected hashes or observed block indexes; the two array shapes are distinct.
          • Each replacement is ordinary literal text or a code-block replacement using old_code_block and new_code_text.
          • Success and conflict returns carry operation-level receipts; a structural change belongs in edit_page.
      • codex_apps.chatgpt_space.progress_update - Publish temporary progress messages and text highlights on an open Page without editing its saved content.

        • Binding: tools.mcp__codex_apps__chatgpt_space_progress_update.
        • TypeScript contract:
          ⎗
          ✓
          1
          2
          3
          4
          5
          6
          declare function progress_update(args: {
            block_ids: Array<string>;
            message: string;
            page_id: string;
            text_ranges?: Array<{ block_id: string; end_utf16: number; start_utf16: number; }> | null;
          }): Promise<CallToolResult<{ expires_at: string | null; status: "published" | "cleared"; } | PageFailure>>;
          
        • Behavior: Publishes expiring presence without a content edit or comment. Omitted text_ranges preserves current highlights, an empty array clears them, and empty block_ids with an empty message clears presence.
      • codex_apps.chatgpt_space.read_page - Read Page content, metadata, selected blocks, or excerpts with exact identifiers and guards for later editing.

        • Binding: tools.mcp__codex_apps__chatgpt_space_read_page.
        • TypeScript contract:
          ⎗
          ✓
          declare function read_page(args: {
            block_ids?: Array<string> | null;
            context_blocks?: number;
            context_lines?: number;
            include_content?: boolean;
            page_id: string;
            search?: Array<string> | null;
            stream_kind?: "content" | "scratch";
            view?: "editing" | "full" | "excerpts";
          }): Promise<CallToolResult<{
            content: {
              blocks: Array<{
                hash: string;
                id: string;
                kind: "markdown" | "agent_instructions";
                last_modified?: { [key: string]: unknown; } | null;
                markdown: string;
                metadata?: { [key: string]: unknown; } | null;
              }>;
              checkpoint_id?: string | null;
              markdown?: string;
              page_id: string;
              schema_version: 1 | 2;
              through_sequence?: number;
              title: string;
              title_hash: string;
            } | null;
            metadata: {
              drive_scope?: "space" | "personal" | "workspace_private" | null;
              owner_workspace_id?: string | null;
              page_id: string;
              stream_kind?: "content" | "scratch";
              url: string;
            };
            selection?: {
              blocks: Array<{
                block_id: string;
                block_index: number;
                query_indices: Array<number>;
                roles: Array<"match" | "context" | "instruction">;
              }>;
              context_blocks: number;
              matched_block_count: number;
              missing_block_ids: Array<string>;
              mode: "search" | "block_ids";
              page_block_count: number;
              query_matches: Array<{ block_ids: Array<string>; matched_block_count: number; query_index: number; }>;
              returned_block_count: number;
              selection_complete: boolean;
              whole_page_complete: boolean;
            };
            view?: "editing";
          } | {
            block_excerpts: Array<{
              block_index: number;
              complete: boolean;
              hash: string;
              id: string;
              kind: "markdown";
              metadata?: { [key: string]: unknown; } | null;
              total_lines: number;
              windows: Array<{
                end_line: number;
                includes_prefix: boolean;
                query_indices: Array<number>;
                start_line: number;
                text: string;
              }>;
            }>;
            content: {
              blocks: Array<{
                hash: string;
                id: string;
                kind: "markdown" | "agent_instructions";
                last_modified?: { [key: string]: unknown; } | null;
                markdown: string;
                metadata?: { [key: string]: unknown; } | null;
              }>;
              checkpoint_id?: string | null;
              markdown?: string;
              page_id: string;
              schema_version: 1 | 2;
              through_sequence?: number;
              title: string;
              title_hash: string;
            };
            excerpt_selection: {
              blocks: Array<{
                block_id: string;
                block_index: number;
                query_matches: Array<{ occurrence_count: number; query_index: number; }>;
                representation: "complete" | "excerpt";
                roles: Array<"match" | "context" | "instruction">;
              }>;
              context_blocks: number;
              context_lines: number;
              match_coverage_complete: true;
              page_block_count: number;
              prefix_lines: 2;
              query_matches: Array<{ matched_block_count: number; occurrence_count: number; query_index: number; }>;
              returned_block_count: number;
              whole_page_complete: boolean;
            };
            metadata: {
              drive_scope?: "space" | "personal" | "workspace_private" | null;
              owner_workspace_id?: string | null;
              page_id: string;
              stream_kind?: "content" | "scratch";
              url: string;
            };
            view: "excerpts";
          } | PageFailure>>;
          
        • Behavior: search accepts 1–16 case-sensitive literals totaling at most 4 KiB; block_ids accepts 1–64 observed IDs. Selectors are mutually exclusive. Excerpts require search; block_ids requires editing view. Unselected editing is limited to 128 KiB.
        • Variants:

          • view: "editing" returns complete canonical blocks with IDs and hashes, subject to the unselected read limit.
          • view: "full" returns the full representation without selectors; search selects editing or excerpt reads and block_ids selects editing reads.
          • view: "excerpts" requires search and returns line windows with full-block hashes and explicit completeness.
          • include_content: false returns metadata with content: null; selector and context fields are omitted.
      • codex_apps.chatgpt_space.read_page_changes - Retrieve Page diffs, affected block identities, actors, and optional comments since a previously observed sequence.

        • Binding: tools.mcp__codex_apps__chatgpt_space_read_page_changes.
        • TypeScript contract:
          ⎗
          ✓
          declare function read_page_changes(args: {
            after_sequence?: number | null;
            include_comments?: boolean;
            max_chars?: number;
            page_id: string;
            stream_kind?: "content" | "scratch";
          }): Promise<CallToolResult<{
            after_sequence: number;
            changed_blocks: Array<{ hash: string; id: string; kind: "markdown" | "agent_instructions"; }>;
            changes: Array<{
              actor_summary: {
                account_user_id?: string | null;
                actor_type: string;
                agent_kind?: string | null;
                conversation_id?: string | null;
                tool_call_id?: string | null;
                turn_id?: string | null;
              };
              affected_block_ids: Array<string>;
              committed_at: string;
              deleted_block_ids: Array<string>;
              own_edit: false;
              sequence: number;
              update_id: string;
            }>;
            comments?: Array<CommentThread>;
            deleted_block_ids: Array<string>;
            markdown_diff: string;
            page_id: string;
            reason?: string;
            references?: Array<{
              byte_size: number | null;
              metadata_available: boolean;
              mime_type: string | null;
              reference: string;
            }>;
            references_truncated?: boolean;
            resync_required: boolean;
            through_sequence: number;
            title?: string;
            title_hash?: string;
            truncated: boolean;
          } | PageFailure>>;
          
        • Behavior: after_sequence comes from an observed read guard. Missing or compacted history returns resync_required. Changed instruction blocks also require a fresh Page read before editing.
      • codex_apps.chatgpt_space.read_page_reference - Read authorized Page-linked images, text sources, or extracted document text with original byte metadata and digest.

        • Binding: tools.mcp__codex_apps__chatgpt_space_read_page_reference.
        • TypeScript contract:
          ⎗
          ✓
          declare function read_page_reference(args: { page_id: string; reference: string; }): Promise<CallToolResult<{
            byte_size: number;
            kind: "image" | "text";
            mime_type: string;
            page_id: string;
            reference: string;
            sha256: string;
            text: string | null;
            text_byte_size?: number | null;
            text_representation?: "source" | "extracted" | null;
          } | PageFailure>>;
          
        • Behavior: Raster images are bounded at 10 MiB; UTF-8 source and extracted PDF/Office text at 1 MiB. Document inputs are at most 10 MiB. References are opaque Page-linked identifiers, not URLs or filesystem paths.
      • codex_apps.chatgpt_space.read_page_transcript - Retrieve authorized meeting transcripts associated with meeting-note Pages, including available live or paginated final entries.

        • Binding: tools.mcp__codex_apps__chatgpt_space_read_page_transcript.
        • TypeScript contract:
          ⎗
          ✓
          declare function read_page_transcript(args: { cursor?: string | null; page_id: string; }): Promise<CallToolResult<{
            page_id: string;
            transcript: {
              earlierContentOmitted?: boolean;
              entries: Array<{
                continuesAfter?: boolean;
                endSeconds?: number | null;
                message: string;
                offsetSeconds?: number | null;
                speaker?: string | null;
                startCharacter?: number;
                timestamp?: string | null;
                timingGranularity?: "source_segment" | null;
              }>;
              language?: string | null;
              nextCursor?: string | null;
              source?: string | null;
              status: "pending" | "preliminary" | "final" | "unavailable";
            } | null;
          } | PageFailure>>;
          
        • Behavior: Meeting-note Pages resolve their own independently authorized transcript. Final responses support nextCursor pagination; live responses may omit earlier content without continuation. Preliminary text is an incomplete mutable snapshot.
      • codex_apps.chatgpt_space.reply_page_comment - Post one reply to an existing Page comment thread using identifiers retained from prior authorized reads.

        • Binding: tools.mcp__codex_apps__chatgpt_space_reply_page_comment.
        • TypeScript contract:
          ⎗
          ✓
          declare function reply_page_comment(args: { body: string; page_id: string; thread_id: string; }): Promise<CallToolResult<CommentMutation | PageFailure>>;
          
        • Behavior: Adds one reply to an existing observed thread. Authenticated context supplies authorship; unknown commit outcomes require reconciliation through list_page_comments.
      • codex_apps.chatgpt_space.run_page_auto_update - Request an immediate run of an enabled Page controller without changing its saved recurring schedule.

        • Binding: tools.mcp__codex_apps__chatgpt_space_run_page_auto_update.
        • TypeScript contract:
          ⎗
          ✓
          1
          2
          3
          4
          5
          declare function run_page_auto_update(args: {
            expected_controller_id?: string | null;
            idempotency_key: string;
            page_id: string;
          }): Promise<CallToolResult<{ [key: string]: unknown; } | PageFailure>>;
          
        • Behavior: Requires an enabled owned controller and Page edit access. The idempotency key identifies the run request; acceptance does not confirm completion or alter the schedule.
      • codex_apps.chatgpt_space.search_sharing_recipients - Find eligible users and groups for a Page or Space using single or batched recipient searches.

        • Binding: tools.mcp__codex_apps__chatgpt_space_search_sharing_recipients.
        • TypeScript contract:
          ⎗
          ✓
          1
          2
          3
          4
          5
          6
          7
          declare function search_sharing_recipients(args: {
            limit?: number;
            page_id?: string | null;
            queries?: Array<string> | null;
            query?: string | null;
            space_id?: string | null;
          }): Promise<CallToolResult<{ [key: string]: unknown; } | { [key: string]: unknown; } | PageFailure>>;
          
        • Behavior: Exactly one Page or Space target is required. query performs one search; queries supports up to fifty ordered searches. Recipient IDs originate in authorized results.
        • Variants:

          • Provide exactly one of page_id or space_id.
          • Use query for one search or queries for up to fifty ordered searches; do not supply both.
          • The generic return declaration does not publish the detailed recipient record shape.
      • codex_apps.chatgpt_space.set_page_auto_update - Create, enable, or disable a Page's owned auto-update controller and manage its linked worker state.

        • Binding: tools.mcp__codex_apps__chatgpt_space_set_page_auto_update.
        • TypeScript contract:
          ⎗
          ✓
          1
          2
          3
          4
          5
          declare function set_page_auto_update(args: {
            idempotency_key?: string | null;
            is_enabled: boolean;
            page_id: string;
          }): Promise<CallToolResult<{ [key: string]: unknown; } | PageFailure>>;
          
        • Behavior: Enabling without a controller creates and schedules one with an idempotency key. Disabling detaches the controller and attempts to pause linked workers; saved tasks and worker attachments remain.
      • codex_apps.chatgpt_space.trash_page - Move a requested Page and its nested descendants into Trash using the exact observed Page identifier.

        • Binding: tools.mcp__codex_apps__chatgpt_space_trash_page.
        • TypeScript contract:
          ⎗
          ✓
          1
          2
          3
          4
          declare function trash_page(args: { page_id: string; }): Promise<CallToolResult<{
            page_id: string;
            trashed: true;
          } | PageFailure>>;
          
        • Behavior: Moves the target Page and nested descendants to Trash.
      • codex_apps.chatgpt_space.update_page_sharing - Change a Page's direct collaborator or workspace grants using verified recipients and explicitly requested access roles.

        • Binding: tools.mcp__codex_apps__chatgpt_space_update_page_sharing.
        • TypeScript contract:
          ⎗
          ✓
          declare function update_page_sharing(args: {
            add_or_replace?: Array<{
              id: string;
              role: "viewer" | "commenter" | "editor";
              type: "user" | "workspace_group";
            } | { id: string; role: "viewer" | "editor"; type: "workspace"; }>;
            page_id: string;
            remove?: Array<{ id: string; type: "user" | "workspace_group" | "workspace"; }>;
          }): Promise<CallToolResult<{ sharing_available: true; workspace_id?: string | null; } | {
            [key: string]: unknown;
          } | PageFailure>>;
          
        • Behavior: Requires explicit access-change intent, sharing availability, a current sharing read, and verified recipients. One change is allowed per call. Direct grants change; inherited grants retain their source.
        • Variants:

          • add_or_replace grants or replaces one direct user, workspace-group, or workspace role; remove revokes one direct grant.
          • User/group roles include viewer, commenter, editor; workspace roles include viewer or editor.
          • The runtime permits one Page sharing change per call despite the array-typed arguments.
      • codex_apps.chatgpt_space.update_space_sharing - Apply requested whole-Space sharing changes in bounded batches while preserving owners and reporting individual recipient outcomes.

        • Binding: tools.mcp__codex_apps__chatgpt_space_update_space_sharing.
        • TypeScript contract:
          ⎗
          ✓
          declare function update_space_sharing(args: {
            add_or_replace?: Array<{
              id: string;
              role: "viewer" | "commenter" | "editor";
              type: "user" | "workspace_group";
            } | { id: string; role: "viewer" | "editor"; type: "workspace"; }>;
            remove?: Array<{ id: string; type: "user" | "workspace_group" | "workspace"; }>;
            space_id: string;
          }): Promise<CallToolResult<{
            scope: "space_and_backing_library_folder";
            sharing_available: true;
            workspace_id?: string | null;
          } | { [key: string]: unknown; } | { [key: string]: unknown; } | { [key: string]: unknown; }>>;
          
        • Behavior: Accepts 1–50 requested recipient changes. Results are per-recipient and non-atomic; submitted or unchanged does not establish completion. Owner grants remain; descendant and group membership access follow the changed grant.
        • Variants:

          • Use add_or_replace and/or remove for one to fifty total verified recipient changes.
          • User/group roles include viewer, commenter, editor; workspace roles include viewer or editor.
          • Per-recipient outcomes are not atomic; the published declaration leaves portions of the result as unknown records.
      • codex_apps.chatgpt_space.upload_artifact_images - Upload workspace images for native Spaces artifacts and return references usable in subsequent artifact editing callbacks.

        • Binding: tools.mcp__codex_apps__chatgpt_space_upload_artifact_images.
        • TypeScript contract:
          ⎗
          ✓
          1
          2
          3
          4
          5
          6
          declare function upload_artifact_images(args: { page_id: string; paths: Array<string>; }): Promise<CallToolResult<{
            images: Array<{ path: string; reference?: string | null; status: "uploaded" | "unknown"; }>;
            message?: string;
          } | {
            error: { code?: string | null; commit_status?: string | null; message: string; retryable?: boolean | null; };
          }>>;
          
        • Behavior: Accepts 1–16 absolute workspace paths: PNG, JPEG, GIF, or WebP, at most 10 MiB each and 16 MiB total. Uploads produce references without editing the native artifact.
      • codex_apps.chatgpt_space.write_page_reference - Upload a selected file to a Page's Files destination and return its persistent reference and image Markdown.

        • Binding: tools.mcp__codex_apps__chatgpt_space_write_page_reference.
        • TypeScript contract:
          ⎗
          ✓
          declare function write_page_reference(args: { file: string; page_id: string; title?: string | null; }): Promise<CallToolResult<{
            byte_size: number;
            file_access_confirmed: boolean;
            file_name: string;
            inserted: false;
            is_image: boolean;
            markdown: string | null;
            mime_type: string;
            next_step: string;
            page_id: string;
            reference: string;
            sha256: string;
          } | PageFailure>>;
          
        • Behavior: Accepts one selected file up to 10 MiB. Confirmed destination access permits a persistent reference and native image Markdown; the Page content is not automatically edited.
    • OpenAI Library — codex_apps.library (4 methods)

      • codex_apps.library.create_library_file - Persist one local file or a bounded file batch as new Library items with returned version metadata.

        • Binding: tools.mcp__codex_apps__library_create_library_file.
        • TypeScript contract:
          ⎗
          ✓
          1
          2
          3
          4
          5
          6
          declare function create_library_file(args: {
            directory_id?: string | null;
            file?: string;
            files?: Array<string>;
            library_artifact_type?: "other" | "image" | "image_gen" | "report" | "sheet" | "slides" | null;
          }): Promise<CallToolResult>;
          
        • Behavior: Exactly one of file or files is accepted. A batch contains 1–20 absolute paths. Returned identities and extended attributes associate each original file with its persisted version.
        • Variants:

          • file creates one local file; files creates a batch of one to twenty paths. Supply exactly one form.
          • Results can include file identity, version information, and local extended attributes; the declaration leaves the payload untyped.
      • codex_apps.library.finalize_uploads - Finalize prepared file transfers as Library creations or replacements while preserving returned upload session data unchanged.

        • Binding: tools.mcp__codex_apps__library_finalize_uploads.
        • TypeScript contract:
          ⎗
          ✓
          declare function finalize_uploads(args: {
            uploads: Array<{
              directory_id?: string | null;
              expected_current_version?: number | null;
              file_id: string;
              file_name: string;
              file_size_bytes?: number | null;
              library_artifact_type?: "other" | "image" | "image_gen" | "report" | "sheet" | "slides" | null;
              library_file_id?: string | null;
              method?: "PUT";
              mime_type?: string | null;
              pdf_c2pa_upload?: boolean;
              purpose: "create_library_file" | "replace_library_file";
              required_headers?: { [key: string]: string; };
              shared_library_upload?: true | null;
              store_in_library: boolean;
              upload_session_id: string;
              upload_url?: string | null;
              version_reason?: string | null;
              workspace_path?: string | null;
            }>;
          }): Promise<CallToolResult>;
          
        • Behavior: Accepts 1–20 opaque prepared upload objects, each preserving exactly one transfer source: upload_url or workspace_path. Replacement items retain the existing Library identity and applicable version guard.
        • Variants:

          • Each item preserves exactly one prepared transfer source, upload_url or workspace_path.
          • Create and replacement purposes share this endpoint; replacements additionally retain the identified Library file.
          • Per-item creation or replacement metadata is returned inside the generic tool envelope.
      • codex_apps.library.prepare_uploads - Prepare bounded file upload sessions for new Library items or version-checked replacements of existing stored files.

        • Binding: tools.mcp__codex_apps__library_prepare_uploads.
        • TypeScript contract:
          ⎗
          ✓
          declare function prepare_uploads(args: {
            uploads: Array<{
              expected_current_version?: number | null;
              file_name: string;
              file_size_bytes?: number | null;
              library_artifact_type?: "other" | "image" | "image_gen" | "report" | "sheet" | "slides" | null;
              library_file_id?: string | null;
              mime_type?: string | null;
              purpose: "create_library_file" | "replace_library_file";
              workspace_path?: string | null;
            }>;
          }): Promise<CallToolResult>;
          
        • Behavior: Prepares 1–20 new or replacement files. A returned workspace_path denotes completed transfer; otherwise a prepared upload URL supplies the transfer destination. Shared replacements require identity, expected version, and exact size.
        • Variants:

          • purpose: "create_library_file" prepares a new item; "replace_library_file" prepares a version of an existing item.
          • Shared replacements require the existing file ID, expected version, and exact byte size.
          • A returned workspace_path means transfer already completed; otherwise use the prepared upload route.
      • codex_apps.library.replace_library_file - Replace an identified Library file with local content while retaining its identity and optional version concurrency guard.

        • Binding: tools.mcp__codex_apps__library_replace_library_file.
        • TypeScript contract:
          ⎗
          ✓
          1
          2
          3
          4
          5
          6
          7
          declare function replace_library_file(args: {
            directory_id?: string | null;
            expected_current_version?: number | null;
            file: string;
            library_file_id: string;
            version_reason?: string | null;
          }): Promise<CallToolResult>;
          
        • Behavior: Replaces bytes for the same exact Library file ID. A supplied expected_current_version guards against intervening changes; returned extended attributes identify the persisted replacement version.
    • Personal Context — codex_apps.personal_context (1 method)

      • codex_apps.personal_context.search - Retrieve relevant user context from prior interactions and connected sources when it materially changes the current response.

        • Binding: tools.mcp__codex_apps__personal_context_search.
        • TypeScript contract:
          ⎗
          ✓
          1
          2
          3
          4
          declare function search(args: { query: string; }): Promise<CallToolResult<{
            error?: string | null;
            messages: Array<{ author_role: string; content: string; }>;
          }>>;
          
        • Behavior: Retrieves relevant personal context from prior interactions and connected sources when that unseen context affects the current response.
    • Pets — codex_apps.pets (11 methods)

      • codex_apps.pets.adopt - Install an owned copy of a shared ChatGPT pet from its supplied opaque public sharing identifier.

        • Binding: tools.mcp__codex_apps__pets_adopt.
        • TypeScript contract:
          ⎗
          ✓
          declare function adopt(args: { shared_pet_id: string; }): Promise<CallToolResult>;
          
        • Behavior: A sharepet_ identifier, optionally extracted from its sharing URL, creates a new owned copy without disclosing the original owner's identity.
      • codex_apps.pets.create_pet - Create a custom Work pet from a validated upload session without automatically making that pet active.

        • Binding: tools.mcp__codex_apps__pets_create_pet.
        • TypeScript contract:
          ⎗
          ✓
          declare function create_pet(args: { description?: string | null; name: string; upload_session_id: string; }): Promise<CallToolResult>;
          
        • Behavior: Consumes a completed upload session and performs validation, scanning, and moderation. The upload session is the idempotency key; creation does not select the pet.
      • codex_apps.pets.delete_pet - Permanently remove one explicitly requested owned custom pet and its stored sprite sheet from the account.

        • Binding: tools.mcp__codex_apps__pets_delete_pet.
        • TypeScript contract:
          ⎗
          ✓
          declare function delete_pet(args: { pet_id: string; }): Promise<CallToolResult>;
          
        • Behavior: Requires an explicit deletion request for an owned custom pet. Built-in pets are not deletable.
      • codex_apps.pets.get_pet_download_link - Retrieve a sprite-sheet download URL for a built-in or owned custom pet using its stable identifier.

        • Binding: tools.mcp__codex_apps__pets_get_pet_download_link.
        • TypeScript contract:
          ⎗
          ✓
          declare function get_pet_download_link(args: { pet_id: string; }): Promise<CallToolResult>;
          
        • Behavior: Uses stable pet identity. Built-in sprite URLs are static; custom sprite URLs are short-lived.
      • codex_apps.pets.list_pets - List built-in and custom pet metadata with the active identifier and bounded pagination for additional pets.

        • Binding: tools.mcp__codex_apps__pets_list_pets.
        • TypeScript contract:
          ⎗
          ✓
          declare function list_pets(args: { cursor?: string | null; limit?: number; }): Promise<CallToolResult>;
          
        • Behavior: Returns at most twenty metadata records per page and the active pet identifier. Image URLs require get_pet_download_link.
      • codex_apps.pets.prepare_pet_upload - Validate and transfer a supported pet sprite sheet, returning an upload session for creation or replacement.

        • Binding: tools.mcp__codex_apps__pets_prepare_pet_upload.
        • TypeScript contract:
          ⎗
          ✓
          declare function prepare_pet_upload(args: { file: string; }): Promise<CallToolResult>;
          
        • Behavior: Requires a valid transparent PNG/WebP sheet. Supported sizes are 1536×1872 (v1) or 1536×2288 (v2), using 192×208 cells. Returns a session for creation or artwork replacement.
      • codex_apps.pets.select_pet - Make a built-in or owned custom pet active, or disable the animated companion with the default identifier.

        • Binding: tools.mcp__codex_apps__pets_select_pet.
        • TypeScript contract:
          ⎗
          ✓
          declare function select_pet(args: { pet_id: string; }): Promise<CallToolResult>;
          
        • Behavior: An owned or built-in pet ID activates that companion. The default identifier disables the animated companion.
        • Variants:

          • A stable built-in or owned custom pet_id selects that companion.
          • pet_id: "default" disables the animated companion instead.
      • codex_apps.pets.share_pet - Create a sharing link for an owned custom pet after the user confirms the applicable audience.

        • Binding: tools.mcp__codex_apps__pets_share_pet.
        • TypeScript contract:
          ⎗
          ✓
          declare function share_pet(args: { pet_id: string; }): Promise<CallToolResult>;
          
        • Behavior: Requires explicit confirmation of the sharing audience for an owned custom pet. Personal links are public; enterprise links use workspace sharing rules. The snapshot contains name, description, and artwork.
      • codex_apps.pets.unshare_pet - Invalidate an owned custom pet's existing sharing link while preserving the pet and its stored sprite sheet.

        • Binding: tools.mcp__codex_apps__pets_unshare_pet.
        • TypeScript contract:
          ⎗
          ✓
          declare function unshare_pet(args: { pet_id: string; }): Promise<CallToolResult>;
          
        • Behavior: Requires an explicit unshare request. Invalidates the current share URL without deleting the pet.
      • codex_apps.pets.update_pet - Change an owned pet's name, description, or sprite sheet while preserving fields omitted from the update.

        • Binding: tools.mcp__codex_apps__pets_update_pet.
        • TypeScript contract:
          ⎗
          ✓
          1
          2
          3
          4
          declare function update_pet(args: {
            pet_id: string;
            updates: { description?: string | null; name?: string | null; upload_session_id?: string | null; };
          }): Promise<CallToolResult>;
          
        • Behavior: Omitted fields retain their values; null description clears it. A completed upload session replaces artwork, and the same session identifies a retry after an uncertain outcome.
        • Variants:

          • Omit update fields to preserve them; description: null clears that description.
          • A supplied upload_session_id replaces artwork through an already prepared upload session.
      • codex_apps.pets.validate_pet_spritesheet - Check sprite-sheet dimensions, transparency, required artwork, and unused cells before preparing a custom pet upload session.

        • Binding: tools.mcp__codex_apps__pets_validate_pet_spritesheet.
        • TypeScript contract:
          ⎗
          ✓
          declare function validate_pet_spritesheet(args: { file: string; }): Promise<CallToolResult>;
          
        • Behavior: Reports zero-indexed row/frame errors for dimensions, missing art, opacity, and unused cells. This preflight creates no upload session and performs no scanning, moderation, or pet creation.
    • Plugin Management — codex_apps.plugin_management (6 methods)

      • codex_apps.plugin_management.get_app_permissions - Inspect a named plugin's permission settings and whether its behavior inherits the account's global permission defaults.

        • Binding: tools.mcp__codex_apps__plugin_management_get_app_permissions.
        • TypeScript contract:
          ⎗
          ✓
          declare function get_app_permissions(args: { app_id: string; }): Promise<CallToolResult>;
          
        • Behavior: A target identifies one named plugin. Returns its global/default and plugin-specific permission settings; this is distinct from OAuth scopes or administrator access.
      • codex_apps.plugin_management.get_plugin_dependencies - Resolve a plugin's declared canonical dependencies and report their visibility, installation policy, and current installed status.

        • Binding: tools.mcp__codex_apps__plugin_management_get_plugin_dependencies.
        • TypeScript contract:
          ⎗
          ✓
          declare function get_plugin_dependencies(args: { plugin_reference: string; }): Promise<CallToolResult>;
          
        • Behavior: Accepts an exact plugin ID or name@marketplace reference. Returns canonical dependency metadata, user-aware status, installation policy, and installed state without connecting anything.
      • codex_apps.plugin_management.search_plugins - Discover directory plugins by provider names or capability keywords, including user-aware availability and installed state metadata.

        • Binding: tools.mcp__codex_apps__plugin_management_search_plugins.
        • TypeScript contract:
          ⎗
          ✓
          declare function search_plugins(args: { limit?: number | null; query: string; }): Promise<CallToolResult>;
          
        • Behavior: limit is 1–50, default fifty. Queries use provider or capability terms. Results include availability and installed state, provide no exhaustive enumeration, and have no continuation cursor.
      • codex_apps.plugin_management.suggest_plugins - Offer eligible unconnected plugins using exact directory references so users can explicitly initiate the required connection.

        • Binding: tools.mcp__codex_apps__plugin_management_suggest_plugins.
        • TypeScript contract:
          ⎗
          ✓
          declare function suggest_plugins(args: { plugin_ids: Array<string>; }): Promise<CallToolResult>;
          
        • Behavior: Accepts up to ten exact eligible plugin references. Installed, pending, or recently suggested plugins are ineligible unless the applicable explicit request permits re-suggestion; connection remains a user action.
      • codex_apps.plugin_management.uninstall_app - Remove explicitly identified ChatGPT plugins and return each requested uninstall result without choosing ambiguous targets automatically.

        • Binding: tools.mcp__codex_apps__plugin_management_uninstall_app.
        • TypeScript contract:
          ⎗
          ✓
          declare function uninstall_app(args: { app_ids: Array<string>; reason?: string | null; }): Promise<CallToolResult>;
          
        • Behavior: Requires exact explicitly requested targets. Returns an outcome for each plugin; disabling and uninstalling are separate operations.
      • codex_apps.plugin_management.update_app_permissions - Apply explicitly requested global permission defaults or named plugin overrides using the published supported permission modes.

        • Binding: tools.mcp__codex_apps__plugin_management_update_app_permissions.
        • TypeScript contract:
          ⎗
          ✓
          declare function update_app_permissions(args: {
            app_id?: string | null;
            reason?: string | null;
            updates: {
              app_permissions?: Array<{
                setting?: "permission_mode";
                value: "inherit" | "always_ask" | "ask_before_writes" | "review_important_actions" | "full_access";
              }> | null;
              global_permissions?: Array<{
                setting?: "permission_mode";
                value: "always_ask" | "ask_before_writes" | "review_important_actions" | "full_access";
              }> | null;
            };
          }): Promise<CallToolResult>;
          
        • Behavior: Global-only changes omit app_id; plugin overrides require one exact target. A combined call applies the global update first. inherit exists only for plugin overrides.
        • Variants:

          • global_permissions changes the account default; app_permissions with app_id changes one plugin override.
          • A call containing both applies the global change first; inherit is valid only for plugin overrides.
    • Sites — codex_apps.sites (25 methods)

      • codex_apps.sites.add_custom_domain - Attach a custom domain to a published Site and return required routing and domain validation records.

        • Binding: tools.mcp__codex_apps__sites_add_custom_domain.
        • TypeScript contract:
          ⎗
          ✓
          declare function add_custom_domain(args: { hostname: string; project_id: string; }): Promise<CallToolResult<CustomDomain>>;
          
        • Behavior: Requires a published Site and bare hostname. Returns apex A targets, a subdomain CNAME target, validation records, and domain/TLS status.
      • codex_apps.sites.change_site_slug - Request a change to a Site's public URL label and expose its asynchronous slug-change status.

        • Binding: tools.mcp__codex_apps__sites_change_site_slug.
        • TypeScript contract:
          ⎗
          ✓
          declare function change_site_slug(args: { project_id: string; slug: string; }): Promise<CallToolResult<{
            auth_client_id: string | null;
            created_at: string;
            current_live_url: string | null;
            current_preview_url: string | null;
            description: string | null;
            disabled_by?: "workspace_admin" | "openai" | null;
            id: string;
            latest_edit_context?: { chatgpt_conversation_id?: string | null; codex_thread_id?: string | null; } | null;
            latest_version_number: number;
            screenshot_url: string | null;
            slug: string;
            slug_change?: { requested_slug: string; status: "pending" | "complete"; } | null;
            status: "creating" | "active" | "suspended" | "deleting";
            title: string;
            updated_at: string;
          }>>;
          
        • Behavior: The slug change can remain pending. get_site observes completion without resubmitting the mutation.
      • codex_apps.sites.create_schedule - Create and link a requested scheduled cloud task to a published Site using its retained request identifier.

        • Binding: tools.mcp__codex_apps__sites_create_schedule.
        • TypeScript contract:
          ⎗
          ✓
          1
          2
          3
          4
          5
          declare function create_schedule(args: {
            project_id: string;
            request_id: string;
            task: { prompt: string; schedule: string; timezone: string; title: string; };
          }): Promise<CallToolResult<{ [key: string]: unknown; }>>;
          
        • Behavior: Requires scheduling intent and available Site automation metadata. request_id comes from get_site.schedule_request_id; the same ID and task identify retries.
      • codex_apps.sites.create_site - Register a new Site and return its project metadata and available source repository provisioning information.

        • Binding: tools.mcp__codex_apps__sites_create_site.
        • TypeScript contract:
          ⎗
          ✓
          declare function create_site(args: {
            creation_intent?: "user_requested" | "proactive" | "unknown";
            description?: string | null;
            enable_plugins?: boolean | null;
            publish_on_push?: "private" | null;
            slug: string;
            title: string;
          }): Promise<CallToolResult<{
            auth_client_id: string | null;
            created_at: string;
            current_live_url: string | null;
            current_preview_url: string | null;
            description: string | null;
            disabled_by?: "workspace_admin" | "openai" | null;
            expected_url?: string | null;
            id: string;
            latest_edit_context?: { chatgpt_conversation_id?: string | null; codex_thread_id?: string | null; } | null;
            latest_version_number: number;
            screenshot_url: string | null;
            slug: string;
            source_repository_credential?: {
              app_repository_id: string;
              auth_mode: string;
              branch: string;
              provider: string;
              publish_on_push_accepted?: boolean;
              publish_on_push_expires_at?: string | null;
              remote_url: string;
              repository: string;
              token: string;
              token_expires_at: string;
            } | {
              app_repository_id: string;
              auth_mode?: "work_proxy";
              branch: string;
              provider: string;
              publish_on_push_accepted?: boolean;
              publish_on_push_expires_at?: string | null;
              remote_url: string;
              repository: string;
            } | null;
            status: "creating" | "active" | "suspended" | "deleting";
            title: string;
            updated_at: string;
          }>>;
          
        • Behavior: Registers a new project without creating local source. Existing hosting project IDs identify the same Site. Provisioning may return token-based credentials or work_proxy authentication.
      • codex_apps.sites.create_source_repository_write_credential - Issue temporary source repository write access when Site provisioning omitted credentials or earlier access has expired.

        • Binding: tools.mcp__codex_apps__sites_create_source_repository_write_credential.
        • TypeScript contract:
          ⎗
          ✓
          declare function create_source_repository_write_credential(args: {
            project_id: string;
            publish_on_push?: "private" | null;
          }): Promise<CallToolResult<{
            app_repository_id: string;
            auth_mode: string;
            branch: string;
            provider: string;
            publish_on_push_accepted?: boolean;
            publish_on_push_expires_at?: string | null;
            remote_url: string;
            repository: string;
            token: string;
            token_expires_at: string;
          } | {
            app_repository_id: string;
            auth_mode?: "work_proxy";
            branch: string;
            provider: string;
            publish_on_push_accepted?: boolean;
            publish_on_push_expires_at?: string | null;
            remote_url: string;
            repository: string;
          }>>;
          
        • Behavior: Returns temporary repository write access for the same Site. work_proxy authentication has no executor token; publication-on-push is active only when the response explicitly accepts it.
      • codex_apps.sites.deploy_private_site_version - Deploy an exact saved Site version when verified owner-only access permits the dedicated private publication route.

        • Binding: tools.mcp__codex_apps__sites_deploy_private_site_version.
        • TypeScript contract:
          ⎗
          ✓
          1
          2
          3
          4
          5
          declare function deploy_private_site_version(args: {
            project_id: string;
            tunnel_bindings?: Array<{ binding_alias: string; tunnel_id: string; }> | null;
            version_id: string;
          }): Promise<CallToolResult<Deployment>>;
          
        • Behavior: Requires verified sole-owner access and an exact saved version ID. A supplied tunnel_bindings list replaces the desired tunnel set; omission preserves it. Returned deployment URLs are production URLs.
      • codex_apps.sites.deploy_site_version - Deploy an exact saved Site version to production while preserving the Site's currently authorized audience configuration.

        • Binding: tools.mcp__codex_apps__sites_deploy_site_version.
        • TypeScript contract:
          ⎗
          ✓
          1
          2
          3
          4
          5
          declare function deploy_site_version(args: {
            project_id: string;
            tunnel_bindings?: Array<{ binding_alias: string; tunnel_id: string; }> | null;
            version_id: string;
          }): Promise<CallToolResult<Deployment>>;
          
        • Behavior: Publishes an exact saved version for the existing audience. Source must already have a saved version; access configuration is unchanged by deployment.
      • codex_apps.sites.generate_siwc_bypass_token - Create or rotate a requested bearer token permitting API access through a Site's ChatGPT sign-in gate.

        • Binding: tools.mcp__codex_apps__sites_generate_siwc_bypass_token.
        • TypeScript contract:
          ⎗
          ✓
          1
          2
          3
          4
          declare function generate_siwc_bypass_token(args: { project_id: string; }): Promise<CallToolResult<{
            project_id: string;
            siwc_bypass_bearer_token: string;
          }>>;
          
        • Behavior: Requires an explicit bypass-token request. Creates or rotates the bearer token used in the OAI-Sites-Authorization header.
      • codex_apps.sites.get_deployment_status - Inspect a production deployment's status, published URL, saved version, and failure details using its deployment identifier.

        • Binding: tools.mcp__codex_apps__sites_get_deployment_status.
        • TypeScript contract:
          ⎗
          ✓
          1
          2
          3
          4
          5
          declare function get_deployment_status(args: {
            deployment_id: string;
            project_id: string;
            version_id?: string | null;
          }): Promise<CallToolResult<Deployment>>;
          
        • Behavior: The deployment ID determines its saved version; version_id is deprecated compatibility input. Nonterminal status is not successful publication.
      • codex_apps.sites.get_environment_variables - Read a Site's production environment entries, revision, and secret requirements separately from its local source configuration.

        • Binding: tools.mcp__codex_apps__sites_get_environment_variables.
        • TypeScript contract:
          ⎗
          ✓
          declare function get_environment_variables(args: { project_id: string; }): Promise<CallToolResult<SiteEnvironment>>;
          
        • Behavior: Reads production configuration separately from source files. Values marked secret may be withheld; revision identifies the active environment set.
      • codex_apps.sites.get_site - Read Site metadata, current audience, attached automations, and optional MCP connection settings for an identified project.

        • Binding: tools.mcp__codex_apps__sites_get_site.
        • TypeScript contract:
          ⎗
          ✓
          declare function get_site(args: { include_mcp_connection?: boolean; project_id: string; }): Promise<CallToolResult<{
            access_mode?: "public" | "admins_only" | "workspace_all" | "custom" | null;
            access_policy?: SiteAccessPolicy | null;
            attached_page_id?: string | null;
            auth_client_id: string | null;
            automations?: Array<{ id: string; is_enabled: boolean; schedule: string; timezone: string; title: string; }> | null;
            available_access_modes?: Array<"public" | "workspace_all" | "custom"> | null;
            created_at: string;
            current_live_url: string | null;
            current_preview_url: string | null;
            current_user_role?: "owner" | "editor" | null;
            description: string | null;
            disabled_by?: "workspace_admin" | "openai" | null;
            expected_url?: string | null;
            external_visitor_invites_enabled?: boolean | null;
            id: string;
            latest_edit_context?: { chatgpt_conversation_id?: string | null; codex_thread_id?: string | null; } | null;
            latest_version_number: number;
            mcp_connection?: { mcp_url: string; oauth_resource: string; plugin_id?: string | null; } | null;
            requires_byop?: boolean | null;
            schedule_request_id?: string | null;
            screenshot_url: string | null;
            siwc_bypass_bearer_token?: string | null;
            slug: string;
            source_repository_credential?: {
              app_repository_id: string;
              auth_mode: string;
              branch: string;
              provider: string;
              publish_on_push_accepted?: boolean;
              publish_on_push_expires_at?: string | null;
              remote_url: string;
              repository: string;
              token: string;
              token_expires_at: string;
            } | null;
            status: "creating" | "active" | "suspended" | "deleting";
            title: string;
            updated_at: string;
          }>>;
          
        • Behavior: Returns current project access and optional connection metadata. MCP settings require include_mcp_connection and a ready publication; metadata does not establish an installed or connected plugin.
        • Variants:

          • Set include_mcp_connection: true to request connection settings when the publication supports MCP.
          • A returned plugin reference indicates available metadata, not that a connection is installed or authorized.
      • codex_apps.sites.get_site_version - Retrieve a saved Site version's identifier, user-facing version number, source commit, and available archive provenance.

        • Binding: tools.mcp__codex_apps__sites_get_site_version.
        • TypeScript contract:
          ⎗
          ✓
          declare function get_site_version(args: { project_id: string; version_id: string; }): Promise<CallToolResult<SiteVersion>>;
          
        • Behavior: Returns a saved version and source provenance. A saved version is not necessarily the currently deployed version.
      • codex_apps.sites.get_site_worker_logs - Read bounded recent production Worker logs to diagnose deployed Site failures without changing or redeploying the website.

        • Binding: tools.mcp__codex_apps__sites_get_site_worker_logs.
        • TypeScript contract:
          ⎗
          ✓
          1
          2
          3
          4
          5
          6
          declare function get_site_worker_logs(args: {
            errors_only?: boolean;
            limit?: number;
            project_id: string;
            since_minutes?: number;
          }): Promise<CallToolResult<{ events: Array<{ [key: string]: unknown; }>; project_id: string; }>>;
          
        • Behavior: Defaults are errors_only=true, since_minutes=180, limit=25. Bounds are 1–10080 whole minutes and 1–100 events. The operation is read-only.
      • codex_apps.sites.list_custom_domains - List a Site's attached custom domains with routing targets, validation records, and current domain activation status.

        • Binding: tools.mcp__codex_apps__sites_list_custom_domains.
        • TypeScript contract:
          ⎗
          ✓
          1
          2
          3
          declare function list_custom_domains(args: { project_id: string; }): Promise<CallToolResult<{
            items: Array<CustomDomain>;
          }>>;
          
        • Behavior: Returns attached custom domain records, including routing, validation, activation, and TLS state.
      • codex_apps.sites.list_site_versions - List saved Site versions in reverse chronological order to inspect history or choose an existing deployment candidate.

        • Binding: tools.mcp__codex_apps__sites_list_site_versions.
        • TypeScript contract:
          ⎗
          ✓
          1
          2
          3
          4
          declare function list_site_versions(args: { cursor?: string | null; limit?: number; project_id: string; }): Promise<CallToolResult<{
            cursor?: string | null;
            items: Array<SiteVersion>;
          }>>;
          
        • Behavior: Returns newest-first saved versions. limit is 1–50, default twenty; the returned cursor continues the same project history.
      • codex_apps.sites.list_sites - List owned or shared editable Sites in the selected account, preserving requested access filters across pagination.

        • Binding: tools.mcp__codex_apps__sites_list_sites.
        • TypeScript contract:
          ⎗
          ✓
          declare function list_sites(args: {
            cursor?: string | null;
            include_editable?: boolean;
            limit?: number;
            role?: "owner" | "editor" | null;
          }): Promise<CallToolResult<{
            cursor?: string | null;
            items: Array<{
              access_mode?: "public" | "admins_only" | "workspace_all" | "custom" | null;
              access_policy?: SiteAccessPolicy | null;
              attached_page_id?: string | null;
              auth_client_id: string | null;
              available_access_modes?: Array<"public" | "workspace_all" | "custom"> | null;
              created_at: string;
              current_live_url: string | null;
              current_preview_url: string | null;
              current_user_role?: "owner" | "editor" | null;
              description: string | null;
              disabled_by?: "workspace_admin" | "openai" | null;
              expected_url?: string | null;
              id: string;
              latest_edit_context?: { chatgpt_conversation_id?: string | null; codex_thread_id?: string | null; } | null;
              latest_version_number: number;
              screenshot_url: string | null;
              slug: string;
              source_repository_credential?: {
                app_repository_id: string;
                auth_mode: string;
                branch: string;
                provider: string;
                publish_on_push_accepted?: boolean;
                publish_on_push_expires_at?: string | null;
                remote_url: string;
                repository: string;
                token: string;
                token_expires_at: string;
              } | null;
              status: "creating" | "active" | "suspended" | "deleting";
              title: string;
              updated_at: string;
            }>;
          }>>;
          
        • Behavior: Defaults to owned Sites, with role=editor for shared editable Sites. limit is 1–50, default twenty; continuation retains the same role and include_editable filters.
        • Variants:

          • Default discovery lists owned Sites; role: "editor" selects shared editable Sites.
          • Reuse the same role and include_editable filters when following the returned cursor.
      • codex_apps.sites.read_database_overview - Inspect exact live database bindings and user table names before requesting bounded read-only Site database rows.

        • Binding: tools.mcp__codex_apps__sites_read_database_overview.
        • TypeScript contract:
          ⎗
          ✓
          declare function read_database_overview(args: { binding_name?: string | null; project_id: string; }): Promise<CallToolResult<{
            bindings: Array<string>;
            model_projection: {
              omitted_bindings: number;
              omitted_project_id: boolean;
              omitted_selected_binding: boolean;
              omitted_tables: number;
              truncated: boolean;
            };
            project_id: string | null;
            selected_binding_name: string | null;
            tables: Array<string>;
          }>>;
          
        • Behavior: Returns exact bounded binding and user-table identifiers from a deployed D1 database. model_projection counts omitted identifiers; no arbitrary SQL interface is exposed.
      • codex_apps.sites.read_database_table_rows - Read a bounded page from an observed live database table using only the server's returned continuation offset.

        • Binding: tools.mcp__codex_apps__sites_read_database_table_rows.
        • TypeScript contract:
          ⎗
          ✓
          declare function read_database_table_rows(args: {
            binding_name?: string | null;
            limit?: number;
            offset?: number;
            project_id: string;
            table_name: string;
          }): Promise<CallToolResult<{
            binding_name: string;
            columns: Array<string>;
            has_more: boolean;
            limit: number;
            model_projection: {
              next_offset: number | null;
              omitted_columns: number;
              omitted_rows: number;
              truncated: boolean;
              truncated_values: number;
            };
            offset: number;
            project_id: string;
            rows: Array<{ [key: string]: unknown; }>;
            table_name: string;
          }>>;
          
        • Behavior: Requires exact names from read_database_overview. limit is at most twenty-five rows; offset is 0–10000 and continuation uses model_projection.next_offset.
      • codex_apps.sites.refresh_custom_domain_status - Refresh an attached custom domain's validation and TLS status using its exact Site and domain identifiers.

        • Binding: tools.mcp__codex_apps__sites_refresh_custom_domain_status.
        • TypeScript contract:
          ⎗
          ✓
          declare function refresh_custom_domain_status(args: { custom_domain_id: string; project_id: string; }): Promise<CallToolResult<CustomDomain>>;
          
        • Behavior: Refreshes validation and TLS state for an exact custom domain and Site.
      • codex_apps.sites.remove_custom_domain - Remove an identified custom domain from a Site and return the resulting domain record and status.

        • Binding: tools.mcp__codex_apps__sites_remove_custom_domain.
        • TypeScript contract:
          ⎗
          ✓
          declare function remove_custom_domain(args: { custom_domain_id: string; project_id: string; }): Promise<CallToolResult<CustomDomain>>;
          
        • Behavior: Detaches an exact custom domain and returns its resulting domain record.
      • codex_apps.sites.save_site_version - Save pushed Site source and optional build assets as a version without deploying that version to production.

        • Binding: tools.mcp__codex_apps__sites_save_site_version.
        • TypeScript contract:
          ⎗
          ✓
          declare function save_site_version(args: { archive?: string; commit_sha: string; project_id: string; }): Promise<CallToolResult<SiteVersion>>;
          
        • Behavior: commit_sha is the full pushed source-branch HEAD. archive contains build output or configured assets from that commit; remote build is the fallback when local packaging cannot complete.
      • codex_apps.sites.save_version_and_deploy_private - Save pushed Site source and deploy that exact version through the verified owner-only publication route.

        • Binding: tools.mcp__codex_apps__sites_save_version_and_deploy_private.
        • TypeScript contract:
          ⎗
          ✓
          1
          2
          3
          4
          5
          declare function save_version_and_deploy_private(args: {
            archive?: string;
            commit_sha: string;
            project_id: string;
          }): Promise<CallToolResult<Deployment>>;
          
        • Behavior: Combines saving and publishing the same pushed commit under verified owner-only access. A returned saved_version_id remains the deployment target after a partial failure.
      • codex_apps.sites.update_environment_variables - Set or remove selected production environment keys and create a new revision for subsequent Site deployment.

        • Binding: tools.mcp__codex_apps__sites_update_environment_variables.
        • TypeScript contract:
          ⎗
          ✓
          1
          2
          3
          4
          5
          declare function update_environment_variables(args: {
            project_id: string;
            remove?: Array<string> | null;
            set_values: Array<{ is_secret?: boolean; key: string; type?: "envvar"; value: string; }>;
          }): Promise<CallToolResult<SiteEnvironment>>;
          
        • Behavior: Only listed keys change. set_values and remove are disjoint, case-sensitive key sets. A saved-version deployment applies the new environment revision.
      • codex_apps.sites.update_site_access - Apply requested Site audience or collaborator changes while preserving owner access and omitted existing visitor configuration.

        • Binding: tools.mcp__codex_apps__sites_update_site_access.
        • TypeScript contract:
          ⎗
          ✓
          declare function update_site_access(args: {
            access_mode?: "public" | "workspace_all" | "custom" | null;
            allowed_tenant_group_ids?: Array<string> | null;
            allowed_user_emails?: Array<string> | null;
            allowed_workspace_group_ids?: Array<string> | null;
            editor_changes?: {
              add_editor_account_user_ids?: Array<string>;
              add_editor_group_ids?: Array<string>;
              remove_editor_account_user_ids?: Array<string>;
              remove_editor_group_ids?: Array<string>;
            } | null;
            project_id: string;
            viewer_changes?: {
              add_external_visitor_emails?: Array<string>;
              add_viewer_account_user_ids?: Array<string>;
              add_viewer_workspace_group_ids?: Array<string>;
              remove_external_visitor_emails?: Array<string>;
              remove_viewer_account_user_ids?: Array<string>;
              remove_viewer_workspace_group_ids?: Array<string>;
            } | null;
          }): Promise<CallToolResult<SiteAccessPolicy>>;
          
        • Behavior: Requires explicit access-change intent. Complete allowed_user_emails and incremental viewer_changes are mutually exclusive. External additions require owner invite eligibility; owner access remains.
        • Variants:

          • access_mode changes the audience only when requested; collaborator-only changes omit it.
          • Use complete allowed_user_emails or incremental viewer_changes, not both.
          • editor_changes and viewer lists use their explicitly published add/remove fields.
          • Group discovery requires list_available_access_groups, whose binding is not exposed.
      • codex_apps.sites.update_site_metadata - Change an identified Site's display title while preserving its public URL label and other project metadata.

        • Binding: tools.mcp__codex_apps__sites_update_site_metadata.
        • TypeScript contract:
          ⎗
          ✓
          declare function update_site_metadata(args: { project_id: string; title: string; }): Promise<CallToolResult<{
            auth_client_id: string | null;
            created_at: string;
            current_live_url: string | null;
            current_preview_url: string | null;
            description: string | null;
            disabled_by?: "workspace_admin" | "openai" | null;
            id: string;
            latest_edit_context?: { chatgpt_conversation_id?: string | null; codex_thread_id?: string | null; } | null;
            latest_version_number: number;
            screenshot_url: string | null;
            slug: string;
            status: "creating" | "active" | "suspended" | "deleting";
            title: string;
            updated_at: string;
          }>>;
          
        • Behavior: Updates the display title without changing the public URL slug.
  • Category not supplied

    • Automations — codex_apps.automations (7 methods)

      • codex_apps.automations.create - Create scheduled tasks or event watchers that run saved prompts at specified times or triggers.

        • Binding: tools.mcp__codex_apps__automations_create.
        • TypeScript contract:
          ⎗
          ✓
          declare function create(args: {
            default_timezone?: string | null;
            dtstart_offset_json?: string | null;
            prompt: string;
            schedule: string;
            timing_mode: "exact_schedule" | "flexible_schedule" | "condition_watch";
            title: string;
            triggers?: Array<{
              connector_type: "slack";
              params: {
                author_names?: Array<string> | null;
                author_user_ids?: Array<string> | null;
                channel_ids: Array<string>;
                channel_names?: Array<string> | null;
                include_thread_replies?: boolean;
              };
              webhook_name: "message";
            } | {
              connector_type: "microsoft_teams";
              params: {
                author_names?: Array<string> | null;
                author_user_ids?: Array<string> | null;
                channel_ids: Array<string>;
                channel_names?: Array<string> | null;
                channel_team_ids?: { [key: string]: string; };
                include_thread_replies?: boolean;
              };
              webhook_name: "message";
            } | {
              connector_type: "linear";
              params: {
                enable_updates?: boolean;
                label_match?: string | null;
                project?: string | null;
                project_name?: string | null;
                team: string;
                team_name?: string | null;
                title_match?: string | null;
              };
              webhook_name: "issue";
            } | {
              connector_type: "gmail";
              params: { from_match?: string | null; subject_match?: string | null; };
              webhook_name: "message";
            } | {
              connector_type: "github";
              params: {
                author_login?: string | null;
                enable_comments?: boolean;
                enable_commit_updates?: boolean;
                enable_reviews?: boolean;
                label_match?: string | null;
                only_on_merge?: boolean;
                pull_request_number?: number | null;
                repository: string;
                title_match?: string | null;
              };
              webhook_name: "pull_request";
            } | { connector_type: "finances"; params: {}; webhook_name: "update"; } | {
              connector_id: string;
              event: string;
              params: { [key: string]: unknown; };
            }> | null;
          }): Promise<CallToolResult<AutomationMutation>>;
          
        • Behavior: Schedules use iCal VEVENT; relative DTSTART uses dtstart_offset_json and timezones use IANA names. Event subscriptions use discovered connector events; connection or approval requirements suspend setup.
        • Variants:

          • timing_mode: exact_schedule, flexible_schedule, or condition_watch; these are modes of one method.
          • triggers accepts Slack, Teams, Linear, Gmail, GitHub, Finances, or discovered generic connector events.
          • Trigger fields vary by discovered connector event and filter schema.
      • codex_apps.automations.discover_webhook_schema - Discover supported event schemas and filters before configuring automation triggers for an authorized connected application.

        • Binding: tools.mcp__codex_apps__automations_discover_webhook_schema.
        • TypeScript contract:
          ⎗
          ✓
          declare function discover_webhook_schema(args: { connector_type: string; }): Promise<CallToolResult<{
            connector_type?: string | null;
            display_to_user?: boolean | null;
            error_code?: "too_many_active_automations" | "too_many_active_goals" | "automation_schedule_not_available" | null;
            error_data?: { current_count: number; plan_limit: number; } | {
              allowed: Array<string>;
              constraint: "frequency" | "timing_mode";
              requested: string;
            } | null;
            guidance?: string | null;
            jawbone_id?: string | null;
            message?: string | null;
            schema?: { [key: string]: unknown; } | null;
            status?: "ERROR" | null;
            user_message?: string | null;
          }>>;
          
        • Behavior: A connector identifier from list_event_sources selects its supported events and filters. Event-based creation uses condition_watch, triggers, and an empty schedule when the required schedule field has no calendar meaning.
      • codex_apps.automations.list - Display the user's saved task automations when they explicitly request their current automation list.

        • Binding: tools.mcp__codex_apps__automations_list.
        • TypeScript contract:
          ⎗
          ✓
          declare function list(args: {}): Promise<CallToolResult<AutomationList>>;
          
        • Behavior: The result displays saved automations and is intended for an explicit request to view tasks.
      • codex_apps.automations.list_event_sources - List connected applications supporting automation events so subscriptions use valid connector identifiers and supported events.

        • Binding: tools.mcp__codex_apps__automations_list_event_sources.
        • TypeScript contract:
          ⎗
          ✓
          declare function list_event_sources(args: {}): Promise<CallToolResult>;
          
        • Behavior: Returns connected applications with supported events. Its connector_id values are accepted by discover_webhook_schema.
      • codex_apps.automations.peek - Retrieve saved automation details privately to resolve task identifiers, schedules, prompts, and current enabled status.

        • Binding: tools.mcp__codex_apps__automations_peek.
        • TypeScript contract:
          ⎗
          ✓
          declare function peek(args: { jawbone_id?: string | null; }): Promise<CallToolResult<AutomationList>>;
          
        • Behavior: Provides task lookup without displaying the list. A supplied jawbone_id includes recorded run and result details.
      • codex_apps.automations.run_now - Request one immediate execution of an enabled automation using its existing prompt and delivery settings.

        • Binding: tools.mcp__codex_apps__automations_run_now.
        • TypeScript contract:
          ⎗
          ✓
          declare function run_now(args: { jawbone_id: string; }): Promise<CallToolResult<AutomationMutation>>;
          
        • Behavior: Requires an enabled existing task and an explicit immediate-run request. Acceptance confirms a run request, not execution or delivery completion.
      • codex_apps.automations.update - Modify saved automation settings, revise subscriptions, or pause and resume tasks while preserving omitted fields.

        • Binding: tools.mcp__codex_apps__automations_update.
        • TypeScript contract:
          ⎗
          ✓
          declare function update(args: {
            default_timezone?: string | null;
            dtstart_offset_json?: string | null;
            is_enabled?: boolean | null;
            jawbone_id: string;
            prompt?: string | null;
            schedule?: string | null;
            title?: string | null;
            triggers?: Array<{
              connector_type: "slack";
              id?: string | null;
              params: {
                author_names?: Array<string> | null;
                author_user_ids?: Array<string> | null;
                channel_ids: Array<string>;
                channel_names?: Array<string> | null;
                include_thread_replies?: boolean;
              };
              webhook_name: "message";
            } | {
              connector_type: "microsoft_teams";
              id?: string | null;
              params: {
                author_names?: Array<string> | null;
                author_user_ids?: Array<string> | null;
                channel_ids: Array<string>;
                channel_names?: Array<string> | null;
                channel_team_ids?: { [key: string]: string; };
                include_thread_replies?: boolean;
              };
              webhook_name: "message";
            } | {
              connector_type: "linear";
              id?: string | null;
              params: {
                enable_updates?: boolean;
                label_match?: string | null;
                project?: string | null;
                project_name?: string | null;
                team: string;
                team_name?: string | null;
                title_match?: string | null;
              };
              webhook_name: "issue";
            } | {
              connector_type: "gmail";
              id?: string | null;
              params: { from_match?: string | null; subject_match?: string | null; };
              webhook_name: "message";
            } | {
              connector_type: "github";
              id?: string | null;
              params: {
                author_login?: string | null;
                enable_comments?: boolean;
                enable_commit_updates?: boolean;
                enable_reviews?: boolean;
                label_match?: string | null;
                only_on_merge?: boolean;
                pull_request_number?: number | null;
                repository: string;
                title_match?: string | null;
              };
              webhook_name: "pull_request";
            } | { connector_id: string; event: string; id?: string | null; params: { [key: string]: unknown; }; }> | null;
          }): Promise<CallToolResult<AutomationMutation>>;
          
        • Behavior: Omitted fields retain their values. is_enabled pauses or resumes a task; supplying triggers replaces its subscription set.
        • Variants:

          • is_enabled: false pauses; is_enabled: true resumes. Omitted fields retain their values.
          • triggers replaces the desired subscription set when supplied; omission preserves existing subscriptions.
          • Update triggers include existing IDs and have no explicit Finances branch.
    • Hotline — codex_apps.hotline (1 method)

      • codex_apps.hotline.get_local_hotline - Retrieve location-appropriate helpline information using the country inferred from the conversation instead of guessing contact details.

        • Binding: tools.mcp__codex_apps__hotline_get_local_hotline.
        • TypeScript contract:
          ⎗
          ✓
          declare function get_local_hotline(args: {}): Promise<CallToolResult>;
          
        • Behavior: Country is inferred from conversation context. The specialized lookup supplies helpline details rather than guessed contact information.
    • Safety Settings — codex_apps.safety_settings (5 methods)

      • codex_apps.safety_settings.get_family_info - Read family setup status, product information, actor role, and authorized member identifiers before parental-control operations.

        • Binding: tools.mcp__codex_apps__safety_settings_get_family_info.
        • TypeScript contract:
          ⎗
          ✓
          1
          2
          3
          4
          5
          6
          7
          8
          9
          declare function get_family_info(args: {}): Promise<CallToolResult<{
            actor_role: "parent" | "teen" | "child" | null;
            help_url: string;
            pending_invite_count: number;
            product_information: string;
            readable_targets: Array<{ display_name: string; role: "parent" | "teen" | "child"; user_id: string; }>;
            settings_url: "#settings/ParentalControls";
            status: "not_configured" | "pending_invite" | "linked";
          }>>;
          
        • Behavior: Returns current family status and authorized member identifiers; these identities constrain subsequent parental-control reads and changes.
      • codex_apps.safety_settings.get_parental_controls - Read one authorized family member's available controls, current values, update eligibility, and supported configuration choices.

        • Binding: tools.mcp__codex_apps__safety_settings_get_parental_controls.
        • TypeScript contract:
          ⎗
          ✓
          declare function get_parental_controls(args: { user_id: string; }): Promise<CallToolResult<{
            controls: Array<{
              can_update_in_chat: boolean;
              control_id: string;
              current_value: boolean | { enabled: boolean; end_time: string | null; start_time: string | null; } | Array<string>;
              description: string | null;
              label: string;
              locked: boolean;
              options: Array<{ description: string | null; label: string; value: string; }>;
              type: "toggle" | "quiet_hours" | "multi_select";
            }>;
            help_url: string;
            settings_url: "#settings/ParentalControls";
            target_display_name: string;
            target_role: "parent" | "teen" | "child";
          }>>;
          
        • Behavior: Requires a member ID from the latest family result. Each control publishes its current value, lock state, supported options, and in-chat update eligibility.
      • codex_apps.safety_settings.get_trusted_contact - Inspect Trusted Contact setup status and product information before answering setup, notification, or privacy questions.

        • Binding: tools.mcp__codex_apps__safety_settings_get_trusted_contact.
        • TypeScript contract:
          ⎗
          ✓
          1
          2
          3
          4
          5
          6
          7
          declare function get_trusted_contact(args: {}): Promise<CallToolResult<{
            help_url: string;
            name: string | null;
            product_information: string;
            settings_url: "#settings/Safety";
            status: "not_configured" | "pending" | "active";
          }>>;
          
        • Behavior: Returns not_configured, pending, or active status together with product and help information.
      • codex_apps.safety_settings.prepare_parental_control_update - Validate one authorized parental-control change and return its exact confirmation summary before any setting is modified.

        • Binding: tools.mcp__codex_apps__safety_settings_prepare_parental_control_update.
        • TypeScript contract:
          ⎗
          ✓
          declare function prepare_parental_control_update(args: {
            control_id: string;
            user_id: string;
            value: boolean | { enabled: boolean; end_time: string | null; start_time: string | null; } | Array<string>;
          }): Promise<CallToolResult<{
            confirmation_summary: string;
            operation_id: string;
            status: "needs_approval" | "already_set";
            value: boolean | { enabled: boolean; end_time: string | null; start_time: string | null; } | Array<string> | null;
          }>>;
          
        • Behavior: Validates a writable observed control without changing it. needs_approval supplies the exact confirmation summary and operation ID; already_set requires no write.
        • Variants:

          • value is a boolean toggle, a quiet-hours object, or a string selection list, matching the observed control type.
          • needs_approval supplies a confirmation summary and operation ID; already_set means no change is needed.
      • codex_apps.safety_settings.update_parental_control - Apply a prepared parental-control change after explicit approval of the exact returned confirmation summary and value.

        • Binding: tools.mcp__codex_apps__safety_settings_update_parental_control.
        • TypeScript contract:
          ⎗
          ✓
          declare function update_parental_control(args: {
            confirmation_summary: string;
            control_id: string;
            operation_id: string;
            user_id: string;
            value: boolean | { enabled: boolean; end_time: string | null; start_time: string | null; } | Array<string>;
          }): Promise<CallToolResult<{
            status: "updated" | "already_set" | "declined";
            value: boolean | { enabled: boolean; end_time: string | null; start_time: string | null; } | Array<string> | null;
          }>>;
          
        • Behavior: Requires explicit parental approval of the prepared summary. Target, control, operation, summary, and value must match the prepared change.
        • Variants:

          • Use the exact previously prepared operation_id, confirmation_summary, target, control, and value.
          • The declared status is updated, already_set, or declined; return values preserve the supported control union.

Shared API types

CallToolResult<T> carries structured payload T when the backend returns one. Content blocks support text, images, audio, resource links, and embedded resources. isError and payload-specific status fields describe different error layers.

⎗
✓
type CallToolResult<T = { [key: string]: unknown }> = {
  _meta?: { [key: string]: unknown };
  content: ContentBlock[];
  isError?: boolean;
  structuredContent?: T;
  [key: string]: unknown;
};

type ContentBlock =
  | TextContent
  | ImageContent
  | AudioContent
  | ResourceLink
  | EmbeddedResource;

The following aliases retain the published structural fields, optional properties, and return unions.

PageFailure

⎗
✓
type PageFailure = {
  error: {
    cause?: "timeout";
    code?: string;
    commit_status?: string;
    conflict_reason?: string;
    details?: unknown;
    limit_actual?: number;
    limit_dimension?: string;
    limit_maximum?: number;
    limit_reason?: string;
    message: string;
    retryable?: boolean;
  };
};

Automation

⎗
✓
type Automation = {
  conversation_id?: string | null;
  default_timezone?: string | null;
  display_schedule?: string | null;
  id: string;
  is_enabled: boolean;
  is_self_owned_automation?: boolean | null;
  last_run_time?: string | null;
  next_run_time?: string | null;
  plan_file_id?: string | null;
  prompt: string;
  run_details?: {
    delivery_status?: "unknown";
    last_run: {
      chat_ref: { id: string; type: "chatgpt" | "codex"; } | null;
      completed_at: string | null;
      id: string;
      recorded_status: "in_progress" | "completed" | "failed" | "no_update";
      scheduled_for: string;
      started_at: string;
    } | null;
    latest_result: {
      chat_ref: { id: string; type: "chatgpt" | "codex"; } | null;
      completed_at: string | null;
      content_text: string;
      content_truncated: boolean;
      created_at: string;
      is_failure_message: boolean;
      requires_user_action: boolean;
      run_id: string;
      scheduled_for: string;
    } | null;
  } | null;
  schedule: string;
  team_id?: string | null;
  thread_id?: string | null;
  timing_mode?: "exact_schedule" | "flexible_schedule" | "condition_watch" | null;
  title: string;
  updated_at: string;
};

AutomationMutation

⎗
✓
type AutomationMutation = {
  assistant_response_guidance?: string | null;
  automation?: Automation | null;
  automation_id?: string | null;
  display_to_user?: boolean | null;
  error_code?: "too_many_active_automations" | "too_many_active_goals" | "automation_schedule_not_available" | null;
  error_data?: { current_count: number; plan_limit: number; } | {
    allowed: Array<string>;
    constraint: "frequency" | "timing_mode";
    requested: string;
  } | null;
  jawbone_id?: string | null;
  message: string;
  status?: "ERROR" | null;
  success?: boolean | null;
  user_message?: string | null;
};

CommentThread

⎗
✓
type CommentThread = {
  author: { displayName: string; id: string; };
  createdAt: string;
  id: string;
  messages: Array<{
    agent_kind?: string;
    author: { displayName: string; id: string; };
    authorType?: "agent";
    body: string;
    conversation_id?: string;
    createdAt: string;
    deletedAt?: string;
    editedAt?: string;
    id: string;
    reactions: Array<{
      count: number;
      emoji: string;
      reactedByMe: boolean;
      reactors: Array<{ displayName: string; id: string; }>;
    }>;
  }>;
  resolvedAt?: string;
  resolvedBy?: { displayName: string; id: string; };
  selectionContext?: {
    end: { blockId: string; offsetUtf16: number; };
    start: { blockId: string; offsetUtf16: number; };
    status: "attached";
    text: string;
    truncated: boolean;
  } | { status: "detached"; };
  state: "open" | "resolved";
  target: { blockId: string; kind: "block"; } | {
    anchor: { blockId: string; relativePositionBase64: string; };
    head: { blockId: string; relativePositionBase64: string; };
    kind: "selection";
  };
  updatedAt: string;
};

SiteAccessPolicy

⎗
✓
type SiteAccessPolicy = {
  access_mode: "public" | "admins_only" | "workspace_all" | "custom";
  allowed_account_user_ids: Array<string>;
  allowed_editors?: Array<{
    account_user_id: string;
    avatar_url?: string | null;
    email?: string | null;
    is_external?: boolean | null;
    name?: string | null;
    pending?: boolean;
    role?: "owner" | "editor" | "viewer" | null;
  }>;
  allowed_groups: Array<{
    id: string;
    name: string;
    pending?: boolean;
    role?: "viewer" | "editor" | null;
    size: number;
  }>;
  allowed_tenant_group_ids: Array<string>;
  allowed_users: Array<{
    account_user_id: string;
    avatar_url?: string | null;
    email?: string | null;
    is_external?: boolean | null;
    name?: string | null;
    pending?: boolean;
    role?: "owner" | "editor" | "viewer" | null;
  }>;
  allowed_workspace_group_ids: Array<string>;
  external_visitor_count?: number;
  project_id: string;
  revision: number;
  updated_at: string;
};

AutomationList

⎗
✓
type AutomationList = {
  assistant_response_guidance?: string | null;
  automations?: Array<Automation> | null;
  completed_count?: number | null;
  cursor?: string | null;
  display_to_user?: boolean | null;
  error_code?: "too_many_active_automations" | "too_many_active_goals" | "automation_schedule_not_available" | null;
  error_data?: { current_count: number; plan_limit: number; } | {
    allowed: Array<string>;
    constraint: "frequency" | "timing_mode";
    requested: string;
  } | null;
  jawbone_id?: string | null;
  message: string;
  paused_count?: number | null;
  status?: "ERROR" | null;
  user_message?: string | null;
};

PageOperationReceipt

⎗
✓
type PageOperationReceipt = {
  affected_blocks: Array<{ block_id: string; hash: string; }>;
  continuation_position: { block_id: string; relative_position_base64: string; } | null;
  created_block_ids: Array<string>;
  error_code?: null | "edit_conflict" | "invalid_page_schema" | "page_limit_exceeded";
  ignored_reason?: null | "block_deleted";
  operation_index: number;
  preceding_block_id: string | null;
  rejection_reason?: string | null;
  status?: "applied" | "rejected";
};

CustomDomain

⎗
✓
type CustomDomain = {
  apex_proxy_ipv4_targets: Array<string>;
  cname_target: string | null;
  created_at: string;
  hostname: string;
  id: string;
  last_error: string | null;
  project_id: string;
  provider_status: string | null;
  ssl_status: string | null;
  status: "pending" | "active" | "failed";
  updated_at: string;
  validation_records: Array<{ name?: string | null; record_type?: string | null; value?: string | null; }>;
  worker_name: string;
};

Deployment

⎗
✓
type Deployment = {
  env_set_revision: number;
  failure_message: string | null;
  has_mcp?: boolean | null;
  id: string;
  is_async_publication?: boolean | null;
  project_id: string;
  provider_deployment_id: string | null;
  screenshot_asset_pointer?: string | null;
  status: "pending" | "building" | "publishing" | "succeeded" | "failed";
  title: string;
  type: "preview" | "publish";
  updated_at: string;
  url: string | null;
  version_id: string;
};

PageList

⎗
✓
type PageList = {
  incomplete_reasons?: Array<"content_limited" | "content_failed"> | null;
  items: Array<{
    access: {
      can_comment?: boolean;
      can_delete?: boolean;
      can_read?: boolean;
      can_share?: boolean;
      can_write?: boolean;
      sources?: Array<string>;
    };
    created_at: string;
    creator_account_user_id: string;
    current_sequence: number;
    deleted_at: string | null;
    display_metadata_included?: boolean;
    document_type?: string;
    drive_scope?: "space" | "personal" | "workspace_private" | null;
    drive_space_id?: string | null;
    has_children?: boolean | null;
    layout?: "document" | "spatial";
    library_container_id?: string | null;
    namespace?: "meeting_notes" | "data_reports" | "skill" | null;
    owner_workspace_id: string | null;
    page_id: string;
    parent: null | { unavailable: true; } | { page_id: string; title?: string; };
    position?: number;
    preview?: string | null;
    projection_through_sequence: number;
    site_project_id?: string | null;
    stream_kind?: "content" | "scratch";
    symbol?: null | { kind: "none"; } | { kind: "emoji"; value: string; } | {
      color: string;
      kind: "icon";
      value: string;
    };
    title?: string | null;
    updated_at: string;
    url: string;
  }>;
  next_cursor?: string | null;
  partial_results?: boolean | null;
};

CommentMutation

⎗
✓
1
2
3
4
5
6
7
8
9
type CommentMutation = {
  deleted_thread_id?: string;
  message_id: string | null;
  page_id: string;
  sequence: number;
  thread: CommentThread | null;
  thread_id: string;
  truncated: boolean;
};

ArtifactExecution

⎗
✓
type ArtifactExecution = {
  committed_sequence?: number | null;
  document_type?: string | null;
  error_code?: string | null;
  error_details?: {
    category?: "semantic" | "unknown";
    message: string;
    name: string;
    stack: Array<string>;
    truncated: boolean;
  } | null;
  error_message?: string | null;
  font_loading?: {
    error_details?: {
      category?: "semantic" | "unknown";
      message: string;
      name: string;
      stack: Array<string>;
      truncated: boolean;
    } | null;
    message?: string | null;
    status: "loaded" | "disabled" | "runtime_unsupported" | "memory_limit" | "registration_failed";
  } | null;
  idempotency_key: string;
  observed_sequence?: number | null;
  page_id: string;
  rendered_images?: Array<{ byte_length: number; file_name: string; mime_type: string; sha256: string; }> | null;
  request_id?: string | null;
  result?: unknown;
  result_message?: string | null;
  result_omitted?: boolean;
  retryable?: boolean;
  status: "committed" | "accepted" | "no_changes" | "rejected" | "unknown" | "not_found";
};

SiteVersion

⎗
✓
type SiteVersion = {
  archive_storage?: {
    archive_format: string;
    content_hash: string;
    file_count?: number | null;
    sediment_file_id: string;
    size_bytes?: number | null;
  } | null;
  deployment_id?: string | null;
  id: string;
  project_id: string;
  screenshot_url?: string | null;
  source: { commit_sha: string; };
  version_number: number;
};

AttachedAutomation

⎗
✓
type AttachedAutomation = {
  automation_id: string;
  automation_role: "controller" | "task";
  can_remove: boolean;
  configuration: {
    default_timezone: string;
    is_enabled: boolean;
    prompt: string;
    runs_as_account_user_id: string;
    runs_as_display_name: string | null;
    schedule: string;
    title: string;
  } | null;
  controller_automation_id: string | null;
  created_at: string;
  creator_account_user_id: string;
  creator_display_name: string | null;
  display_name: string | null;
  runtime: "cloud" | "local" | null;
  status: "active" | "paused" | "finished" | "unavailable";
};

SiteEnvironment

⎗
✓
1
2
3
4
5
6
7
8
type SiteEnvironment = {
  entries: Array<{ is_secret?: boolean; key: string; type?: "envvar"; value: string | null; }>;
  instructions?: string | null;
  project_id: string;
  requires_secrets?: boolean;
  revision: number;
  updated_at: string | null;
};

PageEditResult

⎗
✓
type PageEditResult = {
  error: { code: "invalid_page_schema"; commit_status: "not_committed"; message: string; };
} | {
  new_sequence?: number;
  operation_results: Array<PageOperationReceipt>;
  recovery?: {
    action: "reread_and_rebuild" | "correct_input" | "change_operation" | "reduce_edit_size" | "reduce_document_size" | "inspect_state" | "repair_rejected_operations";
    message: string;
    retryable: boolean;
  };
  through_sequence?: number;
} | {
  error: {
    code: "edit_conflict";
    commit_status?: "not_committed" | "unknown";
    details: { operation_results: Array<PageOperationReceipt>; through_sequence?: number; };
    message: string;
    recovery?: {
      action: "reread_and_rebuild" | "correct_input" | "change_operation" | "reduce_edit_size" | "reduce_document_size" | "inspect_state" | "repair_rejected_operations";
      message: string;
      retryable: boolean;
    };
  };
} | { error: { code: "invalid_page_schema"; details?: unknown; message: string; retryable?: boolean; }; } | PageFailure & {
  error?: { code?: unknown; };
};

Registered workflow skills

Inputs and outputs describe workflow tasks. Backing-method references use the callable contracts above; renderer references use the contracts below.

  • Productivity

    • skills.answers_ask_user_input.answers_ask_user_input - Gather consequential missing preferences with tappable answer choices and a concise free-text option tailored to each question.

      • Advertised name: answers-ask-user-input:answers-ask-user-input; authority: executor and cloud.
      • Inputs: Material unanswered preferences expressed as concise questions and selectable options.
      • Outputs: A rendered preference questionnaire with question-specific free-text entry.
      • Rendering methods: render.ask_user_input.
      • Packages:

        • executor: skill://answers-ask-user-input@openai-curated-remote/root/.codex/plugins/cache/openai-curated-remote/answers-ask-user-input/0.1.1/skills/answers-ask-user-input.
        • cloud: skill://plugin_connector_1p_eef8f74d53ec81918192d7cf7058e696/answers-ask-user-input.
    • skills.answers_charts.answers_charts - Render interactive bar, line, pie, or scatter charts when quantitative relationships benefit from an in-conversation visualization.

      • Advertised name: answers-charts:answers-charts; authority: cloud and executor.
      • Inputs: Measured or clearly labeled illustrative rows, chart mappings, and a quantitative question.
      • Outputs: A rendered bar, line, pie, or scatter chart.
      • Rendering methods: render.charts_widget_v2.
      • Packages:

        • cloud: skill://plugin_connector_1p_4f078b18ec548191a54ea74cb1994973/answers-charts.
        • executor: skill://answers-charts@openai-curated-remote/root/.codex/plugins/cache/openai-curated-remote/answers-charts/0.1.1/skills/answers-charts.
    • skills.answers_image_picker.answers_image_picker - Generate three comparable visual directions and present a structured image choice that guides the next implementation.

      • Advertised name: answers-image-picker:answers-image-picker; authority: executor and cloud.
      • Inputs: Exactly three real generated preview paths with labels and continuation context.
      • Outputs: A three-card image choice returning the selected direction to the conversation.
      • Rendering methods: render.image_picker.
      • Packages:

        • executor: skill://answers-image-picker@openai-curated-remote/root/.codex/plugins/cache/openai-curated-remote/answers-image-picker/0.1.1/skills/answers-image-picker.
        • cloud: skill://plugin_connector_1p_b8ecd6622db4819194b0e8a72d67d155/answers-image-picker.
    • skills.answers_images.answers_images - Ground an explanation with relevant retrieved image groups when visual context materially improves the user's understanding.

      • Advertised name: answers-images:answers-images; authority: executor and cloud.
      • Inputs: One or more useful image-search queries and a gallery layout.
      • Outputs: A rendered image group rather than an RPC payload.
      • Rendering methods: render.async_image_group.
      • Packages:

        • executor: skill://answers-images@openai-curated-remote/root/.codex/plugins/cache/openai-curated-remote/answers-images/0.1.1/skills/answers-images.
        • cloud: skill://plugin_connector_1p_a3b087f2f2808191b35389b76c8ab7aa/answers-images.
    • skills.answers_learning.answers_learning - Present objective multiple-choice knowledge quizzes or pronunciation practice using the appropriate interactive language and learning widgets.

      • Advertised name: answers-learning:answers-learning; authority: executor and cloud.
      • Inputs: An explicitly requested objective quiz or a concrete pronunciation target.
      • Outputs: An interactive quiz or pronunciation block.
      • Rendering methods: render.learning_quiz, render.language_learning_block_widget_pronunciation.
      • Packages:

        • executor: skill://answers-learning@openai-curated-remote/root/.codex/plugins/cache/openai-curated-remote/answers-learning/0.1.1/skills/answers-learning.
        • cloud: skill://plugin_connector_1p_8234276408088191a3582915dd4ac853/answers-learning.
    • skills.demos.answers_ask_user_input - Collect useful missing preferences through concise selectable answers and an optional question-specific free-text response.

      • Advertised name: demos:answers-ask-user-input; authority: cloud and executor.
      • Inputs: A material unanswered preference, constraint, or goal.
      • Outputs: Selectable responses with question-specific free-text entry.
      • Rendering methods: render.ask_user_input.
      • Packages:

        • cloud: skill://plugin_connector_1p_791a564c68c88191b3b084d5fb733be6/answers-ask-user-input.
        • executor: skill://demos@openai-curated-remote/root/.codex/plugins/cache/openai-curated-remote/demos/0.1.22/skills/answers-ask-user-input.
    • skills.demos.onboarding_artifact_creation - Guide explicitly invoked onboarding toward a compact polished first artifact with only essential source or style questions.

      • Advertised name: demos:onboarding-artifact-creation; authority: cloud.
      • Inputs: An explicitly invoked onboarding brief and any available source or style preferences.
      • Outputs: A compact polished first document, presentation, spreadsheet, PDF, or other chosen artifact.
      • Packages:

        • cloud: skill://plugin_connector_1p_791a564c68c88191b3b084d5fb733be6/onboarding-artifact-creation.
        • Local definition: /root/.codex/plugins/cache/openai-curated-remote/demos/0.1.22/skills/onboarding-artifact-creation/SKILL.md.
          - Scope: explicitly invoked onboarding.
    • skills.demos.onboarding_email - Connect the chosen email provider during explicitly invoked onboarding and demonstrate a useful initial inbox workflow.

      • Advertised name: demos:onboarding-email; authority: cloud.
      • Inputs: An explicitly invoked onboarding task and selected email provider.
      • Outputs: A verified connection flow and useful initial inbox result or reviewable draft.
      • Backing methods:

        • codex_apps.plugin_management.search_plugins.
        • codex_apps.plugin_management.suggest_plugins.
          - Packages:
        • cloud: skill://plugin_connector_1p_791a564c68c88191b3b084d5fb733be6/onboarding-email.
        • Local definition: /root/.codex/plugins/cache/openai-curated-remote/demos/0.1.22/skills/onboarding-email/SKILL.md.
          - Scope: explicitly invoked onboarding.
    • skills.demos.onboarding_learn_writing_style - Learn a user's writing style from verified samples during onboarding, calibrate examples, and save an approved reference.

      • Advertised name: demos:onboarding-learn-writing-style; authority: cloud.
      • Inputs: Explicit onboarding intent and a small verified sample of the user's writing.
      • Outputs: A calibrated style reference and examples, followed by the authorized saved skill.
      • Packages:

        • cloud: skill://plugin_connector_1p_791a564c68c88191b3b084d5fb733be6/onboarding-learn-writing-style.
        • Local definition: /root/.codex/plugins/cache/openai-curated-remote/demos/0.1.22/skills/onboarding-learn-writing-style/SKILL.md.
          - Scope: explicitly invoked onboarding.
    • skills.demos.onboarding_messaging - Connect the selected messaging provider during explicitly invoked onboarding and demonstrate summaries or reviewable reply drafts.

      • Advertised name: demos:onboarding-messaging; authority: cloud.
      • Inputs: An explicitly invoked onboarding task and selected messaging provider.
      • Outputs: A verified connection flow with summaries or reviewable reply drafts.
      • Backing methods:

        • codex_apps.plugin_management.search_plugins.
        • codex_apps.plugin_management.suggest_plugins.
          - Packages:
        • cloud: skill://plugin_connector_1p_791a564c68c88191b3b084d5fb733be6/onboarding-messaging.
        • Local definition: /root/.codex/plugins/cache/openai-curated-remote/demos/0.1.22/skills/onboarding-messaging/SKILL.md.
          - Scope: explicitly invoked onboarding.
    • skills.demos.onboarding_parallel_research - Research three complementary angles through parallel agents during explicitly invoked onboarding and synthesize their sourced findings visually.

      • Advertised name: demos:onboarding-parallel-research; authority: cloud.
      • Inputs: An explicit onboarding invocation and one main research topic.
      • Outputs: Three complementary sourced research angles and a compact visual synthesis.
      • Packages:

        • cloud: skill://plugin_connector_1p_791a564c68c88191b3b084d5fb733be6/onboarding-parallel-research.
        • Local definition: /root/.codex/plugins/cache/openai-curated-remote/demos/0.1.22/skills/onboarding-parallel-research/SKILL.md.
          - Scope: explicitly invoked onboarding.
    • skills.demos.onboarding_setup_pet - Guide visual selection or creation of a personalized Work pet and finish with individual animated previews.

      • Advertised name: demos:onboarding-setup-pet; authority: cloud and executor.
      • Inputs: Desired companion traits or a selected built-in pet during pet setup.
      • Outputs: Individual animated previews and the selected or created Work pet.
      • Backing methods:

        • codex_apps.pets.list_pets.
        • codex_apps.pets.get_pet_download_link.
        • codex_apps.pets.select_pet.
        • codex_apps.pets.validate_pet_spritesheet.
        • codex_apps.pets.prepare_pet_upload.
        • codex_apps.pets.create_pet.
          - Packages:
        • cloud: skill://plugin_connector_1p_791a564c68c88191b3b084d5fb733be6/onboarding-setup-pet.
        • executor: skill://demos@openai-curated-remote/root/.codex/plugins/cache/openai-curated-remote/demos/0.1.22/skills/onboarding-setup-pet.
          - Scope: explicitly invoked onboarding.
    • skills.demos.onboarding_website_creation - Guide explicitly invoked onboarding toward a private usable first website with a clean personalized one-page design.

      • Advertised name: demos:onboarding-website-creation; authority: cloud.
      • Inputs: An explicitly invoked onboarding request and the user's website idea.
      • Outputs: A private usable first Site with a personalized clean one-page design.
      • Backing methods:

        • codex_apps.sites.create_site.
        • codex_apps.sites.save_version_and_deploy_private.
          - Packages:
        • cloud: skill://plugin_connector_1p_791a564c68c88191b3b084d5fb733be6/onboarding-website-creation.
        • Local definition: /root/.codex/plugins/cache/openai-curated-remote/demos/0.1.22/skills/onboarding-website-creation/SKILL.md.
          - Scope: explicitly invoked onboarding.
    • skills.openai_library.library - Resolve, read, create, and update persistent user files while preserving file identity and version history.

      • Advertised name: openai-library:library; authority: cloud and executor.
      • Inputs: A file reference, content request, local deliverable, or requested file organization change.
      • Outputs: File content or persisted file identity and version information.
      • Backing methods:

        • codex_apps.library.create_library_file.
        • codex_apps.library.replace_library_file.
        • codex_apps.library.prepare_uploads.
        • codex_apps.library.finalize_uploads.
          - Packages:
        • cloud: skill://plugin_connector_1p_1b8ff8edfc1481918b252c8277e23125/library.
        • executor: skill://openai-library@openai-curated-remote/root/.codex/plugins/cache/openai-curated-remote/openai-library/0.1.69/skills/library.
    • skills.pages.maintain_space - Reconcile requested evidence into existing Pages and Spaces while preserving their structure, sources, and relevant context.

      • Advertised name: pages:maintain-space; authority: cloud and executor.
      • Inputs: Existing Page or Space targets and new evidence to reconcile.
      • Outputs: Updated Page content grounded in the supplied evidence.
      • Backing methods:

        • codex_apps.chatgpt_space.read_page.
        • codex_apps.chatgpt_space.read_page_changes.
        • codex_apps.chatgpt_space.read_page_reference.
        • codex_apps.chatgpt_space.patch_page.
        • codex_apps.chatgpt_space.edit_page.
          - Packages:
        • cloud: skill://plugin_connector_1p_4a72ddeef4c481918f92d8e8df18fb2c/maintain-space.
        • executor: skill://pages@openai-curated-remote/root/.codex/plugins/cache/openai-curated-remote/pages/0.1.26/skills/maintain-space.
    • skills.pages.manage_schedules - Review Page automation needs and create, change, or remove the recurring work the user requests.

      • Advertised name: pages:manage-schedules; authority: cloud and executor.
      • Inputs: A target Page, its current schedules, and the requested recurring work.
      • Outputs: Reviewed or updated Page-linked task and controller configuration.
      • Backing methods:

        • codex_apps.chatgpt_space.list_page_automations.
        • codex_apps.chatgpt_space.get_page_auto_update.
        • codex_apps.chatgpt_space.create_controller_automation.
        • codex_apps.chatgpt_space.set_page_auto_update.
        • codex_apps.automations.create.
        • codex_apps.automations.update.
          - Packages:
        • cloud: skill://plugin_connector_1p_4a72ddeef4c481918f92d8e8df18fb2c/manage-schedules.
        • executor: skill://pages@openai-curated-remote/root/.codex/plugins/cache/openai-curated-remote/pages/0.1.26/skills/manage-schedules.
    • skills.pages.organize_space - Reorganize existing Pages and Space structure according to requested moves, hierarchy changes, and destination access.

      • Advertised name: pages:organize-space; authority: cloud and executor.
      • Inputs: Observed Pages or Spaces and the requested destination hierarchy.
      • Outputs: Reorganized Pages, branches, or Space structure with returned move results.
      • Backing methods:

        • codex_apps.chatgpt_space.list_spaces.
        • codex_apps.chatgpt_space.get_space.
        • codex_apps.chatgpt_space.list_pages.
        • codex_apps.chatgpt_space.create_space.
        • codex_apps.chatgpt_space.move_page.
        • codex_apps.chatgpt_space.trash_page.
          - Packages:
        • cloud: skill://plugin_connector_1p_4a72ddeef4c481918f92d8e8df18fb2c/organize-space.
        • executor: skill://pages@openai-curated-remote/root/.codex/plugins/cache/openai-curated-remote/pages/0.1.26/skills/organize-space.
    • skills.pages.write_page - Create or edit requested Page content using grounded source evidence and the destination's supported content structure.

      • Advertised name: pages:write-page; authority: cloud and executor.
      • Inputs: Requested prose, evidence, and an identified writable Page or Space destination.
      • Outputs: Created or revised Page content and any requested supported embeds.
      • Backing methods:

        • codex_apps.chatgpt_space.create_page.
        • codex_apps.chatgpt_space.read_page.
        • codex_apps.chatgpt_space.edit_page.
        • codex_apps.chatgpt_space.patch_page.
        • codex_apps.chatgpt_space.write_page_reference.
        • codex_apps.chatgpt_space.create_page_visualization.
          - Packages:
        • cloud: skill://plugin_connector_1p_4a72ddeef4c481918f92d8e8df18fb2c/write-page.
        • executor: skill://pages@openai-curated-remote/root/.codex/plugins/cache/openai-curated-remote/pages/0.1.26/skills/write-page.
    • skills.personal_context.personal_context - Retrieve prior preferences, decisions, or work only when missing personal context materially affects the present task.

      • Advertised name: personal-context:personal-context; authority: cloud and executor.
      • Inputs: A current question for which unseen prior personal context materially affects the answer.
      • Outputs: Relevant retrieved messages or context, with possible retrieval error details.
      • Backing methods:

        • codex_apps.personal_context.search.
          - Packages:
        • cloud: skill://plugin_connector_1p_d1c5f7186b5081919776a7b3d7cd73ea/personal-context.
        • executor: skill://personal-context@openai-curated-remote/root/.codex/plugins/cache/openai-curated-remote/personal-context/0.1.1/skills/personal-context.
    • skills.plugin_management.plugin_management - Discover suitable integrations and inspect or manage requested plugin dependencies, connections, installation state, and permission settings.

      • Advertised name: plugin-management:plugin-management; authority: cloud and executor.
      • Inputs: A provider, capability need, exact plugin target, or requested permission change.
      • Outputs: Directory metadata, connection suggestions, permission results, or requested uninstall outcomes.
      • Backing methods:

        • codex_apps.plugin_management.search_plugins.
        • codex_apps.plugin_management.get_plugin_dependencies.
        • codex_apps.plugin_management.get_app_permissions.
        • codex_apps.plugin_management.suggest_plugins.
        • codex_apps.plugin_management.update_app_permissions.
        • codex_apps.plugin_management.uninstall_app.
          - Packages:
        • cloud: skill://plugin_connector_1p_b3438d6beb9081918fba3625bc988128/plugin-management.
        • executor: skill://plugin-management@openai-curated-remote/root/.codex/plugins/cache/openai-curated-remote/plugin-management/0.1.0/skills/plugin-management.
    • skills.resolve_recipients.resolve_recipients - Verify intended people against available communication context before sending messages, invitations, or other person-directed actions.

      • Advertised name: resolve-recipients:resolve-recipients; authority: cloud and executor.
      • Inputs: A named or described recipient and the intended person-directed action.
      • Outputs: Verified recipient identity or a focused ambiguity clarification.
      • Packages:

        • cloud: skill://plugin_connector_1p_23724af15ba0819186e98d78fb875c86/resolve-recipients.
        • executor: skill://resolve-recipients@openai-curated-remote/root/.codex/plugins/cache/openai-curated-remote/resolve-recipients/0.1.1/skills/resolve-recipients.
    • skills.sites.sites - Build, revise, save, and publish functional websites while preserving existing project identity and authorized visitor access.

      • Advertised name: sites:sites; authority: cloud and executor.
      • Inputs: A website brief or an existing Site project and requested changes.
      • Outputs: A functional website, saved source versions, and a production publication when authorized.
      • Backing methods:

        • codex_apps.sites.create_site.
        • codex_apps.sites.get_site.
        • codex_apps.sites.save_site_version.
        • codex_apps.sites.save_version_and_deploy_private.
        • codex_apps.sites.deploy_private_site_version.
        • codex_apps.sites.deploy_site_version.
        • codex_apps.sites.get_deployment_status.
          - Packages:
        • cloud: skill://plugin_connector_1p_689987207de08191979cf68eca2941c6/sites.
        • executor: skill://sites@openai-curated-remote/root/.codex/plugins/cache/openai-curated-remote/sites/1.1.2/skills/sites.
    • skills.sites.sites_remix - Create a separate Site from an identified existing Site while following the source's supported remix workflow.

      • Advertised name: sites:sites-remix; authority: cloud and executor.
      • Inputs: An identified source Site and the requested separate derivative.
      • Outputs: A new Site derived through the supported remix workflow.
      • Backing methods:

        • codex_apps.sites.get_site.
        • codex_apps.sites.create_site.
          - Packages:
        • cloud: skill://plugin_connector_1p_689987207de08191979cf68eca2941c6/sites-remix.
        • executor: skill://sites@openai-curated-remote/root/.codex/plugins/cache/openai-curated-remote/sites/1.1.2/skills/sites-remix.
    • skills.static_app_previews.static_app_previews - Present self-contained interactive app previews when the request fits and the available Sites workflow does not apply.

      • Advertised name: static-app-previews:static-app-previews; authority: cloud and executor.
      • Inputs: An app or game brief compatible with a self-contained inline preview.
      • Outputs: One complete HTML, JSX, or TSX preview block; Sites takes precedence for websites.
      • Rendering methods: render.static_app_preview.
      • Packages:

        • cloud: skill://plugin_connector_1p_463919bb791881918e5970d96f225668/static-app-previews.
        • executor: skill://static-app-previews@openai-curated-remote/root/.codex/plugins/cache/openai-curated-remote/static-app-previews/0.1.1/skills/static-app-previews.
    • skills.template_creator.template_creator - Create reusable installable artifact templates from reference files, designs, messages, or existing Site projects.

      • Advertised name: template-creator:template-creator; authority: cloud and executor.
      • Inputs: Reference artifacts or examples and the desired reusable artifact behavior.
      • Outputs: A reusable installable personal template skill.
      • Packages:

        • cloud: skill://plugin_connector_1p_28fcc699d1308191a783ccaabe1850a3/template-creator.
        • executor: skill://template-creator@openai-curated-remote/root/.codex/plugins/cache/openai-curated-remote/template-creator/0.2.6/skills/template-creator.
    • skills.work_pets.create_pet - Create and validate a custom animated Work pet with required sprite states, preview assets, and activation support.

      • Advertised name: work-pets:create-pet; authority: cloud and executor.
      • Inputs: A character idea, reference artwork, or compatible pet sprite sheet.
      • Outputs: A validated custom Work pet, preview, and activation when requested.
      • Backing methods:

        • codex_apps.pets.validate_pet_spritesheet.
        • codex_apps.pets.prepare_pet_upload.
        • codex_apps.pets.create_pet.
        • codex_apps.pets.select_pet.
          - Packages:
        • cloud: skill://plugin_connector_1p_bccf6c8660c08191ae4470d9ae4877fa/create-pet.
        • executor: skill://work-pets@openai-curated-remote/root/.codex/plugins/cache/openai-curated-remote/work-pets/0.1.6/skills/create-pet.
    • skills.work_pets.pets - List, inspect, select, download, or explicitly delete animated companions within the established ChatGPT Work pet environment.

      • Advertised name: work-pets:pets; authority: cloud and executor.
      • Inputs: A pet listing, stable pet identifier, selection, download, or explicit deletion request.
      • Outputs: Pet metadata, an active selection, download link, or requested deletion outcome.
      • Backing methods:

        • codex_apps.pets.list_pets.
        • codex_apps.pets.get_pet_download_link.
        • codex_apps.pets.select_pet.
        • codex_apps.pets.delete_pet.
          - Packages:
        • cloud: skill://plugin_connector_1p_bccf6c8660c08191ae4470d9ae4877fa/pets.
        • executor: skill://work-pets@openai-curated-remote/root/.codex/plugins/cache/openai-curated-remote/work-pets/0.1.6/skills/pets.
    • skills.work_pets.update_pet - Inspect, repair, validate, or revise a custom Work pet's metadata or sprite sheet while preserving its identity.

      • Advertised name: work-pets:update-pet; authority: cloud and executor.
      • Inputs: An identified custom Work pet and requested metadata or sprite-sheet changes.
      • Outputs: Updated metadata or artwork for the same custom pet identity.
      • Backing methods:

        • codex_apps.pets.list_pets.
        • codex_apps.pets.get_pet_download_link.
        • codex_apps.pets.validate_pet_spritesheet.
        • codex_apps.pets.prepare_pet_upload.
        • codex_apps.pets.update_pet.
          - Packages:
        • cloud: skill://plugin_connector_1p_bccf6c8660c08191ae4470d9ae4877fa/update-pet.
        • executor: skill://work-pets@openai-curated-remote/root/.codex/plugins/cache/openai-curated-remote/work-pets/0.1.6/skills/update-pet.
    • skills.work_skill_creator.skill_creator - Create, validate, install, revise, or remove personal skills and explain their discovery and invocation behavior.

      • Advertised name: work-skill-creator:skill-creator; authority: cloud and executor.
      • Inputs: A skill purpose, supplied skill files, or a requested existing-skill change.
      • Outputs: A created, validated, installed, updated, disabled, or removed personal skill.
      • Packages:

        • cloud: skill://plugin_connector_1p_37308b34410c81919f53bd47798a5250/skill-creator.
        • executor: skill://work-skill-creator@openai-curated-remote/root/.codex/plugins/cache/openai-curated-remote/work-skill-creator/0.1.2/skills/skill-creator.
    • skills.work_visualize.visualize - Build interactive visual explanations, simulations, comparisons, maps, and interface mockups directly within the current conversation.

      • Advertised name: work-visualize:visualize; authority: cloud and executor.
      • Inputs: Data or scenarios and a requested in-conversation visual explanation or mockup.
      • Outputs: An interactive rendered HTML fragment referenced in the final response.
      • Rendering methods: render.visualize_reference.
      • Packages:

        • cloud: skill://plugin_connector_1p_5a9e3a4c16408191a4d3d8e2d76f99ee/visualize.
        • executor: skill://work-visualize@openai-curated-remote/root/.codex/plugins/cache/openai-curated-remote/work-visualize/0.1.5/skills/visualize.
    • skills.writing_blocks.writing_blocks - Present complete requested emails, messages, posts, or short drafts in editable writing blocks with appropriate metadata.

      • Advertised name: writing-blocks:writing-blocks; authority: cloud and executor.
      • Inputs: A complete requested draft and the relevant email, message, social, or standard metadata.
      • Outputs: An editable writing block containing the entire requested text.
      • Rendering methods: render.writing_block.
      • Packages:

        • cloud: skill://plugin_connector_1p_92a9ce34a39c8191a6ec355628654e53/writing-blocks.
        • executor: skill://writing-blocks@openai-curated-remote/root/.codex/plugins/cache/openai-curated-remote/writing-blocks/0.1.1/skills/writing-blocks.
  • Built-in artifact skills

    • skills.builtins.documents - Create and revise Word documents, including comments and tracked changes, then render and inspect their final layout.

      • Advertised name: documents; authority: executor.
      • Inputs: Document content, an existing Word file, or requested tracked edits and comments.
      • Outputs: A rendered and verified Word document with the requested revisions.
      • Packages:

        • executor: skill://flora-artifact-skills/root/.codex/skills/builtins/documents.
    • skills.builtins.pdf - Read, create, fill, inspect, and render PDF documents when extraction, forms, or page layout require precise handling.

      • Advertised name: pdf; authority: executor.
      • Inputs: A PDF, source content, form values, or requested extraction and layout changes.
      • Outputs: Extracted content or a created, filled, edited, and verified PDF.
      • Packages:

        • executor: skill://flora-artifact-skills/root/.codex/skills/builtins/pdf.
    • skills.builtins.presentations - Read, create, or edit PowerPoint and Google Slides presentations with the appropriate native or file-based artifact workflow.

      • Advertised name: Presentations; authority: executor.
      • Inputs: A presentation brief, reference material, or an existing slide deck.
      • Outputs: A created or edited presentation file or native Spaces presentation.
      • Backing methods:

        • codex_apps.chatgpt_space.create_presentation.
        • codex_apps.chatgpt_space.inspect_artifact.
        • codex_apps.chatgpt_space.execute_artifact_code.
        • codex_apps.chatgpt_space.upload_artifact_images.
          - Packages:
        • executor: skill://flora-artifact-skills/root/.codex/skills/builtins/presentations.
    • skills.builtins.spreadsheets - Create, modify, analyze, and visualize spreadsheets with formulas, recalculation, formatting, tables, and charts as needed.

      • Advertised name: Spreadsheets; authority: executor.
      • Inputs: A spreadsheet, tabular data, or a requested analytical or modeling task.
      • Outputs: An analyzed or updated spreadsheet with appropriate formulas, formatting, or charts.
      • Backing methods:

        • codex_apps.chatgpt_space.inspect_artifact.
        • codex_apps.chatgpt_space.execute_artifact_code.
          - Packages:
        • executor: skill://flora-artifact-skills/root/.codex/skills/builtins/spreadsheets.
  • System skills

    • skills.system.openai_docs - Resolve questions about Codex, ChatGPT Work, OpenAI products, and APIs using the available authoritative documentation workflow.

      • Advertised name: openai-docs; authority: executor.
      • Inputs: A question about Codex, ChatGPT Work, OpenAI products, or OpenAI APIs.
      • Outputs: An answer grounded through the available authoritative documentation route.
      • Packages:

        • executor: skill://flora-system-skills/root/.codex/skills/.system/openai-docs.
  • Personal skills

    • skills.personal.read_tarot - Draw three random tarot cards for a daily reading or stated question and provide a thoughtful interpretation.

      • Advertised name: read-tarot; authority: executor and cloud.
      • Inputs: A question or request for today's three-card reading.
      • Outputs: Three randomly drawn cards and a thoughtful interpretive reading.
      • Packages:

        • executor: skill://flora-user-skills/root/.codex/skills/remote-skills/skill-6add282cc65481919db06018c4e13732.
        • cloud: skill://user/6add282cc65481919db06018c4e13732/read-tarot.

Additional on-disk skills

These definitions are outside the registered skill list. Their source files and documented interfaces are listed below; registry activation is unspecified.

  • System skill files

    • cached.system.review_agent - Review a specified code change without modifications and report concrete actionable defects ordered by severity.

      • Declared skill name: review-agent; source: /root/.codex/skills/.system/review-agent/SKILL.md.
      • Inputs: A delegated code-review target, diff, commit, or custom instructions.
      • Outputs: Prioritized findings with file locations, overall assessment, and material verification gaps.
      • RPC methods: none exposed.
    • cached.system.skill_creator - Create or update scoped Codex skills with appropriate resources, concise guidance, metadata, and meaningful validation.

      • Declared skill name: skill-creator; source: /root/.codex/skills/.system/skill-creator/SKILL.md.
      • Inputs: A requested Codex skill or a scoped update to an existing skill.
      • Outputs: Skill instructions, supporting resources where needed, and validation results.
      • RPC methods: none exposed.
      • Documented helper interfaces: scripts/init_skill.py, scripts/generate_openai_yaml.py, and scripts/quick_validate.py; these are file-oriented CLI helpers, not exposed plugin functions.
    • cached.system.skill_installer - Discover installable curated skills or install selected skill folders from a specified supported repository location.

      • Declared skill name: skill-installer; source: /root/.codex/skills/.system/skill-installer/SKILL.md.
      • Inputs: A curated listing request or a selected repository and skill path.
      • Outputs: An installable-skill list or installed skill folder; network access is required.
      • RPC methods: none exposed.
      • Documented helper interfaces (CLI, not RPC tools):

        • scripts/list-skills.py [--format json] [--path skills/.experimental] — inputs select repository listing and output format; returns skill names with installation annotations.
        • scripts/install-skill-from-github.py --repo <owner>/<repo> --path <paths...> or --url <repository-tree-url> — inputs select skill folders; returns installed folders or an error.
        • Install options include --ref, --dest, --method auto|download|git, and --name; network access is required for repository operations.
  • Additional OAI guides

    • cached.oai.answers_pronunciation - Render precise pronunciation practice for a word, phrase, sentence, or supported direct translation pronunciation request.

      • Declared skill name: answers-pronunciation; source: /root/.codex/skills/oai/answers-pronunciation/SKILL.md.
      • Inputs: An exact pronunciation target or a short source phrase and target language.
      • Outputs: The pronunciation rendering contract also documented under answers-learning.
      • RPC methods: none exposed.
      • Rendering method: render.language_learning_block_widget_pronunciation; see its shared declared input schema below.
    • cached.oai.answers_quizzes - Create objective single-answer multiple-choice quizzes with four options, useful hints, and verified feedback for every answer.

      • Declared skill name: answers-quizzes; source: /root/.codex/skills/oai/answers-quizzes/SKILL.md.
      • Inputs: An explicit objective quiz request with topic, difficulty, language, and optional sources.
      • Outputs: The quiz rendering contract also documented under answers-learning.
      • RPC methods: none exposed.
      • Rendering method: render.learning_quiz; see its shared declared input schema below.
  • Productivity — artifact routers

    • cached.documents_router.document - Route an explicitly selected document request to the advertised preinstalled document capability without defining additional methods.

      • Declared skill name: document; source: /root/.codex/plugins/cache/openai-curated-remote/documents-router/0.1.5/skills/documents-router/SKILL.md.
      • Inputs: An explicit @document selection.
      • Outputs: Handoff to the active documents skill; no standalone RPC method.
      • RPC methods: none exposed.
    • cached.pdf_router.pdf - Route an explicitly selected PDF request to the advertised preinstalled PDF capability and its existing workflow.

      • Declared skill name: pdf; source: /root/.codex/plugins/cache/openai-curated-remote/pdf-router/0.1.3/skills/pdf-router/SKILL.md.
      • Inputs: An explicit @pdf selection.
      • Outputs: Handoff to the active PDF skill; no standalone RPC method.
      • RPC methods: none exposed.
    • cached.presentations_router.presentation - Route explicitly selected presentation requests to the supported presentation handoff or the installed slide creation workflow.

      • Declared skill name: presentation; source: /root/.codex/plugins/cache/openai-curated-remote/presentations-router/0.1.5/skills/presentations-router/SKILL.md.
      • Inputs: An explicit @presentation selection.
      • Outputs: Presentation handoff where available, otherwise the active Presentations skill.
      • RPC methods: none exposed.
    • cached.spreadsheets_router.spreadsheet - Route an explicitly selected spreadsheet request to the advertised preinstalled spreadsheet capability without duplicating its implementation.

      • Declared skill name: spreadsheet; source: /root/.codex/plugins/cache/openai-curated-remote/spreadsheets-router/0.1.5/skills/spreadsheets-router/SKILL.md.
      • Inputs: An explicit @spreadsheet selection.
      • Outputs: Handoff to the active Spreadsheets skill; no standalone RPC method.
      • RPC methods: none exposed.

Additional copies of registered guides

Alternative paths for the named registered workflows:

  • /root/.codex/skills/oai/answers-charts/SKILL.md — additional guide for answers-charts:answers-charts.
  • /root/.codex/skills/oai/answers-images/SKILL.md — additional guide for answers-images:answers-images.
  • /root/.codex/skills/oai/personal-context/SKILL.md — additional guide for personal-context:personal-context.
  • /root/.codex/skills/oai/resolve-recipients/SKILL.md — additional guide for resolve-recipients:resolve-recipients.
  • /root/.codex/skills/oai/skill-creator/SKILL.md — additional guide for work-skill-creator:skill-creator.
  • /root/.codex/skills/oai/visualize/SKILL.md — additional guide for work-visualize:visualize.
  • /root/.codex/skills/oai/writing-blocks/SKILL.md — additional guide for writing-blocks:writing-blocks.

Rendering contracts

Named widgets use the exact GenUI keys below. Markup forms identify response syntax rather than callable functions. None returns CallToolResult.

  • Productivity — named widgets

    • render.charts_widget_v2 - Render one interactive quantitative chart from an inline specification containing chart mappings, series definitions, and data.

      • Method: GenUI key charts_widget_v2.
      • Inputs:
        ⎗
        ✓
        1
        2
        3
        type ChartsWidgetV2Parameters = {
          content: { [key: string]: any };
        };
        
      • Output: One rendered chart.
      • Constraints:

        • content.chartType is bar, line, pie, or scatter. meta contains title, description, and optional footer; data contains inline row objects.
        • xKey identifies the x field. xAxisScale may be linear only for a numeric line axis; xAxisLabel is optional.
        • series entries contain dataKey and optional label, axisLabel, valueFormat (compact, integer, raw), valuePrefix, valueSuffix, and bar stack.
        • yAxisMin and yAxisMax optionally bound the shared y-axis. layout=vertical produces horizontal bars; pie charts require nameKey and valueKey.
        • Percent suffixes use percentage-point data. One invocation represents one chart.
    • render.ask_user_input - Collect preferences using selectable options and question-specific free-text responses that guide the next conversational answer.

      • Method: GenUI key ask_user_input.
      • Inputs:
        ⎗
        ✓
        1
        2
        3
        4
        5
        6
        7
        8
        type AskUserInputParameters = {
          questions: Array<{
            question: string;
            options: string[];
            type: "single_select" | "multi_select";
            free_text_placeholder: string;
          }>;
        };
        
      • Output: An interactive questionnaire followed by user responses.
      • Constraints:

        • One to three questions; each contains 2–10 options, usually 2–4. A question-specific free_text_placeholder is required.
        • single_select records one choice; multi_select accepts several choices.
    • render.async_image_group - Display retrieved image results as a carousel, bento arrangement, or full-width gallery for useful visual context.

      • Method: GenUI key async_image_group.
      • Inputs:
        ⎗
        ✓
        1
        2
        3
        4
        5
        type AsyncImageGroupParameters = {
          query?: string | string[] | null;
          layout?: "carousel" | "bento" | "full_width";
          numPerQuery?: number;
        };
        
      • Output: An asynchronously populated image group.
      • Constraints:

        • query defaults to null; layout defaults to carousel; numPerQuery is an integer from 1–5, default one.
        • Bento introduces one focal entity at the top of an answer.
    • render.image_picker - Present exactly three generated visual alternatives with unique identifiers and continuation context for the selected direction.

      • Method: GenUI key image_picker.
      • Inputs:
        ⎗
        ✓
        1
        2
        3
        4
        5
        6
        7
        8
        9
        type ImagePickerParameters = {
          question: string;
          options: Array<{
            id: string;
            title: string;
            image_path: string;
            selection_context: string;
          }>;
        };
        
      • Output: The selected option identifier and its continuation context.
      • Constraints:

        • Exactly three options with unique IDs, nonempty selection_context, and real generated absolute image paths.
    • render.learning_quiz - Render objective single-answer quizzes with four choices per question, hidden hints, and feedback for every option.

      • Method: GenUI key learning_quiz.
      • Inputs:
        ⎗
        ✓
        type LearningQuizParameters = {
          title: string;
          nextQuizQuery: string;
          questions: Array<{
            id: string;
            question: string;
            type: "single_select";
            options: Array<{
              value: string;
              label: string;
              feedback: string;
            }>;
            correctValues: string[];
            hint: string;
          }>;
          locale_override?: string;
        };
        
      • Output: An interactive objective quiz with answer feedback and a follow-up query.
      • Constraints:

        • One to twenty questions; exactly four options ordered A–D and one correctValues entry per question.
        • title, nextQuizQuery, question, labels, feedback, and hints are nonempty. Question IDs are 1–64 characters; option values are 1–8.
        • Prompts and labels support Markdown; hints and feedback use plain text. locale_override selects a different response locale.
    • render.language_learning_block_widget_pronunciation - Render pronunciation practice with exact source text, a canonical learner-facing hint, and optional language or reading disambiguation.

      • Method: GenUI key language_learning_block_widget_pronunciation.
      • Inputs:
        ⎗
        ✓
        1
        2
        3
        4
        5
        6
        type PronunciationParameters = {
          source_text?: string;
          pronunciation_hint?: string;
          pronunciation_audio_text?: string | null;
          pronunciation_language?: string | null;
        };
        
      • Output: A pronunciation practice block.
      • Constraints:

        • source_text and pronunciation_hint default to empty strings; audio text and language default to null.
        • pronunciation_language uses BCP-47 where known. Audio text disambiguates a selected established reading.
  • Productivity — markup and reference forms

    • render.visualize_reference - Display an interactive HTML fragment inside the conversation with an optional wide presentation mode when appropriate.

      • Method: response markup/reference form.
      • Inputs: visualize content reference containing path: string, optional mode: "wide", and optional title.
      • Returns: A rendered interactive conversation surface; no function return object.
      • Variants: Default-width and wide reference forms; the HTML fragment contains the visual's local interactions.
    • render.writing_block - Present complete requested draft text in an editable block using metadata appropriate to its communication format.

      • Method: response markup/reference form.
      • Inputs: :::writing directive with variant, unique five-digit id, and complete draft content; email additionally requires subject and may include a known recipient.
      • Returns: An editable complete draft; no RPC result object.
      • Variants: email, chat_message, social_post, or standard; non-email variants omit subject and recipient.
    • render.static_app_preview - Render one complete self-contained HTML or supported React implementation as an immediately usable inline application preview.

      • Method: response markup/reference form.
      • Inputs: One fenced code block tagged html preview, jsx preview, or tsx preview; the implementation is self-contained and imports no external files.
      • Returns: A standalone inline application preview; no RPC result object.
      • Variants: HTML or supported JSX/TSX; this form defers to Sites for website and web app work.

Plugin directory

Directory records describe advertised integrations. AVAILABLE means eligible to install, not connected. Search supplies bounded query results without an exhaustive enumeration or continuation cursor. All records below have GLOBAL scope.

Provider methods and input/return schemas are unpublished for every uninstalled directory entry. Installed interface bindings are identified individually.

  • Productivity — installed by default (3) — ENABLED; INSTALLED_BY_DEFAULT; installed=true.

    • directory.documents - Route an explicitly selected document request to the environment's preinstalled document creation and editing capability.

      • Plugin: Documents; name documents-router; ID plugin_connector_1p_a99a3ddcf0f0819180a5856331428a87.
      • Methods: cached.documents_router.document; contracts appear in their corresponding reference entries.
    • directory.sites - Build and deploy websites using the installed Sites workflow and its separately documented exposed hosting methods.

      • Plugin: Sites; name sites; ID plugin_connector_1p_689987207de08191979cf68eca2941c6.
      • Methods: codex_apps.sites; contracts appear in their corresponding reference entries.
    • directory.spreadsheets - Route explicitly selected spreadsheet requests to the environment's preinstalled spreadsheet analysis, creation, and editing capability.

      • Plugin: Spreadsheets; name spreadsheets-router; ID plugin_connector_1p_c44dd7517dbc8191ad66ed121cebc685.
      • Methods: cached.spreadsheets_router.spreadsheet; contracts appear in their corresponding reference entries.
  • Category not supplied — available to install (111) — ENABLED; AVAILABLE; installed=false.

    • directory.actively - Use account agents to combine sales context and external signals into prioritized account actions.

      • Plugin: Actively; name actively; ID plugin_asdk_app_6a15fca0d57c8191a204ffdd12fbbef2.
    • directory.adobe - Create and edit visual media and documents using advertised Creative Cloud and Acrobat capabilities.

      • Plugin: Adobe; name app-69312da8e4dc81919370cb86fd172b6c; ID plugin_asdk_app_69312da8e4dc81919370cb86fd172b6c.
    • directory.adobe_acrobat - Transform PDFs through page editing, conversion, redaction, text recognition, compression, and organized document assembly.

      • Plugin: Adobe Acrobat; name app-6938a7d323f48191aeabaf579802bf45; ID plugin_asdk_app_6938a7d323f48191aeabaf579802bf45.
    • directory.ahrefs - Analyze search keywords, backlinks, rankings, competitor traffic, and brand visibility using connected marketing intelligence.

      • Plugin: Ahrefs; name app-6966958473488191b775fdb667c52eab; ID plugin_asdk_app_6966958473488191b775fdb667c52eab.
    • directory.airtable - Read, analyze, create, and update structured records in connected bases during ongoing project work.

      • Plugin: Airtable; name airtable; ID plugin_asdk_app_693ca6ce2db08191bb52d66743c65184.
    • directory.alation - Ground enterprise data discovery in catalog metadata, governance policies, semantic definitions, lineage, and trusted documentation.

      • Plugin: Alation; name alation; ID plugin_asdk_app_6a0f9ab98bf4819197de479522d5367b.
    • directory.amplitude - Explore product events, query metrics and experiments, and manage connected analytics charts, dashboards, or alerts.

      • Plugin: Amplitude; name amplitude; ID plugin_connector_690e2dabf430819196f8b3701ec838ec.
    • directory.apollo_io - Research prospects and accounts, enrich records, and prepare sales outreach using authenticated workspace context.

      • Plugin: Apollo.io; name apollo; ID plugin_asdk_app_69bd664f2a908191a3a0a47eca8559d1.
    • directory.asana - Review tasks, subtasks, comments, due dates, and projects to understand priorities and prepare status updates.

      • Plugin: Asana; name asana; ID plugin_asdk_app_69616780bd208191b4fb44ba44f72b61.
    • directory.atlassian - Work with Jira issues, Confluence pages, and other connected Atlassian collaboration resources from the conversation.

      • Plugin: Atlassian; name app-6a83901dde988191b3f3cefdcc19acfa; ID plugin_asdk_app_6a83901dde988191b3f3cefdcc19acfa.
    • directory.attio - Search and organize CRM records, manage contacts and deals, and maintain related notes or tasks.

      • Plugin: Attio; name attio; ID plugin_asdk_app_6981f663d5cc8191ae0d5717a05ccc89.
    • directory.aws_data_analytics - Explore data catalogs, ingestion pipelines, managed tables, and analytical queries across advertised AWS data services.

      • Plugin: AWS Data Analytics; name app-6a917708c64481918f7ddea0cef4b8e6; ID plugin_asdk_app_6a917708c64481918f7ddea0cef4b8e6.
    • directory.azure_cosmos_db - Apply provider skills for NoSQL data modeling, querying, indexing, vector search, security, and development practices.

      • Plugin: Azure Cosmos DB; name azure-cosmosdb; ID plugins_6a7bec8e2dc881919fc93f62e4329ee2.
    • directory.box - Search and organize enterprise files, compare documents, extract metadata, and collaborate through comments or shared links.

      • Plugin: Box; name box; ID plugin_asdk_app_695bfc98071c8191bac7bc479aa27de7.
    • directory.calendly - Manage scheduling event types, availability, booking links, and meeting bookings through the connected scheduling service.

      • Plugin: Calendly; name calendly; ID plugin_asdk_app_69d7f67021c88191bb8aac736eff6cb3.
    • directory.canva - Create and revise designs, presentations, documents, social assets, and generated imagery through connected design workflows.

      • Plugin: Canva; name canva; ID plugin_connector_68df33b1a2d081918778431a9cfca8ba.
    • directory.chatgpt_ads_manager - Manage advertising accounts and campaigns, inspect performance, and upload creative assets through available advertising operations.

      • Plugin: ChatGPT Ads Manager; name ads-manager; ID plugin_connector_1p_2eb0f69766cc81919c6912b2a2e0755a.
    • directory.clay - Find and engage sales prospects through the directory's advertised prospecting capability when the integration becomes connected.

      • Plugin: Clay; name clay; ID plugin_asdk_app_69377d07cd9c8191a988f06f15b8c674.
    • directory.clickhouse - Inspect cloud services, databases, tables, pipelines, backups, and costs while running advertised read-only SQL queries.

      • Plugin: ClickHouse; name app-6a57330f603c8191928119af462402b2; ID plugin_asdk_app_6a57330f603c8191928119af462402b2.
    • directory.close - Use searchable sales communications and CRM records to prepare deal summaries, follow-ups, and outreach workflows.

      • Plugin: Close; name close; ID plugin_asdk_app_694574813e548191bac45327be0a61d1.
    • directory.context7 - Retrieve current library documentation and code examples to improve software answers beyond static training knowledge.

      • Plugin: Context7; name app-69ef18c674308191a2f952431f91ea61; ID plugin_asdk_app_69ef18c674308191a2f952431f91ea61.
    • directory.data - Answer product and business questions using the directory's advertised data analysis capability after connecting it.

      • Plugin: Data; name data-analytics; ID Plugin_fc9843a6fb34819195d6c7802398a8a7.
    • directory.databricks_genie - Analyze connected Databricks information through Genie and manage advertised AI and business intelligence dashboards.

      • Plugin: Databricks Genie; name databricks; ID Plugin_1e24c86b19248191a8c6abb5bc115819.
    • directory.datadog - Investigate observability metrics, logs, traces, dashboards, incidents, hosts, and related monitoring context through connected tools.

      • Plugin: Datadog; name datadog; ID plugin_asdk_app_69e8c7f174a08191a28b6da96c8062c4.
    • directory.datadog_experiments - Work with advertised product analytics, feature flags, and experimentation capabilities in the connected Datadog environment.

      • Plugin: Datadog Experiments; name app-6a7c7752de408191a101b78e59fda025; ID plugin_asdk_app_6a7c7752de408191a101b78e59fda025.
    • directory.deepnote - Search notebooks and integrations, run analytical workflows, and retrieve results from the authenticated workspace.

      • Plugin: Deepnote; name deepnote; ID plugin_asdk_app_69fb51f9519081919c1f3e44ea9a5a05.
    • directory.descript - Import and edit media, publish sharing links, and export transcripts or supported video editing timelines.

      • Plugin: Descript; name app-69f0dc45f6048191876c14c1016fe778; ID plugin_asdk_app_69f0dc45f6048191876c14c1016fe778.
    • directory.docusign - Create and manage agreements, retrieve contract obligations, and automate advertised workflows through the connected service.

      • Plugin: Docusign; name docusign; ID plugin_asdk_app_69fcc3b7582c81918df4ffae40cb7204.
    • directory.dropbox - Access, save, and share files through the directory's advertised Dropbox integration after its connection is established.

      • Plugin: Dropbox; name app-69b31dc2110c8191b8b47dc98fe5a052; ID plugin_asdk_app_69b31dc2110c8191b8b47dc98fe5a052.
    • directory.figma - Create and review editable designs, work with design system components, and produce Slides or FigJam artifacts.

      • Plugin: Figma; name figma; ID plugin_connector_68df038e0ba48191908c8434991bbac2.
    • directory.finances - Connect financial accounts and obtain personalized insights through the directory's advertised authenticated financial data integration.

      • Plugin: Finances; name finances; ID plugin_connector_693864f100e4819093e6ed9b651239f1.
    • directory.firebase - Manage projects, add backend services, develop AI features, and deploy or host applications with provider guidance.

      • Plugin: Firebase; name firebase; ID plugins_6a8ddf314ab88191864c208fda197798.
    • directory.firecrawl - Search and extract web content, crawl sites, run structured research, and inspect advertised browsing capabilities.

      • Plugin: Firecrawl; name app-6a314a73f8ac819195b0d55e36b9c609; ID plugin_asdk_app_6a314a73f8ac819195b0d55e36b9c609.
    • directory.fireflies - Search meeting knowledge and extract insights, action items, feedback, and relevant context from recorded conversations.

      • Plugin: Fireflies; name fireflies; ID plugin_connector_6912075cb358819187346bcafb601db8.
    • directory.g2_mcp - Compare software using verified product reviews and research boards, with advertised buyer intent intelligence.

      • Plugin: G2 MCP; name app-6998622475e081918795d4f4c5e42df4; ID plugin_asdk_app_6998622475e081918795d4f4c5e42df4.
    • directory.github - Inspect repositories, triage issues and pull requests, diagnose continuous integration, and publish authorized code changes.

      • Plugin: GitHub; name github; ID plugin_connector_1p_1a69035c238881919c4190932b2df699.
    • directory.gmail - Access Gmail through the configured provider integration; exact message operations depend on its exposed connected tools.

      • Plugin: Gmail; name gmail; ID plugin_connector_1p_95d39881713c8191931482a62d6edff9.
    • directory.google_calendar - Support scheduling, availability checks, daily briefings, and event management through an authenticated Google Calendar connection.

      • Plugin: Google Calendar; name google-calendar; ID plugin_connector_1p_f8509de903288191b14a160c6c5d20b0.
    • directory.google_contacts - Find people and their contact details through the directory's advertised authenticated Google Contacts integration.

      • Plugin: Google Contacts; name google-contacts; ID plugin_connector_1p_c97194162860819190a6f840a61b9889.
    • directory.google_drive - Use one connected entry point for Drive files and Google Docs, Sheets, and Slides workflows.

      • Plugin: Google Drive; name google-drive; ID plugin_connector_1p_ab21a553bfbc81919ea8fd1858e3ffa7.
    • directory.granola - Retrieve past meeting context to support documents, proposals, presentations, decisions, and ongoing project work.

      • Plugin: Granola; name granola; ID plugin_asdk_app_697761cab6f48191b5ed345919a3ce8b.
    • directory.health - Connect and explore personal health information through the directory's advertised health data integration after authorization.

      • Plugin: Health; name health; ID plugin_connector_1p_e569f8b8dfd08191903c9bd2cd7da9ac.
    • directory.hex - Answer data questions and start new analytical work using the directory's advertised connected Hex Agent.

      • Plugin: Hex; name hex; ID plugin_connector_690a9430a270819196671dcb4c95898e.
    • directory.heygen - Generate avatar videos, voiceovers, translations, dubbing, and short clips for training, marketing, or product demonstrations.

      • Plugin: HeyGen; name heygen; ID plugin_asdk_app_69418aad55e08191aa5e437b649ca2e4.
    • directory.hg_insights_rgi - Research companies, technology stacks, decision makers, spending, and contracts using connected revenue growth intelligence.

      • Plugin: HG Insights - RGI; name hg-insights; ID plugin_asdk_app_694638aebbec8191a888262fa0ea8561.
    • directory.higgsfield - Generate and edit images, videos, and product advertising using references, creative commands, and available media models.

      • Plugin: Higgsfield; name app-6a3293e129088191abf0875820e839da; ID plugin_asdk_app_6a3293e129088191abf0875820e839da.
    • directory.hostinger_mail - Discover mailbox operations, read or search messages, send email, and manage advertised message or webhook state.

      • Plugin: Hostinger Mail; name app-6a323a8a890c819190480c9044395170; ID plugin_asdk_app_6a323a8a890c819190480c9044395170.
    • directory.hubspot - Analyze CRM data and manage authorized contacts, companies, deals, tickets, engagements, tasks, and pipeline updates.

      • Plugin: HubSpot; name hubspot; ID plugin_asdk_app_697acb8e53d88191bf7a79e62012ae14.
    • directory.icloud_calendar - Read and manage calendars, events, and associated contacts through the advertised connected iCloud Calendar integration.

      • Plugin: iCloud Calendar; name icloud-calendar; ID plugin_connector_6a99cb684648819088fe4d6a0e373614.
    • directory.icloud_mail - Read and manage mail messages and associated contacts through the advertised authenticated iCloud Mail integration.

      • Plugin: iCloud Mail; name icloud-mail; ID plugin_connector_6a99cb6846448190875813bf1e8e5504.
    • directory.instacart - Access the directory's advertised grocery and other item delivery service when its integration is connected.

      • Plugin: Instacart; name app-691eab1e001081919e57189f8b2f03bc; ID plugin_asdk_app_691eab1e001081919e57189f8b2f03bc.
    • directory.klaviyo - Analyze marketing campaign and flow performance using send status, engagement metrics, attributed revenue, and contextual recommendations.

      • Plugin: Klaviyo; name app-694421e60cc88191a1e5bb4aa79950e4; ID plugin_asdk_app_694421e60cc88191a1e5bb4aa79950e4.
    • directory.linear - Search, create, and update issues, projects, or initiatives while maintaining plans and drafting product documentation.

      • Plugin: Linear; name linear; ID plugin_asdk_app_69a089a326dc8191b32a3f2553f5be2c.
    • directory.lovable - Build and edit full-stack applications from prompts, inspect generated code, add data services, and publish projects.

      • Plugin: Lovable; name lovable; ID plugin_asdk_app_693a0a79ffe48191901173077edcf914.
    • directory.magicpath - Create editable interface designs, interactive website prototypes, dashboards, and visual plans on a shared canvas.

      • Plugin: MagicPath; name app-6a883213fb288191aa91f89a5db31f60; ID plugin_asdk_app_6a883213fb288191aa91f89a5db31f60.
    • directory.meticulate - Find prospects, manage audiences and outbound sequences, review drafts, and calibrate sales targeting or messaging changes.

      • Plugin: Meticulate; name meticulate; ID plugin_asdk_app_69f8fe2bcac08191b6025acec161ce1e.
    • directory.metricool - Inspect social accounts and analytics, review scheduled content, identify posting times, and manage advertised posts.

      • Plugin: Metricool; name app-69d73fc8aa5c8191bec1583760b130c7; ID plugin_asdk_app_69d73fc8aa5c8191bec1583760b130c7.
    • directory.microsoft_power_bi - Explore reports, build visuals, and publish dashboards using the advertised Power BI desktop browser workflow.

      • Plugin: Microsoft Power BI; name power-bi; ID Plugin_52b7f269362c819190348f32a2f9e7a9.
    • directory.mixpanel - Analyze events, segmentation, funnels, and retention while maintaining event taxonomy metadata and diagnosing data quality.

      • Plugin: Mixpanel; name mixpanel; ID plugin_asdk_app_69b2e9aed45c8191b254b207dfcc2bb4.
    • directory.monday_com - Manage boards, items, owners, timelines, updates, and advertised automation workflows for project or CRM operations.

      • Plugin: monday.com; name monday-com; ID plugin_connector_690aabb71bf481918b8d5b614ed3fd4c.
    • directory.mongodb_atlas - Query and modify documents, inspect schemas and indexes, and manage advertised database infrastructure or streaming pipelines.

      • Plugin: MongoDB Atlas; name app-6a5fa5e2392c8191824fb0340191afba; ID plugin_asdk_app_6a5fa5e2392c8191824fb0340191afba.
    • directory.motherduck - Explore and visualize warehouse data, investigate analytical questions, and create shareable Dives using connected datasets.

      • Plugin: MotherDuck; name motherduck; ID plugin_asdk_app_696a54f1c91c81919002b9153ce0e336.
    • directory.neon - Manage advertised Postgres services, branches, object storage, functions, and AI gateway capabilities through provider tools.

      • Plugin: Neon; name neon-postgres; ID plugin_asdk_app_69e0086d87088191a3edc052fa50c29f.
    • directory.notion - Search workspace knowledge, create or update pages, and maintain project tasks or structured database records.

      • Plugin: Notion; name notion; ID plugin_asdk_app_69c18c28f1188191bf5b8445c4ab0a2e.
    • directory.omni - Discover governed models, run analytical queries, launch deeper assistant jobs, and search related product documentation.

      • Plugin: Omni; name omni-analytics; ID plugin_asdk_app_694e8b8715108191a49fe2db4398d9e2.
    • directory.openai_developers - Build AI applications and agents using the directory's advertised OpenAI development guidance and best practices.

      • Plugin: OpenAI Developers; name openai-developers; ID plugin_connector_1p_32dba5a7095c8191adca04ee30276304.
    • directory.otter_ai - Search meeting records and retrieve speaker-attributed transcripts, summaries, action items, and relevant historical discussion.

      • Plugin: Otter.ai; name otter-ai; ID plugin_asdk_app_695d84e2f06c8191861b9bac9b3fd53b.
    • directory.outlook_calendar - Support scheduling, daily briefings, meeting preparation, and authorized event changes through connected Microsoft Outlook Calendar.

      • Plugin: Outlook Calendar; name outlook-calendar; ID plugin_connector_1p_fd0f4f41caa88191a9456514bbffa06d.
    • directory.outlook_email - Access Outlook Email through its configured provider integration; connected tool exposure determines exact message operations.

      • Plugin: Outlook Email; name outlook-email; ID plugin_connector_1p_6bcb5879c73c819196abc70016166099.
    • directory.outreach - Use connected revenue platform knowledge and actions to support sales workflows, pipeline visibility, and account execution.

      • Plugin: Outreach; name outreach; ID plugin_asdk_app_6a0783e216e48191957d34a5381e3b06.
    • directory.plaud - Search voice recordings, extract structured information, and synthesize summaries or artifacts from the connected recording collection.

      • Plugin: Plaud; name app-69f3c30d68288191bbd428a394a78407; ID plugin_asdk_app_69f3c30d68288191bbd428a394a78407.
    • directory.plugin_creator - Create and improve reusable plugins from supplied ideas, instructions, and workflows using the directory's advertised capability.

      • Plugin: Plugin Creator; name plugin-creator; ID plugin_connector_1p_e1a10c53223481918a42f1510ec46c1e.
    • directory.posthog - Investigate product analytics, feature flags, experiments, errors, surveys, logs, and advertised application monitoring data.

      • Plugin: PostHog; name posthog; ID plugin_asdk_app_699caef2d680819188727b0ddbb349dd.
    • directory.product_design - Explore product directions, audit user flows, and turn live pages or screenshots into reviewable interactive prototypes.

      • Plugin: Product Design; name product-design; ID Plugin_fa77aec24fc08191bc6e57f377126d76.
    • directory.railway - Create and launch applications, manage projects, inspect their performance, and troubleshoot connected deployments with provider guidance.

      • Plugin: Railway; name app-6a502589384081919c5decf93496c9d1; ID plugin_asdk_app_6a502589384081919c5decf93496c9d1.
    • directory.redis - Apply provider development guidance for data modeling, search, caching, connections, clustering, security, observability, and agent memory.

      • Plugin: Redis; name redis-development; ID plugins_6a85b91f8aa081918a9daf1444559586.
    • directory.render - Build and deploy applications or agents through the directory's advertised connected Render hosting and deployment capability.

      • Plugin: Render; name app-6a624c56bfe081918f7544f7d58f6faf; ID plugin_asdk_app_6a624c56bfe081918f7544f7d58f6faf.
    • directory.replit - Turn prompts into running hosted applications, then refine their behavior, inspect implementations, and evaluate deployment readiness.

      • Plugin: Replit; name replit; ID plugin_asdk_app_6934801c799081918131791660f02890.
    • directory.rox - Discover sales data functions and inspect read-only account intelligence across deals, contacts, meetings, documents, and communications.

      • Plugin: Rox; name rox; ID plugin_asdk_app_6a1480a4a93c8191be8b8686d450db0a.
    • directory.runway - Generate or edit images, video, and audio, manage media workflows, and inspect connected assets or credits.

      • Plugin: Runway; name app-6a05e3b201788191be12b590b43e6ce3; ID plugin_asdk_app_6a05e3b201788191be12b590b43e6ce3.
    • directory.scite - Search scientific papers, inspect citation context, format bibliographies, and organize research papers or notes into collections.

      • Plugin: Scite; name scite; ID plugin_asdk_app_6952b3a3f1e881918951582d59483c78.
    • directory.sharepoint - Access SharePoint content through the configured Microsoft provider integration; exact operations require its connected tool definitions.

      • Plugin: SharePoint; name sharepoint; ID plugin_connector_1p_dca009ae2c848191ae14df3a47c5e7fd.
    • directory.shop - Support shopping across merchants through the directory's advertised implementation of the Universal Commerce Protocol.

      • Plugin: Shop; name app-6982cfb482bc81918416ec35e7cc90e5; ID plugin_asdk_app_6982cfb482bc81918416ec35e7cc90e5.
    • directory.shopify - Build and manage online stores, products, inventory, discounts, orders, customers, and advertised business performance analysis.

      • Plugin: Shopify; name shopify; ID plugin_asdk_app_69e65c430b3081919aa4d962ab5d1698.
    • directory.similarweb - Research website and app traffic, keywords, audiences, and competitors using the connected market intelligence platform.

      • Plugin: Similarweb; name similarweb; ID plugin_asdk_app_695cdd7e863c819192b88beffc2033b6.
    • directory.slack - Access Slack through its configured provider integration; exact conversation and messaging methods require its connected tool definitions.

      • Plugin: Slack; name slack; ID plugin_asdk_app_69a1d78e929881919bba0dbda1f6436d.
    • directory.snowflake - Work with databases, schemas, tables, warehouses, search services, containers, and advertised managed MCP capabilities.

      • Plugin: Snowflake; name snowflake; ID Plugin_2af00ca970e88191b55798e3995f2aa3.
    • directory.statsig - Inspect and manage experiments, feature gates, metric definitions, targeting rules, and advertised dynamic configuration changes.

      • Plugin: Statsig; name statsig; ID plugin_asdk_app_6967f065ac9481918969c660ff7686e9.
    • directory.stripe - Develop payment integrations using provider skills, implementation best practices, API upgrade guidance, and configured remote tools.

      • Plugin: Stripe; name stripe; ID plugin_connector_690ab09fa43c8191bca40280e4563238.
    • directory.supabase - Query PostgreSQL, modify schemas, deploy functions, configure authentication, inspect logs, and manage advertised migrations or branches.

      • Plugin: Supabase; name supabase; ID plugin_asdk_app_69d3e5ee6a708191baa733f7b8931995.
    • directory.superhuman_mail - Search email and calendars, draft replies, inspect read status, and perform advertised messaging or scheduling workflows.

      • Plugin: Superhuman Mail; name superhuman; ID plugin_asdk_app_69a21e4058dc8191a6220fa911310d7b.
    • directory.superpowers - Apply an advertised software development framework covering planning, test-driven development, debugging, and collaborative agent workflows.

      • Plugin: Superpowers; name superpowers; ID plugins~Plugin_60aea7460bd4819199fd97a9553a5e12.
    • directory.teams - Access Microsoft Teams through the configured provider integration; exact collaboration methods depend on its connected tools.

      • Plugin: Teams; name teams; ID plugin_connector_1p_eba8b52fe53881918408d4b46b957644.
    • directory.thoughtspot_spottercode - Build embedded analytics and AI features while managing advertised analytical workflows with a connected programming assistant.

      • Plugin: ThoughtSpot SpotterCode; name app-6aa240082b3c81919f204960ce7e0dc0; ID plugin_asdk_app_6aa240082b3c81919f204960ce7e0dc0.
    • directory.ticktick_to_do_list_calendar - Manage synchronized tasks, reminders, calendars, recurring work, and advertised planning or personal organization workflows.

      • Plugin: TickTick:To-Do List & Calendar; name app-69ddbaba3fb48191a825f22c21b0599d; ID plugin_asdk_app_69ddbaba3fb48191a825f22c21b0599d.
    • directory.tinyfish - Automate cloud browser tasks and extract online data using advertised persistent profiles, account access, and scraping capabilities.

      • Plugin: TinyFish; name app-695325bae7348191b58ae9349a963d22; ID plugin_asdk_app_695325bae7348191b58ae9349a963d22.
    • directory.tldraw - Create drawings and diagrams with an AI agent on an interactive canvas within ChatGPT or Codex.

      • Plugin: tldraw; name app-6ab242dbeb5c8191ba5277534ef0c570; ID plugin_asdk_app_6ab242dbeb5c8191ba5277534ef0c570.
    • directory.todoist - Manage tasks, projects, labels, and reminders through the directory's advertised authenticated Todoist task management integration.

      • Plugin: Todoist; name app-6943b73823548191a9f9216c6790c453; ID plugin_asdk_app_6943b73823548191a9f9216c6790c453.
    • directory.trello - Manage connected boards, cards, and tasks through natural-language workflows advertised by the Trello directory integration.

      • Plugin: Trello; name app-6a20b18a639081918c1b438f8381b27e; ID plugin_asdk_app_6a20b18a639081918c1b438f8381b27e.
    • directory.tripsy - Access trip itineraries, reservations, activities, notes, and destinations to summarize travel plans or organize upcoming journeys.

      • Plugin: Tripsy; name app-6a03b72913d88191b464189e99b02d38; ID plugin_asdk_app_6a03b72913d88191b464189e99b02d38.
    • directory.vercel - Build and deploy web applications or AI agents through the directory's advertised connected Vercel platform integration.

      • Plugin: Vercel; name vercel; ID plugin_connector_690a90ec05c881918afb6a55dc9bbaa1.
    • directory.vidiq - Research video ideas, competing creators, keyword demand, audience behavior, and channel performance across advertised content platforms.

      • Plugin: vidIQ; name app-69dd11f3e50c8191b1ca48d03cf7e2ad; ID plugin_asdk_app_69dd11f3e50c8191b1ca48d03cf7e2ad.
    • directory.villagesql_skills - Build VillageSQL extensions and port PostgreSQL extensions using the directory's advertised provider-specific development skills.

      • Plugin: VillageSQL Skills; name villagesql; ID plugins_6a70fadd8f4881919c12bf1c3c81753b.
    • directory.webflow - Design and manage sites, edit CMS content, add integrations, deploy apps, and inspect advertised site performance.

      • Plugin: Webflow; name app-6a0783a98c4c8191841404d786d4a4b9; ID plugin_asdk_app_6a0783a98c4c8191841404d786d4a4b9.
    • directory.windsor_ai - Combine connected marketing and business reporting, with advertised platform-specific campaign changes and social publishing actions.

      • Plugin: Windsor.ai; name windsor-ai; ID plugin_asdk_app_694a52cfaa3c819192bea84eaa254968.
    • directory.wisdomai - Answer enterprise analytical questions using governed definitions, verified queries, traceable sources, and connected organizational context.

      • Plugin: WisdomAI; name app-6a91fcd93878819188347d20f83fe2ee; ID plugin_asdk_app_6a91fcd93878819188347d20f83fe2ee.
    • directory.wix - Build and manage websites, domains, applications, and advertised platform extensions through conversational creation or developer workflows.

      • Plugin: Wix; name wix; ID plugin_asdk_app_6947eaa4edd081919561e4ee3a2e5dcc.
    • directory.wordpress_com - Build and publish WordPress sites through the directory's advertised connected website creation and publishing integration.

      • Plugin: WordPress.com; name app-6a2b62fd753c8191bcff02ac79b54c6b; ID plugin_asdk_app_6a2b62fd753c8191bcff02ac79b54c6b.
    • directory.zoho_crm - Extend connected sales workflows using advertised sales automation, analytics, customization, and CRM management capabilities.

      • Plugin: Zoho CRM; name zoho; ID plugin_asdk_app_6a193ef5e804819197c25f88d92d6bf7.
    • directory.zoom - Retrieve meeting context and support development, debugging, or review of integrations using advertised Zoom platform interfaces.

      • Plugin: Zoom; name zoom; ID plugin_asdk_app_69373a13116c819189d046aea1278836.
    • directory.zoominfo - Research companies, professionals, employment history, contacts, organizational charts, intent, and other advertised sales intelligence signals.

      • Plugin: ZoomInfo; name zoominfo; ID plugin_asdk_app_698a340b9230819188ba5a5eea79022d.
  • Category not supplied — disabled by administrator (4) — DISABLED_BY_ADMIN; NOT_AVAILABLE; installed=false.

    • directory.bigquery - Manage advertised analytics projects, datasets, tables, jobs, access policies, routines, models, and query results.

      • Plugin: BigQuery; name bigquery; ID plugin_connector_1p_b1cefad35a80819184ba7ed35d601d34.
    • directory.dbt - Inspect project metadata and lineage, query semantic metrics, manage jobs, and generate advertised development scaffolding.

      • Plugin: dbt; name app-6a710de0c6b08191a298927933709e4e; ID plugin_templated_apps_6a710de0c6b08191a298927933709e4e.
    • directory.salesforce - Work with advertised sales account briefs, pipeline reviews, queries, plans, assignments, summaries, and authorized record changes.

      • Plugin: Salesforce; name salesforce; ID plugin_asdk_app_697d413990c88191a2bf4799604f8f6c.
    • directory.sigma - Search connected analytical content, query organizational data, and build advertised dashboards or applications through conversation.

      • Plugin: Sigma; name app-6a9b05b3b5e0819197d074e79dfc2e8d; ID plugin_templated_apps_6a9b05b3b5e0819197d074e79dfc2e8d.
  • recommendations.codex_security - Identify the environment's recommended Codex Security integration, whose callable methods and directory availability are currently unspecified.

    • Name: Codex Security; reference codex-security@openai-curated-remote.
    • Directory record and callable input/return contracts: unspecified.

References without exposed method bindings

  • Sites

    • attach_site_to_page — referenced by Page creation; callable contract unavailable.
    • search_sites — referenced by codex_apps.sites.list_sites; callable contract unavailable.
    • list_available_access_groups — referenced by codex_apps.sites.update_site_access; callable contract unavailable.
  • Library

    • list, search, read, find, prepare_materialize, manage_library, and share — documented workflow references without exposed function bindings or complete input/return contracts.
Edit

Pub: 31 Oct 2026 08:25 UTC

Views: 60