Payload schema for adding an MCP server: its name and configuration.

The "apply_patch" tool definition. Parses the patch into hunks, derives the new content for each add/update/move/delete (computing per-file diffs and addition/deletion counts), asks for a single "edit" permission covering all affected paths, applies the writes/removes/moves, runs the configured formatter, publishes file/edit events, refreshes the LSP and appends any diagnostics to the output.

Payload schema for the MCP OAuth callback: the authorization code returned by the provider.

HTTP Basic auth middleware, active only when CLOSEDCODE_SERVER_PASSWORD is set. Accepts credentials via the Authorization header or an auth_token query param; responds 401 when they do not match the configured username/password.

Success schema for removing MCP OAuth credentials: a constant success flag.

Success schema for starting MCP OAuth: the authorization URL plus the opaque OAuth state token.

Replacer for blocks of 3+ lines that anchors on the trimmed first and last lines, then scores candidate blocks by middle-line similarity (Levenshtein-based) and yields the best/only acceptable match's raw substring. Tolerates differences in the interior lines.

Top-level HttpApi combining root, event stream, instance, and PTY-connect APIs, with shared Event/SyncEvent schemas annotated.

Input schema for command: the slash command name plus arguments, optional agent/model/variant, and optional file parts.

Request body schema for sending a command, derived from SessionPrompt.CommandInput minus the path-supplied sessionID.

Request body schema for executing a TUI command, carrying the command string.

gzip-compresses responses when the client accepts gzip, transparently wrapping res.write/res.end through a gzip stream. Skips SSE/streaming endpoints (/event, /global/event, and session message/prompt_async POSTs) so they can flush incrementally.

Effect HttpApi group exposing GET /config, PATCH /config, and GET /config/providers.

Payload selecting the account/org to make active when switching Console orgs.

Replacer for blocks of 3+ lines that anchors on the trimmed first and last lines and accepts a block of the same length only when at least half of its interior non-empty lines match (after trimming), yielding the matching raw substring.

Effect HttpApi group exposing PUT/DELETE /auth/:providerID and POST /log.

Route paths exposed by the control API group.

Request body schema for creating a workspace, derived from Workspace.CreateInput minus projectID, with extra made optional.

Schema describing the decoded pagination cursor payload (message id, time, order, and direction).

Query schema carrying an optional pagination/stream cursor.

Default number of messages returned per page when no limit is supplied.

Default number of sessions returned per page when no limit is supplied.

Schema for diff requests: a required sessionID and optional messageID.

Query-string schema for the diff endpoint, derived from SessionSummary.DiffInput minus the path-supplied sessionID.

Schema for an explicitly disabled LSP server entry ({ disabled: true }). Exposes a derived .zod compatibility schema.

The "edit" tool definition. Validates the arguments, resolves the path, and under a per-file lock either creates the file (when oldString is empty) or applies a find-and-replace (preserving the file's existing line endings and BOM). It asks for "edit" permission, writes and optionally formats the file, publishes edit/update events, computes a trimmed diff plus addition/deletion counts, and appends any LSP diagnostics to the output.

Schema for a single formatter entry: optional disabled flag, command argv, environment variables, and the extensions it applies to. Exposes a derived .zod compatibility schema.

Schema for a single LSP server entry: either Disabled or an object with command, optional extensions, disabled, env, and initialization options. Exposes a derived .zod compatibility schema.

Express error handler. Maps known error types to HTTP status codes (NotFound -> 404, model/auth/worktree validation -> 400, else 500) and serializes them as JSON.

Replacer that interprets backslash escape sequences (\n, \t, \r, quotes, \, $) in the search text, then yields either the unescaped string if found directly or any content block whose own unescaping matches the unescaped search text.

Server lifecycle events published on the bus.

• Connected: emitted when the server has connected ("server.connected").
• Disposed: emitted on global teardown ("global.disposed").

Bus event definitions for session status changes.

Bus event definitions for the todo list.

Effect HttpApi group exposing the GET /event SSE subscribe endpoint.

Route paths exposed by the event API group.

Discriminated-union member schema for the command-execute TUI event.

Discriminated-union member schema for the prompt-append TUI event.

Discriminated-union member schema for the session-select TUI event.

Discriminated-union member schema for the toast-show TUI event.

Effect HttpApi group exposing the experimental endpoints (Console, tools, worktrees, sessions, resources).

Route paths exposed by the experimental API group.

Hono-style middleware that, for mutating requests, snapshots event sequences before and after the handler runs and, if any aggregate advanced, attaches the diff to the response via the x-closedcode-sync header so a proxy can fence reads.

HttpApi definition for the experimental file route group. Bundles the find/list/read/status endpoints under instance-context, workspace-routing, and authorization middleware.

URL path constants for each file route, keyed by endpoint name.

Query schema for endpoints that target a single file by path.

Query schema for the find-file endpoint: search query plus optional dir/type filters and a result limit.

Query schema for the find-symbol endpoint: a workspace symbol search query.

Query schema for the find-text endpoint: a ripgrep search pattern.

Request body schema for forking a session, derived from Session.ForkInput minus the path-supplied sessionID.

The "glob" tool definition. Resolves the search directory (defaulting to the instance directory), asks for glob/external-directory permission, runs ripgrep's file matcher, sorts results newest-first, and truncates to 100 results with a notice when more exist.

HttpApi definition for the global route group. Bundles the health, event-stream, config get/update, dispose, and upgrade endpoints (no instance middleware).

Shared process-wide bus emitter used to relay events across instances.

Schema for a single global event: its directory/project/workspace scope plus a bus or sync event payload.

Success schema for the health endpoint: a constant healthy flag plus the server version.

URL path constants for each global route, keyed by endpoint name.

Payload schema for the upgrade endpoint: an optional target version (latest when omitted).

Success schema for the upgrade endpoint: either success with the new version or failure with an error message.

Shared grep/search tool definition Effect. Resolves the search target (file or directory), asks for grep/external-directory permission, runs the ripgrep search, collects file modification times concurrently, sorts matches newest-first, truncates to 100, and formats the matches grouped by file (long lines clamped to MAX_LINE_LENGTH).

The "grep" tool, built from the shared GrepDefinition (also re-exposed as "search" in tool/search.js).

Schema for a single sync event returned by the history endpoint (uses snake_case aggregate_id on the wire).

Request body schema for the history endpoint: a map of aggregate ID to the last known sequence number.

Replacer that matches blocks after stripping their common leading indentation, so the search text can be matched regardless of how deeply the original block is indented; yields the matching raw substring.

Schema for a session's status: one of "idle", "busy", or "retry" (with attempt count, message, and next-retry timestamp).

Schema for a single todo item: a content description, a status (pending/in_progress/completed/cancelled), and a priority (high/medium/low).

Schema for the formatter config value: either a boolean toggle for built-ins or a record of formatter id to Entry overrides. Exposes a derived .zod schema.

Schema for the lsp config value: either a boolean toggle for built-ins or a record of server id to Entry, checked by requiresExtensionsForCustomServers. Exposes a derived .zod compatibility schema.

Schema for the skills section of the configuration. Carries optional additional skill folder paths and optional remote skill URLs, with a derived zod static for zod-based validation.

Request body schema for initializing a session: the provider/model to use and the seed message ID.

HttpApi definition for the experimental instance read route group. Bundles the dispose/path/vcs/command/agent/skill/lsp/formatter endpoints under instance-context, workspace-routing, and authorization middleware.

Instance HttpApi: all per-instance route groups (config, file, session, sync, etc.).

URL path constants for each instance read route, keyed by endpoint name.

Error raised when a parsed config fails schema validation. Payload carries the file path, optional validation issues, and an optional message.

The "invalid" tool. It is never meant to be invoked deliberately ("Do not use"); it merely echoes back the validation error describing why a previous tool call's arguments were rejected.

Error raised when a config file cannot be parsed as JSON/JSONC. Payload carries the file path and an optional parser message.

Zod-compatible object schema for the keybindings config, derived from KeybindsSchema; exposes .shape so consumers can parse individual fields.

Effect Schema describing every configurable keybinding field and its default.

Schema for the layout config value, one of "auto" or "stretch". Exposes a derived .zod compatibility schema. (Deprecated: layout is always stretch.)

Replacer that matches a block of lines ignoring leading/trailing whitespace on each line, yielding the corresponding raw substring of the original content.

Query-string schema for listing sessions, with optional directory, scope, path, roots-only, pagination, and search filters.

Schema for a log entry payload posted to the /log endpoint.

The "lsp" tool definition. Resolves the file path, asks for lsp/external-directory permission, converts the 1-based line/character into a 0-based LSP position, verifies the file exists and an LSP client is available, then dispatches the requested operation and serializes the result as JSON.

Minimum middle-line similarity required to accept the best candidate when multiple block-anchor candidates exist.

HttpApi definition for the experimental MCP route group. Bundles the status/add/auth/connect/disconnect endpoints under instance-context, workspace-routing, and authorization middleware.

URL path constants for each MCP route, keyed by endpoint name.

Schema for the relevant slice of an MCP tools/call result: result.content[] items with type and text.

Experimental v2 message route group, exposing a single endpoint that retrieves projected v2 messages for a session with order-based or cursor-based pagination. Guarded by authorization middleware.

Branded schema for message identifiers. Exposes static helpers: ascending(id) to make a time-ascending message ID and zod for the zod codec.

Query-string schema for listing messages, supporting an optional non-negative integer limit and a before cursor.

Replacer that yields the exact search string once for every occurrence in the content, letting the caller decide how to handle multiple matches (e.g. via replaceAll).

Parameter schema for the apply_patch tool: the full patchText describing all file changes.

Parameter schema for the edit tool: the filePath to modify, the oldString to find, the newString to substitute, and an optional replaceAll flag.

Parameter schema for the glob tool: the required glob pattern and an optional path directory to search in.

Parameter schema for the grep tool: the required regex pattern, an optional path to search in, and an optional include glob to limit which files are scanned.

Parameter schema for the invalid tool: the offending tool name and the validation error message.

Parameter schema for the lsp tool: the operation to run, the filePath, the 1-based line and character position, and an optional query (used by workspaceSymbol).

Parameter schema for the plan_exit tool: takes no parameters.

Parameter schema for the question tool: a mutable array of question prompts.

Parameter schema for the read tool: an absolute file or directory path with optional 1-indexed offset and limit line/entry counts.

Default shell tool parameter schema, using the bash description text.

Schema for the skill tool parameters: the name of the skill to load.

Schema for the task tool parameters: description, prompt, subagent_type, and optional task_id (to resume) and command.

Schema for the todowrite tool parameters: the full updated array of todo items.

Schema for the webfetch tool parameters: url, output format (text/markdown/html, default markdown), and optional timeout in seconds.

Schema for the websearch tool parameters: query, optional numResults, livecrawl mode, search type, and contextMaxCharacters.

Schema for the write tool parameters: the content to write and the absolute filePath to write it to.

Path-params schema identifying a PTY session by its id.

Branded schema for message part identifiers. Exposes static helpers: ascending(id) to make a time-ascending part ID and zod for the zod codec.

Success schema for the path endpoint: the instance's home, state, config, worktree, and directory paths.

HttpApi definition for the experimental permission route group. Bundles the list and reply endpoints under instance-context, workspace-routing, and authorization middleware.

Request body schema for responding to a permission request, carrying the user's approve/deny reply.

The "plan_exit" tool. Prompts the user to approve the completed plan; on "No" it raises a RejectedError to stay in the plan agent, and on approval it appends a synthetic user message switching the session to the build agent (reusing the last user model, or the provider default) and instructing it to execute the plan.

HttpApi definition for the experimental project route group. Bundles the list/current/initGit/update endpoints under instance-context, workspace-routing, and authorization middleware.

Input schema for prompt: the session, optional model/agent/variant, output format, and the prompt parts (text/file/agent/subtask).

Request body schema for sending a prompt, derived from SessionPrompt.PromptInput minus the path-supplied sessionID.

HttpApi definition for the experimental provider route group. Bundles the list/auth/authorize/callback endpoints under instance-context, workspace-routing, and authorization middleware.

HttpApi definition for the experimental PTY route group. Bundles the shells/list/create/get/update/remove endpoints under instance-context, workspace-routing, and authorization middleware.

HttpApi definition for the PTY websocket connect route group. Exposes the single connect endpoint used to attach to a PTY session in real time (no instance middleware).

URL path constants for each PTY route, keyed by endpoint name.

The public closedcode HttpApi, annotated with OpenAPI metadata and the legacy-compatibility spec transform.

Query-string boolean schema that decodes the strings "true"/"false" to a boolean and back.

HttpApi surface for the question group, exposing endpoints to list pending question requests and to reply to or reject a specific request. The group is guarded by instance-context, workspace-routing, and authorization middleware.

The "question" tool. Presents the supplied questions to the user via the Question service, then returns a human-readable summary of the answers (with unanswered questions marked "Unanswered") plus the raw answers in metadata.

The "read" tool. Resolves the requested path, checks permissions and external directory access, then renders a directory listing, an image/PDF attachment, or a paged, byte/line-capped text view; binary files are rejected. Also warms the LSP and appends any resolved instruction files as a system reminder.

Schema for a single sync event to replay, identified by event ID, aggregate ID, sequence number, type, and free-form data.

Request body schema for the replay endpoint: the target directory and a non-empty array of events to replay.

Response schema for the replay endpoint, returning the session ID produced by the replay.

Payload schema for replying to a permission request: the reply decision plus an optional message.

Request body schema for replying to a question: an array of user answers, one per question, in order.

Tagged enum describing how a request should be handled: Local, Remote, or MissingWorkspace.

Input schema for a revert request: the session plus the message (and optional part) to revert back to.

Request body schema for reverting a message, derived from SessionRevert.RevertInput minus the path-supplied sessionID.

Root (control-plane) HttpApi: control + global route groups.

Minimum middle-line similarity to accept a block-anchor match when there is exactly one candidate (anchors alone suffice).

Error shape thrown by fetch() when gzip/br decompression fails mid-stream

Schema for the arguments passed to the Exa search tool: query, search type, result count, livecrawl mode, and optional context size cap.

The "search" tool: a plain alias that exposes the grep implementation under the id "search" so models that insist on calling a search tool succeed.

Experimental HttpApi surface for the session group, exposing the full set of session endpoints (list, status, get, children, todo, diff, messages, create, delete, update, fork, abort, init, share, summarize, prompt, command, shell, revert, permission response, and message/part mutations). The group is guarded by instance-context, workspace-routing, and authorization middleware.

Schema describing the decoded session pagination cursor, including the active list filters so paging keeps them stable.

Experimental v2 session route group, exposing endpoints to list sessions (order-based or cursor-based pagination), send a prompt, compact the conversation, wait for the agent loop to become idle, and retrieve the active context messages. Guarded by authorization middleware.

Branded schema for session identifiers. Exposes static helpers: descending(id) to make a time-descending session ID and zod for the zod codec.

Query params for filtering the cross-project session list (directory, roots, time, search, pagination, archived).

Map of endpoint name to URL path template for every session route.

Request body schema for restoring a session into a workspace, derived from Workspace.SessionRestoreInput minus the path-supplied workspaceID.

Response schema for the session-restore endpoint, returning the total number of events scheduled for replay.

Input schema for shell: the session, agent/model, and the command string to run.

Schema for a discoverable shell: its path, display name, and whether it is acceptable for use.

Request body schema for running a shell command, derived from SessionPrompt.ShellInput minus the path-supplied sessionID.

The shell tool. Selects the configured shell, parses each command to find the file/path arguments and directories it touches (prompting for read/external access permissions), then runs the command with streamed output, byte/line truncation to a spill file, a configurable timeout, and abort handling.

Replacer that yields the search string verbatim (exact match candidate).

The "skill" tool. Resolves a skill by name, asks for permission to load it, then returns the skill's markdown content plus a sampled list of its files (excluding SKILL.md) so the model can reference them by absolute path. Fails if the named skill is not found, listing the available skills.

Effect Schema describing a formatter's reported status: its name, supported extensions, and whether it is enabled.

Schema mapping each MCP server name to its connection status.

Response schema mapping each session ID to its current status info.

Request body schema for summarizing a session: the provider/model to use and an optional auto flag.

Experimental HttpApi surface for the sync group, exposing endpoints to start workspace sync loops, replay a complete event history, and list sync events. The group is guarded by instance-context, workspace-routing, and authorization middleware.

Map of endpoint name to URL path template for every sync route.

Absolute path to the directory holding persisted full tool output ("tool-output" under the global data path).

The "task" tool. Validates the requested subagent type and permissions, creates a fresh child session (or resumes the one named by task_id), derives the model from the agent or the parent assistant message, runs the subagent prompt to completion, and returns its last text part as the result. Wires the abort signal to cancel the subagent run.

Schema for a single todo item: content (description), status, and priority.

The "todowrite" tool. After requesting permission, replaces the current session's todo list with the supplied array and returns a summary of the remaining (non-completed) count plus the serialized list.

Branded ToolID schema with attached static helpers. Exposes ascending(id) to mint a new monotonically-increasing tool ID and zod for the equivalent Zod schema.

The stable, externally-visible tool ID and permission key for the shell tool. Kept as "bash" for backwards compatibility with plugins and saved permissions.

Query params selecting the provider/model whose tools should be listed.

Replacer that retries matching after trimming the search text's leading/trailing whitespace, yielding the trimmed string if found directly or any content block whose trimmed form equals it. No-ops when the search text is already trimmed.

Experimental HttpApi surface for the TUI group, exposing endpoints to append or submit prompts, open dialogs, show toasts, execute and publish events, select sessions, and pump the control request/response queue. The group is guarded by instance-context, workspace-routing, and authorization middleware.

Map of endpoint name to URL path template for every TUI route.

Request body schema for the publish endpoint: any one of the supported TUI events.

Schema for a queued TUI control request, describing the target path and an opaque body.

Exa MCP endpoint URL, with the EXA_API_KEY query param appended when that env var is set.

Payload schema for updating a project: optional name, icon, and commands fields.

Request body schema for updating a session: optional title, permission ruleset, and archived timestamp.

Experimental v2 HttpApi surface, composed of the v2 session group and the v2 message group.

Query schema for the VCS diff endpoint: which diff mode to compute (e.g. working tree vs default branch).

The "webfetch" tool. Validates the URL scheme, requests permission, fetches the URL with a format-aware Accept header (retrying with an honest UA when blocked by Cloudflare), enforces a 5MB response cap and timeout, and returns the body in the requested format. Images are returned as a base64 data-URL attachment.

The "websearch" tool. After requesting permission, calls the Exa web_search_exa MCP endpoint with the query and options, and returns the resulting context string (or a not-found message). The description is rendered dynamically with the current year substituted for {{year}}.

Replacer that matches by collapsing all runs of whitespace to single spaces, handling both single-line (full-line or substring) and multi-line matches, and yields the matching raw substring of the content.

Experimental HttpApi surface for the workspace group, exposing endpoints to list available workspace adapters, list/create workspaces, query connection status, remove a workspace, and restore a session's events into a workspace. The group is guarded by instance-context, workspace-routing, and authorization middleware.

Map of endpoint name to URL path template for every workspace route.

The "write" tool. Resolves the target path (relative to the instance directory if needed), guards external-directory access, computes a diff for the permission prompt, writes the content while preserving any byte-order mark, runs the configured formatter, publishes file edit/update events, and appends LSP diagnostics (for the written file and up to a few other affected files) to the output.

The Express runtime adapter implementation.

Issue the permission prompts implied by a scan result: an external-directory prompt for out-of-tree file directories and a shell-command prompt for the command patterns.

Effect that asserts a target path lies within the current instance directory, and otherwise raises an "external_directory" permission prompt for the target's containing directory. Resolves to nothing (the side effect is the permission check); does not modify the path.

Layer implementing the Authorization HttpApi middleware service. Wires the basic and authToken security schemes to credential validation against ServerAuthConfig.

Router middleware that enforces authorization for raw (non-HttpApi) routes. When auth is required, it reads the credential from the Authorization: Basic header or the auth_token query parameter (or an empty credential as a last resort) and validates it before delegating to the wrapped effect.

Biome formatter for web/JS/TS and config/markup files. enabled(context) looks for biome.json/biome.jsonc up the tree, then resolves @biomejs/biome via npm.

Invokes a named Exa MCP tool over HTTP and returns its first text content block.

clang-format formatter for C/C++ files. enabled(context) requires a .clang-format config up the tree and clang-format on PATH.

The createClientConfig() function will be called on client initialization and the returned object will become the client's initial configuration.

You may want to initialize your client this way instead of calling setConfig(). This is useful for example if you're using Next.js to ensure your client always has the correct values.

cljfmt formatter for Clojure files. Enabled when cljfmt is on PATH.

Maps legacy TUI command names to their current canonical command ids.

Builds the request handlers for the "config" HttpApi group, wiring the get, update, and providers endpoints to the Config and Provider services.

Shared, empty Effect context used as the base context for the server's request runtime.

Registers the handlers for the "control" HTTP API group on the root API.

Validated entry point that starts a new compaction for a session. Validates input against the schema, then runs the service's create method.

Codec for the message pagination cursor: a base64url-encoded JSON blob carrying a message id, its creation time (epoch millis), the sort order, and the paging direction.

Opaque pagination cursor codec: encodes/decodes a { id, time } keyset cursor as a base64url string for use in message pagination.

dart formatter for Dart files. Enabled when dart is on PATH.

Decoder that parses a JSON string into an McpResult.

Synchronously decodes and validates an unknown value into a PtyID, throwing on invalid input.

The SessionStatus layer with its Bus dependency provided.

The SessionSummary layer with all its dependencies (Session, Snapshot, Storage, Bus) provided.

The SystemPrompt layer with its Skill dependency provided.

The SessionTodo layer with its Bus dependency provided.

The ToolRegistry layer wired with all of its default dependency layers (config, plugin, question, todo, skill, agent, session, provider, LSP, etc.).

Format service Layer with its default Config and cross-spawn spawner dependencies provided.

Lazily-constructed default web handler over routes, with deferred instance disposal as outer middleware.

Tool description with the {{year}} placeholder replaced by the current year.

dfmt formatter for D files. Enabled when dfmt is on PATH.

Dispose every active instance from the InstanceStore and then emit the global "disposed" event. The whole sequence is run uninterruptibly so disposal and notification cannot be torn apart.

Outer server middleware that performs deferred instance disposal after a handler has produced its response. Looks up any instance previously marked via markInstanceForDisposal (keyed by the request source), removes the mark, and uninterruptibly runs the store disposal before returning the response.

Effect that emits a global "disposed" event on the global bus for the "global" directory.

A default, empty ConsoleState (no managed providers, no active org).

Builds the <env> system-prompt block describing the model id, working/worktree directories, VCS, platform, and date.

Layer building the event (SSE) API routes, served behind the instance router middleware.

Effect HttpApi handler group wiring the "subscribe" endpoint to the SSE event response.

Registers the handlers for the "experimental" HTTP API group on the instance API.

Registers the handlers for the "file" HTTP API group on the instance API.

Effect variant of filterCompacted that streams a session's messages from the database, collects them, and returns the compaction-filtered list.

Infers parseAs value from provided Content-Type header.

gleam formatter for Gleam files. Enabled when gleam is on PATH.

Registers the handlers for the "global" HTTP API group on the root API.

gofmt formatter for Go files. Enabled when gofmt is on PATH. enabled() returns the command array or false.

Set of hop-by-hop header names that must not be forwarded to an upstream target.

htmlbeautifier formatter for ERB/HTML-ERB files. Enabled when htmlbeautifier is on PATH.

Default binding for input_undo, with ctrl+z prepended on Windows.

Layer building the full instance HttpApi from every instance-scoped handler group.

Layer implementing the InstanceContextMiddleware HttpApi service, providing instance context via the InstanceStore.

Registers the handlers for the "instance" HTTP API group on the instance API.

Combined router middleware (authorization + instance context + workspace routing) for raw instance routes.

Router-level middleware that provides the instance context for raw (non-HttpApi) routes via the InstanceStore.

Combined instance routes (raw + HttpApi) with authorization, workspace routing, and instance-context middleware provided.

ktlint formatter for Kotlin files. Enabled when ktlint is on PATH.

latexindent formatter for LaTeX files. Enabled when latexindent is on PATH.

Layer that builds the SessionProcessor service, exposing a create factory for per-message processors.

Layer that builds the SessionPrompt service (prompt / loop / shell / command / cancel operations).

Layer that builds the SessionRevert service (revert / unrevert / cleanup operations).

Layer that builds the SessionRunState service: keeps a map of session ID to Runner.

Effect Layer providing the SessionStatus service, which keeps per-session status in instance state and publishes status changes on the bus.

Effect Layer providing the SessionSummary service, which derives file diffs between snapshots, stores them, and exposes summarize/diff/computeDiff operations.

Effect Layer providing the SystemPrompt service, which produces the environment block and the available-skills block for a prompt.

Effect Layer providing the SessionTodo service, which stores todos in the database and publishes Updated events.

Layer that constructs the ToolRegistry service. It discovers custom tools (from tool(s)/*.js|ts in config directories and from plugins), initializes the built-in tools, and exposes ids, all, named, and tools for resolving the active tool set for a given model/agent.

Layer constructing the Truncate service. Provides cleanup, write, output, and limits operations, and forks a background fiber that purges expired truncation files once per hour (after a 1-minute startup delay).

Effect Layer that constructs the Format service, wiring config and a child-process spawner into formatter discovery and execution.

Per-file semaphores keyed by resolved path, used to serialize concurrent edits to the same file.

Mark the current request's instance to be disposed after the response is sent. Registers a pre-response handler that stashes the captured services keyed by the source Request, which disposeMiddleware later reads to perform the teardown.

Mark the current request's instance to be reloaded after the response is sent. Registers a pre-response handler that, once the response is ready, uninterruptibly runs the store reload using the captured bridge and returns the original response unchanged.

Registers the handlers for the "mcp" HTTP API group on the instance API.

Builds the "v2.message" HTTP API handler group: a single "messages" endpoint that returns a page of messages plus previous/next cursors derived from the first/last items.

mix formatter for Elixir files. Enabled when mix is on PATH.

nixfmt formatter for Nix files. Enabled when nixfmt is on PATH.

ocamlformat formatter for OCaml files. enabled(context) requires ocamlformat on PATH and a .ocamlformat config up the tree.

Supported LSP operation names accepted by the tool's operation parameter.

ormolu formatter for Haskell files. Enabled when ormolu is on PATH.

oxfmt formatter for JS/TS files (gated behind the experimental flag). enabled(context) requires the flag and an oxfmt (dev)dependency in a nearby package.json.

Parse a command string into a tree-sitter syntax tree using the bash or PowerShell grammar.

Parses a Server-Sent Events response body, decoding each data: line as an MCP result and returning the first non-empty text content found.

Lazily initialize tree-sitter and load the bash and PowerShell grammars once, returning the two configured parsers.

Registers the handlers for the "permission" HTTP API group on the instance API.

Laravel Pint formatter for PHP files. enabled(context) requires laravel/pint listed in a composer.json up the tree.

Prettier formatter for web/JS/TS and many config/markup files. enabled(context) walks up from context.directory to context.worktree looking for a package.json that lists prettier as a (dev)dependency, then resolves the binary via npm.

Registers the handlers for the "project" HTTP API group on the instance API.

Registers the handlers for the "provider" HTTP API group on the instance API.

Registers the GET WebSocket route that connects a client to a PTY: it upgrades the request to a socket, adapts the socket into a minimal WebSocket-like object so the Pty service can stream output, replays from an optional cursor, and forwards incoming socket messages as PTY input until the socket closes.

Builds the "pty" HTTP API handler group: shells/list/create/get/update/remove endpoints backed by the Pty service.

Replacer that converts non-JSON values (bigint, Date, etc.) to safe substitutes.

Builds the "question" HTTP API handler group, wiring list/reply/reject endpoints to the Question service.

Layer for raw (non-HttpApi) instance routes such as the PTY connect upgrade, behind the instance router middleware.

For custom (non-builtin) LSP server entries, extensions is required so the client knows which files the server should attach to. Builtin server IDs and explicitly disabled entries are exempt.

air formatter for R files. enabled() confirms the air binary is the R language server/formatter via its --help output.

Base URL path for the permission route group.

Base URL path for the project route group.

Base URL path for the provider route group.

Base URL path for the PTY route group.

Base URL path prefix for all question endpoints.

Base URL path prefix for all session endpoints.

Base URL path prefix for all sync endpoints.

Base URL path prefix for all TUI endpoints.

Base URL path prefix for all experimental workspace endpoints.

Layer building the root (non-instance) API routes from control-plane and global handlers.

The default route layer built with no custom CORS options.

rubocop formatter for Ruby files. Enabled when rubocop is on PATH.

ruff formatter for Python files. enabled(context) requires ruff on PATH plus either a ruff config (with [tool.ruff] when in pyproject.toml) or a dependency manifest that mentions ruff.

Router middleware that selects the server backend and annotates the current span with backend attributes before running each handler.

rustfmt formatter for Rust files. Enabled when rustfmt is on PATH.

Normalizes any accepted value into a JSON-friendly shape for query keys.

Codec for the session pagination cursor: a base64url-encoded JSON blob carrying a session id, its creation time, the sort order, the paging direction, and the active list filters (so subsequent pages keep them).

Builds the "session" HTTP API handler group: the full set of session lifecycle, message, prompt, share, revert, permission, and part endpoints backed by the session-related services.

Builds the "v2.session" HTTP API handler group: sessions (paginated list), prompt, compact, wait, and context endpoints.

shfmt formatter for shell scripts. Enabled when shfmt is on PATH.

Builds the available-skills section of the system prompt for the given agent, or returns nothing when the skill permission is disabled.

standardrb formatter for Ruby files. Enabled when standardrb is on PATH.

Safely stringifies a value and parses it back into a JsonValue.

Builds the "sync" HTTP API handler group: start/replay/history endpoints for cross-instance event sync.

terraform formatter for Terraform files. Enabled when terraform is on PATH.

Convert stored session messages into provider model messages. Maps each part type to its model representation: user text/file/compaction/subtask parts, assistant text/reasoning/step-start parts, and tool parts (completed, error, and interrupted pending/running calls, which are forced to errors so every tool_use has a matching tool_result as Anthropic/Claude APIs require). Media from tool results is split into a synthetic follow-up user message when the provider can't carry media in tool results. Optionally strips media and truncates tool output for compaction.

Builds the "tui" HTTP API handler group: endpoints that publish TUI control events onto the bus.

Catch-all UI route layer that serves the web UI (and proxies dev assets) behind authorization middleware.

uv formatter for Python files, used only when ruff is not already enabled. enabled(context) checks uv is on PATH and supports format via its --help output.

Combined v2 handlers layer: merges the v2 session and message handler groups and provides the SessionV2 default layer.

Builds the "workspace" HTTP API handler group: adapters/list/create/status/remove/sessionRestore endpoints.

Router-level workspace routing middleware for raw (non-HttpApi) routes; plans and routes each request without session lookup.

Layer implementing the WorkspaceRoutingMiddleware HttpApi service, wiring the WebSocket constructor, Workspace service, and HTTP client into routing.

zig formatter for Zig files. Enabled when zig is on PATH.

Build the Express router for the "/config" route group (GET/PATCH "/" and GET "/providers").

Build the Express router for the control-plane route group (PUT/DELETE "/auth/:providerID", GET "/doc", POST "/log").

Build CORS middleware whose origin callback delegates to isAllowedCorsOrigin(opts).

Build the Express router exposing GET "/event", a Server-Sent Events stream of bus events. Each connection emits an initial "server.connected" event, periodic "server.heartbeat" events, and forwards all subscribed bus events until the client disconnects or the instance is disposed.

Build the Express router for the "/experimental" route group (Console org metadata/list/switch, tool ids/list, worktree create/list/remove/reset, global session list, and MCP resources).

Builds the Express router for the file/find route group (find text/files/symbols, list, read, git status).

Builds the Express router for the /global route group (health, SSE event stream, global config, dispose, upgrade).

Build the instance-resolution middleware. For each request it resolves the effective workspace and adapter target, then: responds 500 for a missing workspace, proxies remote targets, or runs downstream handlers locally with the resolved (or default) directory.

Build middleware that establishes the workspace and instance context for a request. Resolves the target directory from the directory query param or x-closedcode-directory/x-opencode-directory headers (falling back to the process cwd), then runs the next handler inside that workspace and instance scope.

Builds the aggregate Express router for an instance: mounts every instance route group and the inline instance-root routes (/instance/dispose, /path, /vcs, /command, /agent, /skill, /lsp, /formatter).

Build request-logging middleware that logs each request (skipping /log) and times it until the response finishes or closes.

Builds the JSON-RPC tools/call request schema for a given arguments schema.

Builds the Express router for the /mcp route group (MCP server status/add/connect/disconnect and OAuth flows).

Builds the Express router for the /permission route group (reply to a permission request, list pending requests).

Builds the Express router for the /project route group (list projects, current project, git init, update).

Builds the Express router for the /provider route group (list providers, auth methods, OAuth authorize/callback).

Builds the Express router for the /pty route group (list shells, PTY session list/create/get/update/remove, and a WebSocket route for real-time PTY interaction).

Builds the Express router for the /question route group (list pending questions, reply with answers, reject).

Builds the Express router for the instance /session endpoints (list, get, create, update, fork, abort, share, messages, parts, prompts, commands, revert, permissions, etc.).

Builds the Express router for the instance /sync endpoints: start workspace syncing, replay a full sync event history, and list sync events since known sequence IDs.

Builds the Express router for the instance /tui endpoints: publishing TUI events (prompt append/submit/clear, open dialogs, toasts, command execution, session select) and the /control request/response queue bridge.

Builds the Express router that serves the embedded web UI via a catch-all route.

Build the Express router for the "/experimental/workspace" route group (adapter listing, workspace create/list/status/remove, and session restore).

Add the legacy BadRequestError and NotFoundError component schemas the old SDK expected.

Apply hand-tuned schema overrides so specific component schemas match the legacy SDK (e.g. open additionalProperties, string Command.template, and nullable Workspace/session/provider fields).

Promise-returning wrapper around assertExternalDirectoryEffect for callers outside the Effect runtime; runs the guard with the logger layer provided.

Build telemetry/log attributes describing the selected backend and installation.

Resolve the value of an automatic shell variable (HOME, PWD, PSHOME).

Build the bash-specific "command section" of the tool description, covering directory verification, quoting, output limits, and command chaining.

Bridge an already-upgraded inbound WebSocket to a freshly-dialed outbound one. Inbound messages are queued until the outbound socket opens, then forwarded raw in both directions; close/error codes propagate across (1011 on error), with invalid close codes guarded so close() can't throw.

Compose the compaction prompt: an anchor instruction (create-new vs update-existing), the fixed summary template, and any plugin-supplied context.

Build the final OpenAPI document from the registry, merged with the Effect httpapi contract's paths and components on top of a plain base document.

Forwards a request to the TUI and waits for its matching response. Reads the JSON body from the context, enqueues a TUI request, then awaits the next response.

Resolve a $ref to its canonical form, mapping numeric-suffixed names to their base name when that base exists.

Recursively canonicalize a schema for structural comparison: sort object keys, drop description, and rewrite $refs to their canonical (base) form.

Clamps a delay so it never exceeds the maximum safe setTimeout value.

Return guidance on how to chain dependent commands for the given shell (PowerShell 5.1 lacks &&; other shells get &&/& advice).

Build the ChildProcess spec to run a command: on Windows PowerShell it invokes the shell with -Command, otherwise it runs the command through the shell's -c/shell option, detaching on non-Windows platforms.

Build the cmd.exe-specific "command section" of the tool description, covering notes, directory verification, quoting, output limits, and chaining.

Collapse numeric-suffixed duplicate component schemas (e.g. Foo2) into their base name (Foo) when the schemas are structurally equal, rewriting all $refs and deleting the duplicate.

Collect all command descendant nodes within a parse tree node.

Find the prior completed compactions in a message list: each is an assistant summary message that finished without error, paired with the index of the user (compaction) message that triggered it.

Convert a dotted component name into a PascalCase type name, dropping purely numeric path segments.

Compute the config entry name for a file: the path after a matching search root (or the basename when none match), with its extension stripped.

Read the workspace ID pinned via the CLOSEDCODE_WORKSPACE_ID flag, if any.

Converts an HTML document to Markdown using Turndown, removing script, style, meta, and link elements.

Converts LF line endings in the text to the requested ending.

Build a global CORS router middleware that allows origins per the configured CORS options.

Build the Express application: wires the root middleware chain, mounts every route group against a shared OpenAPI registry, builds the OpenAPI spec, serves the docs, and registers the error handler.

Wrap an Express app with fetch/request methods that drive it over an in-process loopback HTTP server. The lazily-started server has per-request timeouts disabled so long agent loops (run inside a single request) are not capped at 5 minutes. Does not mutate expressApp.request.

Create an empty per-app registry for collecting OpenAPI operations and named schemas.

Build the complete route layer for the server, merging root, event, instance, and UI routes and providing all required service layers (CORS, runtime, and every feature service layer).

Builds the special StructuredOutput AI SDK tool used when the prompt requests JSON-schema output. The tool validates the model's arguments against the schema (with $schema stripped) and invokes onSuccess with the captured output.

Build the WebSocket upgrade machinery for the Express adapter. Returns an upgradeWebSocket route-handler factory (registers per-path WS handlers) and an injectWebSocket(server) injector that handles HTTP upgrade events, dispatching to local routes or remote-workspace proxying.

URI-decode a value, returning the original input unchanged if decoding throws.

Decode a Base64-encoded username:password string into a credential, falling back to empty values on failure.

Resolve the project directory for the plain (non-workspace) path from the request's directory query param or x-closedcode/x-opencode-directory header, falling back to the current working directory.

Resolve the directory for a locally handled request from the directory query param, the x-closedcode-directory/x-opencode-directory headers, or the process cwd.

Defines a tool. Returns an Effect (with an attached id) that resolves the tool's setup, acquires the Truncate and Agent services, and yields a record with the tool id plus a lazy init (the wrapped execute pipeline).

Register an event type with its property schema and remember it in the registry.

Computes the wait before the next retry attempt. Prefers the provider's retry-after-ms / retry-after response headers (seconds or HTTP date); otherwise falls back to exponential backoff capped per the no-headers limit.

Annotate a schema with a human-readable description for OpenAPI documentation.

Detects the dominant line ending of a text.

Compute the aggregates whose sequence number changed between two sequence maps.

Resolve the base directory used to resolve relative {file:...} references.

Detect whether a token contains dynamic/computed content (subexpressions, command substitution, or unresolved variables) that cannot be treated as a static path for permission scanning.

Build Effect Schema.Struct schemas for every registered event, each annotated with an Event.<type> identifier.

Resolves the lazily-loaded embedded web UI asset map.

Resolve the lazily-imported embedded web UI bundle (a map of asset path to on-disk file path), or null when the embedded UI is disabled or unavailable.

Recursively converts any Effect DateTime values within a structure to epoch milliseconds so the data can be JSON-serialized into a sqlite column.

Encodes a message's data payload for storage (currently just DateTime encoding).

Look up an environment variable, matching case-insensitively on Windows.

Build a responses fragment for the given HTTP error status codes, for spreading into a route's describeRoute responses (e.g. ...errors(400, 404)).

Wraps a bus event payload into an SSE "message" frame with a JSON-encoded body.

Wraps a payload into an SSE "message" event envelope with a JSON-serialized data field.

Builds the streaming SSE HTTP response: emits a server.connected event, then merges the bus event stream with a 10-second heartbeat, encoding each frame as SSE text. The stream halts when the instance is disposed.

Builds a Server-Sent Events HTTP response that streams global bus events plus a periodic heartbeat, starting with a server.connected event and tearing down the bus listener when the client disconnects.

Expand environment-variable and automatic-variable references in a token (${env:X}, $env:X, $HOME/$PWD/$PSHOME) and then expand ~.

Collect the set of file paths already loaded into context via completed, non-compacted read tool calls (from each tool result's metadata.loaded).

Extracts visible text from an HTML document, stripping content inside script, style, noscript, iframe, object, and embed elements.

Trim a (newest-first) message list down to the active context after compaction: scans for the most recent completed compaction and drops the superseded history before its retained tail, keeping the summary and the preserved tail. Returns the result in chronological (oldest-first) order.

Fix component schemas that are self-referencing $refs — an Effect OpenAPI generation bug where annotated union arms that share AST nodes with other endpoints produce {"$ref":"#components/schemas/X"} as the definition of X.

Resolves by finding the actual schema from a parent union's anyOf/oneOf that references the broken component, then inlining that schema.

Flatten nested anyOf/oneOf unions into a single flat list of leaf option schemas.

Override the selection to force a specific backend, marking the reason as "explicit" unless the forced backend already matches the current selection.

Determines whether an error is a SQLite foreign-key constraint violation, unwrapping sequelize's wrapped driver error via original if needed.

Normalize an arbitrary thrown error into one of the named message error objects (Aborted/Auth/API/ContextOverflow/OutputLength/Unknown), classifying abort exceptions, socket resets, decompression failures, and provider API-call/stream errors (including context-overflow detection).

Fetch a single message (with its parts) by id within a session. Throws NotFoundError when no matching message exists.

Find the model most recently used by a user message in the session, scanning the message stream and returning the first user message that carries a model.

Looks up the MIME type for a file path, normalising the library's false to undefined.

Look up the MIME type for a file path by extension.

Extract the session ID embedded in a /session/{id} route URL. Returns null for the /session/status route and for any URL without a session segment.

Reads a field from a partial-update object, optionally descending into a nested object via cb. Returns undefined when the field is absent, but throws if the field is present yet explicitly undefined (callers must pass null to clear a value).

Determines whether the given agent is allowed to use the task tool, used to decide which truncation hint to show (delegate to an explore agent vs. read directly).

Report whether any message contains tool-call or tool-result content, used to decide if a stub tool must be injected for LiteLLM-style proxy compatibility.

Build a sanitized Headers object suitable for forwarding to an upstream target. Accepts either a Request (uses its headers) or a Headers/plain-object header source, removes hop-by-hop/internal headers, then applies any extra overrides.

Expand a leading ~ (home directory) in a path-like token.

Proxy an HTTP request to a target URL and stream the upstream response back to the client. Forwards the method, merged headers, and (for non-GET/HEAD) the request body stream; strips hop-specific content-encoding/content-length headers; aborts the upstream call when the client request is aborted; and converts errors into a plain-text 500 response.

Attach parts to message rows: batch-loads all Part rows for the given messages (ordered), groups them by message, and returns { info, parts } objects.

Reconstruct a message Info object from a stored message row, hoisting the id and session id out of the JSON data column.

Initializes a defined tool, invoking its lazy init and merging the tool id into the resulting info record.

Register session projectors with the SyncEvent system, supplying a convertEvent hook that, for "session.updated" events, asynchronously loads the session row and emits its hydrated info. Other event types pass their data through unchanged.

Determine whether a request Origin is allowed by CORS. Always allows a missing origin, http://localhost:* and http://127.0.0.1:* ports, and the vcc://renderer scheme; otherwise allows it only if listed in opts.cors.

Determine whether authorization is enabled, i.e. a non-empty password is configured.

Check whether a schema is a bare array type (no items or prefixItems).

Check whether a schema is a bare object type (no properties or additionalProperties).

Determine whether a response is one of Effect's built-in error responses for the given error name.

Check whether a credential matches the configured username and password.

Detect the degenerate "bare object OR bare array" union that Effect emits for an unconstrained record/array value.

Whether the given value is one of the recognized shell kinds.

Decide whether a request path/method should be served locally rather than proxied, by matching it against the static RULES table. Rules may pin a method and match a path exactly or as a prefix; the first matching rule wins.

Promise wrapper around the compaction service's overflow check.

Decide whether current token usage exceeds the model's usable budget and should trigger compaction. Always false when auto-compaction is disabled or the model has no context limit.

Detects plain objects (including objects with a null prototype).

Check whether a response's JSON schema is a $ref to the named component.

Build an OpenAPI requestBody object for an application/json endpoint.

Runs an Effect generator inside an OTel span built from the request, then writes the resolved value as JSON.

Runs an Effect generator inside an OTel span built from the request, then writes the resolved value as JSON.

Runs an Effect generator through runRequest and writes the resolved value as JSON.

Runs an Effect generator inside a request span and JSON-encodes the resolved value onto the response.

Runs an Effect generator under an OTel span built from the request, then writes the resolved value as JSON.

Runs an Effect generator inside an OTel span built from the request, then writes the resolved value as JSON.

Runs an Effect generator inside a named span built from the request attributes, then serialises the result as JSON.

Runs an Effect generator within a named span and writes the resolved value as JSON.

Run a request-producing effect within a span and serialize its result as a JSON response.

Run an Effect generator within a traced span and write its result as the JSON response body.

Build a schema for one keybind field: an optional string that decodes to a default binding when omitted, annotated with a human-readable description.

Build a legacy error response object that references a named error schema.

Levenshtein distance algorithm implementation: the minimum number of single-character edits (insertions, deletions, substitutions) needed to turn a into b.

Stream a text file line by line, returning a window of lines starting at opts.offset (1-indexed) up to opts.limit lines. Individual lines longer than MAX_LINE_LENGTH are truncated, and the window is capped at MAX_BYTES; it also reports total line count and whether more content / a byte cut occurred.

Start an HTTP server for the given Express app and return a control handle. Disables per-request/header timeouts only for explicit loopback binds (so long agent loops are not aborted), tries port 4096 then a random port when opts.port is 0, and lets the optional injector hook the server before it listens (used to attach WebSocket upgrade handling).

Load the current event sequence number for each aggregate.

Public helper returning the set of file paths already read into context.

Returns (creating if needed) the single-permit semaphore guarding edits to a given file.

Recursively wrap each property schema in a nullable union, with special handling for share.url (only the url made nullable) and time (recursed into).

Get the managed config directory, honoring the CLOSEDCODE_TEST_MANAGED_CONFIG_DIR test override before falling back to the system directory.

Converts a storage NotFoundError (raised as either a typed failure or a defect) into an HttpApiError.NotFound, re-dying on any other defect.

Capture the services needed to dispose or reload an instance later.

Transform a freshly generated OpenAPI spec in place to match the legacy SDK surface. Fixes self-referencing components, strips optional-null union arms, normalizes/dedupes component names and descriptions, applies legacy schema overrides, removes built-in error/security schemas, injects instance query params, documents SSE event streams, and normalizes parameters/error responses.

Resolve a schema that may be either a Zod schema or an already-built JSON Schema. Zod schemas (detected via _def/_zod) are converted; plain objects pass through.

Fill in missing parameters/requestBody on registry operations from the Effect httpapi contract for matching path+method pairs, mutating paths in place.

Deep-merge a source options object into a target, treating a nullish source as an empty object.

Build a 500 plain-text response indicating the requested workspace was not found.

Pulls the next pending TUI request from the request queue.

Replace component descriptions with the curated legacy descriptions, deleting descriptions for all others.

Rename dotted component names to PascalCase type names, merging into an existing target when structurally equal or renaming otherwise, and rewriting all $refs accordingly.

Replace built-in 400/404 error responses on an operation with the legacy error response shapes.

Apply per-route legacy operation tweaks: drop spurious error responses on specific endpoints and give the message/command POST endpoints their explicit {info, parts} 200 response shape.

Converts all CRLF line endings in the text to LF.

Normalize an operation parameter's schema for the legacy SDK: apply path/query schema overrides, coerce known number/boolean query params, and otherwise strip optional-null arms.

Normalize an Express route path to OpenAPI form: ":param" becomes "{param}" and a trailing slash is dropped except on the root path.

Wrap a schema in an anyOf: [schema, {type:"null"}] union, unless it is already nullable.

Build a Sequelize WHERE clause selecting rows strictly older than a cursor, ordered by creation time then id (the keyset-pagination tiebreaker).

Build a fresh Express app and return its OpenAPI spec, without listening.

Fetch one page of a session's messages (newest-first internally, returned oldest-first) using keyset pagination, hydrating each with its parts. Throws NotFoundError when the session does not exist and no rows are returned.

Map a route-param name to an OpenTelemetry attribute key: a "fooID" param becomes "foo.id", any other key becomes "closedcode.".

Normalises an Express route param name into an OTel attribute key: fooID becomes foo.id; any other param is namespaced under closedcode..

Normalises an Express route param name into an OTel attribute key: fooID becomes foo.id; any other param is namespaced under closedcode..

Normalises an Express route param name into an OTel attribute key: fooID becomes foo.id; any other param is namespaced under closedcode..

Normalises a route param name into an OTel span attribute key.

Map a route param name to an OTel span attribute key. Names ending in ID become <lowercased-prefix>.id (e.g. sessionID -> session.id); all other names are namespaced under closedcode. to avoid colliding with standard conventions.

Build the shell tool's parameter schema (command, optional timeout, optional workdir, and a required description) using the supplied description text for the description field.

Parse the sync fence header into a sequence map. Returns undefined when the header is missing or invalid; otherwise keeps only entries with a string key and an integer sequence value.

Parses a JSON request body, defaulting an empty body to {}.

Strip MDM/plist metadata keys from a JSON-encoded managed plist, returning the remaining closedcode config as a JSON string.

Reconstruct a message Part object from a stored part row, hoisting the id, session id, and message id out of the JSON data column.

Load all parts of a single message in id order, reconstructed as Part objects.

Extract the meaningful tokens (command name and argument-like elements) of a tree-sitter command node, skipping separators and redirections.

Extract the path-like arguments from a command's token list, skipping the command name, flags/switches, and special leading characters. For PowerShell it also follows value-taking parameters (e.g. -Path) to grab their value.

Resolve the override schema for a path parameter by name, with route-specific patterns for id/requestID on workspace, permission, and question routes.

Build Zod object schemas for every registered event, each annotated with an Event.<type> ref.

Convert a Sequelize model row to a plain object, or undefined when the row is null/undefined.

Convert a Sequelize model instance to a plain object, or undefined when null.

Compute the routing plan for a request, accounting for the env-pinned workspace, the selected workspace (session or query param), missing workspaces, and control-plane-only routes.

Build a request plan for a resolved workspace: Remote when the target is remote (proxy), otherwise Local.

Builds an Effect Schedule that retries while retryable returns a reason, waiting the computed delay between attempts and reporting progress.

Build the PowerShell-specific "command section" of the tool description, covering notes, directory verification, quoting, output limits, and chaining.