protocol

package
v0.8.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jul 30, 2026 License: MIT Imports: 16 Imported by: 0

README

Gollem App-Server Protocol Versioning

ProtocolVersion identifies the JSON-RPC method and envelope contract. SchemaVersion identifies the generated schema document format. They change independently: adding an optional field or a new method/type definition does not require an envelope-version change.

Compatibility Rules

  • Existing method names, directions, item discriminators, and required fields are stable within one protocol version.
  • Additive methods, definitions, and optional fields are allowed within the current protocol version. Clients must ignore unknown optional fields and preserve unknown timeline payloads as raw JSON.
  • Removing or renaming a method/type/required field, changing a field type, or changing method direction requires a new protocol version and an explicit migration note. Adding a value to a closed schema enum also requires a new protocol version unless the binding explicitly preserves unknown values.
  • Changing schema metadata or binding representation requires a new schema version even when the JSON-RPC wire remains compatible.
  • Deferred and unavailable methods remain in the method inventory so clients can distinguish capability gaps from unknown methods.

Version 1 Initialize Migration

gollem.appserver.v1 makes the initialize wire compatible with the public Codex identity and environment fields. Clients must send non-empty clientInfo.name and clientInfo.version; clientInfo.title remains nullable and optional on the JSON wire. Initialize capabilities accept the public experimental API, attestation, MCP form-elicitation, and notification opt-out fields, while Gollem's keyed experimental map remains an extension.

Initialize responses now require userAgent, codexHome, platformFamily, and platformOs. Existing Gollem protocolVersion, serverInfo, server capabilities, and method inventory fields remain present as additive extensions. This required-field change is why the protocol version advances from v0 to v1; the schema metadata representation remains v1.

Version 1 Thread Discovery

thread/list accepts the public Codex cursor, limit, sort, provider, source, archive, cwd, state-DB, and title-search fields. Lists default to active threads, created-at descending, and a 50-record page capped at 100 records. Responses include the public data, nextCursor, and backwardsCursor fields and retain Gollem's threads array through the live ThreadListResult compatibility type. Existing statuses and includeDeleted parameters remain optional Gollem lifecycle extensions; clients that need archived or deleted records must now request them explicitly and paginate the result.

thread/read accepts public threadId and optional includeTurns. The live ThreadReadResult nests loaded turns and timeline items under the durable thread record while retaining Gollem's top-level turns and items arrays and the existing id, includeItems, afterSeq, and limit request extensions.

Exact standalone ThreadListResponse and ThreadReadResponse definitions use the public Thread parent. The list response requires non-null data plus explicit nullable forward/backward cursors; read requires only thread. Neither canonical response is bound to a live method until durable records are projected into the public parent. The *Result binding names make that runtime boundary explicit without changing JSON output.

ThreadLifecycleStatus and TurnLifecycleStatus describe Gollem persistence and execution state. They intentionally do not claim compatibility with Codex's runtime ThreadStatus or public TurnStatus; the exported durable records remain separate types until those runtime and item models converge.

Version 1 Thread Controls

thread/loaded/list, thread/archive, thread/unarchive, thread/delete, thread/unsubscribe, and thread/name/set use exported request/result contracts. Public thread ids, names, cursors, limits, loaded-id arrays, and unsubscribe statuses retain their Codex wire names and optionality. Legacy id/title request aliases remain optional Gollem extensions.

Codex archive, delete, and set-name responses are empty objects. Gollem keeps its existing returned durable record/name fields as optional response extensions, so public empty responses remain valid generated values and v1 clients do not lose current result data. The bound ThreadUnarchiveResult still contains ThreadRecord; exact standalone ThreadUnarchiveResponse contains public Thread and remains unbound until the runtime thread/turn/item model converges.

Archive and soft-delete are rejected while the target thread has a queued or running turn. The check and lifecycle mutation share one store transaction, and archived threads cannot create, retry, or start turns until thread/unarchive completes. Full-history forks reject active sources rather than copying queued or running turn states. Runtime, compaction, and shell-command startup failures terminalize turns created before an execution owner is established. Together, these rules prevent lifecycle changes from racing execution across daemon clients; set-name remains available because it does not change run ownership.

Version 1 Thread Goals

thread/goal/get, thread/goal/set, and thread/goal/clear use the public structured goal model: objective, status, nullable token budget, token/time usage, and Unix-second timestamps. Goal update and clear notifications use the same exported model; update notifications carry a required nullable turnId. Legacy id and arbitrary goal/text/value request fields remain optional Gollem extensions, and existing stored goal strings or objects are decoded into the structured response without discarding the stored value. Oversized legacy objectives are projected to the public 4,000-character limit without rewriting the underlying compatibility data. Generated validators and TypeScript require either public threadId or legacy id; empty identifier objects remain invalid. New legacy-form goals start accounting at set time, so earlier thread turns are not charged to a newly created goal.

Turn records are the durable source of goal usage. On turn completion Gollem derives token/time counters and budget-limited state from persisted turns, emits a turn-correlated goal update, and returns the same derived snapshot from thread/goal/get. It does not write a stale accounting snapshot back over a concurrent user goal edit. Public goal mutations persist the structured goal, preserve creation time and prior usage, validate the six closed status values, limit objectives to 4,000 characters, and require positive non-null budgets. Clearing or raising a derived exhausted budget returns the goal to active unless the request also supplies an explicit status.

Version 1 Thread Metadata And Memory Mode

thread/metadata/update accepts the public nested gitInfo patch with independently optional nullable sha, branch, and originUrl fields. Omission preserves the stored field, explicit null clears it, and non-null strings are trimmed and must remain non-empty. Unrelated metadata and unknown keys inside gitInfo are preserved. Legacy id, arbitrary metadata, and replace fields remain optional Gollem extensions. The live ThreadMetadataUpdateResult intentionally contains Gollem ThreadRecord. Exact standalone ThreadMetadataUpdateResponse contains public Thread and remains unbound until the nested runtime thread model converges.

thread/memoryMode/set uses the public enabled/disabled enum and accepts the public threadId/mode pair. Legacy id and memoryMode aliases remain explicit generated variants. Its public empty response remains valid while Gollem returns thread id, selected mode, and durable thread state as optional extensions. thread/name/updated now emits required threadId and optional public threadName; legacy name, durable thread, and timestamp details remain optional extensions.

Version 1 Thread Lifecycle Notifications

thread/archived, thread/closed, thread/deleted, and thread/unarchived use exported notification contracts with the required public threadId field. Archive, delete, and unarchive notifications preserve Gollem's lifecycle status, durable ThreadRecord, and timestamp as optional extensions. The close notification remains the exact public { threadId } shape. These lifecycle types intentionally do not make thread/status/changed public: that method still depends on the distinct Codex runtime ThreadStatus model.

Version 1 Exact Live Notification Values

deprecationNotice, thread/compacted, thread/tokenUsage/updated, and turn/diff/updated bind the exact public DeprecationNoticeNotification, ContextCompactedNotification, ThreadTokenUsageUpdatedNotification, and TurnDiffUpdatedNotification names. Token usage uses the exact public ThreadTokenUsage value and keeps both modelContextWindow and deprecation details required and nullable on the wire. Gollem's original ThreadCompactedNotificationParams, ThreadTokenUsageUpdatedNotificationParams, TokenUsage, and TurnDiffUpdatedNotificationParams exports remain aliases so existing protocol-v1 generated clients continue to compile.

Version 1 Exact Live Primitive Values

item/commandExecution/outputDelta, item/fileChange/patchUpdated, item/mcpToolCall/progress, and serverRequest/resolved bind the exact public notification names. RequestId preserves either a string or signed integer JSON-RPC id without coercion, and empty file-change patch arrays are emitted as [] rather than null. Command-execution, dynamic-tool-call, and MCP-tool-call item statuses reference their exact public closed enums; MCP errors reference the exact public McpToolCallError spelling.

Gollem's original *NotificationParams names and MCPToolCallError remain generated aliases. Their JSON shapes and source compatibility are preserved while new clients infer the exact public names from method bindings.

Version 1 File-Change Approval Responses

item/fileChange/requestApproval binds the public accept, acceptForSession, decline, and cancel decisions to its direct JSON-RPC response. Session acceptance is connection-scoped and suppresses later prompts only for the same normalized mutation target; cancel interrupts an active runtime turn. The approval/respond extension remains available for legacy clients.

Version 1 Exact File-Change Reversal

item/fileChange/revert is a Gollem extension for reversing one durable fileChange timeline item. Requests contain only threadId, itemId, and an idempotencyKey; clients cannot supply a path, patch, digest, mode, or replacement content. The handler resolves those values from private SQLite recovery evidence and cross-checks them against the public item before any mutation.

Gollem captures recovery snapshots only after mutation approval, with the before snapshot, mutation, and after snapshot sharing the filesystem mutation lock. Snapshots are limited to regular files with exactly one observed hard link, whose paths do not traverse symlinks, and whose before and after contents are each at most 1 MiB. Unknown or multiple link counts fail closed. Public FileChangeArtifactEvidence exposes the optional revertSnapshotAvailable capability and a bounded unavailable reason, but never the private before-content bytes. A call is rejected while any turn that can access the configured filesystem workspace is active, when the original turn is not terminal, when the thread is deleted, when the thread's canonical workspace differs from the configured filesystem root, or when current bytes or mode no longer match the recorded post-change state. A dedicated revert request scope and workspace reservation reject new turn starts during approval without blocking thread reads. Forked history explicitly marks copied file-change items unavailable because private recovery evidence does not transfer to the fork.

The filesystem mutation runs through the existing item/fileChange/requestApproval request unless the daemon was explicitly started with --allow-mutations, which deliberately bypasses mutation prompts. Rooted filesystem operations reject symlinks in every path component and restore only the selected file's bytes, existence, and supported permission-mode bits. The final mutation quarantines and validates the current path, then installs restored content without replacing an unknown concurrent path. It does not claim to undo process, Git, provider, directory, or other workspace effects.

The store binds the idempotency key before mutation and writes a fileChangeRevert receipt atomically with terminal recovery state. Repeating the same key returns that receipt. Restored file metadata and every affected directory entry are synchronized before receipt completion. Startup also reconciles a durable private snapshot when owner loss interrupted the matching public item completion. A daemon-wide coordinator prevents other client connections from starting turns, rewriting history, deleting the thread, or starting another exact revert while approval or mutation is pending. After owner loss, a pending request is completed without another mutation only when the file exactly matches the recorded before state; it is retried only when the file exactly matches the recorded after state. Approval denials and pre-mutation failures release the key only after Gollem proves the after state is unchanged. Ambiguous outcomes remain pending for same-key recovery.

Version 1 Command-Execution Approval Responses

item/commandExecution/requestApproval binds the exact public six-variant decision and response types. Current requests advertise only accept, decline, and cancel; unoffered session, exec-policy-amendment, and network-policy-amendment results fail closed. Cancel interrupts an active runtime turn before the blocked process can start. The additional public variants remain exported for wire-compatible clients but are not applied until Gollem has matching policy enforcement.

Exported Permission Profile Contracts

The schema exports the public absolute/legacy path, filesystem path and special path unions, sandbox entries, filesystem/network overlays, request/granted profiles, active profile, turn/session scope, and permission request/response types. These definitions are intentionally not bound to the live item/permissions/requestApproval result. Gollem currently uses that method for specific Git and MCP action approval through PermissionsApprovalRequestParams; it does not yet request, intersect, store, or enforce environment-keyed filesystem/network grants or strict-auto-review state. Binding a profile result to that action gate would fabricate broader authority. Direct permission responses therefore remain fail closed while legacy approval/respond continues to resolve the existing action request. Generated TypeScript uses the public canonical output shape with explicit nullable profile fields and scope; Go decoding also accepts omitted upstream-defaulted fields and normalizes them to that canonical form.

Exported Dynamic Tool Specification Contracts

The schema exports exact standalone DynamicToolFunctionSpec, DynamicToolNamespaceTool, DynamicToolNamespaceSpec, and DynamicToolSpec definitions. Functions require name, description, and an arbitrary JSON input schema; deferLoading defaults to false and is omitted from canonical output unless true. Namespaces preserve an ordered, non-null function array and cannot contain nested namespaces. Unknown record fields are ignored for upstream serde compatibility, while duplicate known fields, invalid discriminators, null required fields, malformed tools, and trailing JSON values fail closed.

These definitions are data contracts only. They are not bound to thread/start, dynamic-call items or methods, registration, input validation, deferred loading, namespace dispatch, persistence, or execution. Generated TypeScript preserves the exact public function/namespace intersections without changing Gollem's runtime-specific bindings or five item bindings.

Exported Collaboration And Capability Contracts

The schema exports exact standalone Settings, ModeKind, MultiAgentMode, CollaborationModeMask, CollaborationMode, CapabilityRootLocation, and SelectedCapabilityRoot definitions. Canonical output keeps plan/default mode values, explicit nullable settings and mask fields, strict built-in/custom multi-agent modes, environment-owned capability locations, and canonical file: path URIs. Decoding also accepts the public legacy mode aliases, legacy none multi-agent input, absolute POSIX/Windows paths, and unknown record fields while rejecting duplicate known fields, malformed unions, relative paths, non-file URIs, and trailing JSON values.

These definitions describe configuration and selected roots only. They do not start collaboration sessions, change delegation policy, spawn subagents, resolve environments, expose files, grant capabilities or permissions, bind methods/items, persist selections, or add runtime authority. Existing live collaboration, thread, and capability behavior remains unchanged.

Version 1 File-Change Item Contracts

FileUpdateChange, PatchChangeKind, and PatchApplyStatus now use the public file-change item contracts. Add and delete kinds carry only their discriminator. Update kinds require nullable snake-case move_path; Gollem also accepts the previous camel-case movePath form and emits both fields so existing v1 consumers continue to decode updates. When both inputs are present, the public field wins even when null or empty. Unknown kinds, fields, and update payloads without either move-path field fail closed.

FileChangeItem.status uses the exact inProgress, completed, failed, and declined enum. The current artifact-change tracker emits its proven inProgress then completed lifecycle; exporting the remaining public values does not invent failure or denial items where no live file-change event exists.

Version 1 Filesystem Contracts

The nine fs/* requests and fs/changed notification bind the exact public filesystem family. Generated clients use absolute paths, base64 file contents, required metadata flags and millisecond timestamps, and non-null directory and watch-path arrays. Gollem continues to accept its existing relative workspace paths and text/encoding write form at runtime. Read, metadata, directory, and mutation responses include the public fields plus optional legacy detail fields; public empty mutation responses remain valid.

Create and remove preserve the public default of recursive operation, with remove also defaulting to force. Explicit false values use non-recursive and non-force service operations rather than being ignored. Public sourcePath and destinationPath directory copies require recursive: true, while legacy source/destination requests retain Gollem's recursive default. Both forms stay on the same scoped path-resolution, approval, and audit path.

fs/changed has two explicit payload variants. FsChangedNotification is the public watch event with watchId and absolute changedPaths; FileChangedNotification is Gollem's mutation-level extension with operation, timestamp, and optional source/destination paths. Consumers must narrow the union by fields instead of assuming every event belongs to a watch.

Version 1 Command Exec Controls

command/exec/write, command/exec/resize, and command/exec/terminate use exported request/result contracts. Public processId, nullable base64 input, close-stdin, and nested terminal-size fields take precedence; legacy id, text/encoding/close, and flat size fields remain explicit generated variants. Public empty responses remain valid while Gollem's existing ok and path details are optional extensions. Follow-up controls are connection-scoped to processes started by command/exec, and resize remains typed-unavailable until a PTY backend is configured.

command/exec/outputDelta now uses the exported public process id, stream, base64 delta, and cap flag contract. This does not make command/exec start or its final response public: Gollem currently starts a legacy string command asynchronously and returns a process snapshot, while the public contract requires argv, PTY/sandbox/stream/cap/timeout controls and a deferred buffered result after process exit.

Version 1 Runtime Client Bindings

Generated clients can discover providers and models, start, steer, and interrupt live runs, and consume the current streaming lifecycle without an untyped JSON escape hatch. provider/list and model/list bind the provider-aware catalog records; thread/start, turn/start, turn/steer, turn/retry, and turn/interrupt bind durable thread/turn results; and thread/started, turn/started, turn/completed, item/agentMessage/delta, and item/reasoning/textDelta bind the live notification records. The registry now contains 79 method bindings and five durable item bindings.

The live names are intentionally explicit: ModelCatalog*, ThreadRun*, TurnRun*, and Runtime*. Exact standalone public ModelList*, ThreadStart*, TurnStart*, lifecycle-notification, and delta-notification types remain separate and retain their stricter Codex shapes. This exposes the implemented Gollem wire truthfully without weakening or falsely claiming those public contracts. Catalog responses expose configuration state and required environment-variable names, never credential values; runtime requests contain selection and model settings but no credential-bearing fields.

An explicit reasoningEffort is accepted only when the selected catalog model advertises reasoning and that exact effort. Validation happens before thread/start creates a thread and before turn/start, thread/resume, or turn/retry creates a turn. Supported choices are copied into durable thread settings and native runtime turn input; later turns inherit the thread choice, and retry recovers the source turn choice when the request omits it. Clients must still gate controls from the selected model's capability record. A model or effort absent from that record is unavailable rather than optimistically forwarded to a provider.

Version 1 Operational Inspector Bindings

thread/backgroundTerminals/list, thread/backgroundTerminals/terminate, thread/backgroundTerminals/clean, git/status, and git/worktree/list use exported request and response contracts. List responses are ordered by their underlying service, capped at 32 records per page, and carry an observed time, snapshot digest, total count, truncation state, and opaque continuation cursor. A continuation is rejected if the method or current snapshot no longer matches the cursor, so clients cannot merge pages from different repository or process states.

Background-terminal records retain the historical id aliases, but expose only a command label, workspace-relative directory, lifecycle state, timestamps, exit code, and argument count. Arguments, environment, captured output, nested native process snapshots, and raw errors are intentionally omitted. Git status omits raw porcelain output and returns bounded structured entries. Worktree metadata is bounded, while desktop clients remain responsible for retaining native paths in their privileged process and projecting opaque ids to an untrusted renderer.

A direct background-terminal terminate request binds its one-shot command approval itemId to terminal-terminate-sha256: plus the lowercase SHA-256 of the UTF-8 bytes gollem.background-terminal.terminate.v1\0<terminal-id>. Privileged clients must verify that receipt before accepting the approval. The native terminal id does not appear in cleartext in the receipt or enter an untrusted renderer.

Exported Thread-Item Prerequisites

The schema exports the exact public ByteRange, TextElement, ImageDetail, UserInput, MessagePhase, MemoryCitationEntry, MemoryCitation, and HookPromptFragment contracts. Byte and citation offsets are nonnegative but do not impose range ordering. Text elements retain a required nullable placeholder, text input retains the public snake-case text_elements field, and image detail remains optional but rejects explicit null. Citation and hook fields use their public camel-case spellings, and paths remain uninterpreted strings rather than gaining absolute-path requirements.

These definitions are also used by the standalone public ThreadItem union. They do not alias Gollem's durable ThreadRecord, TurnRecord, or TimelineItem, or claim that the runtime emits message, memory-citation, or hook-prompt items. Exact public lifecycle records now reference the union, but the method bindings retain Gollem's generic durable and runtime-specialized compatibility payloads until compatible producer paths are implemented.

The exact public CommandAction union is also exported independently. Its read path reuses the absolute normalized AbsolutePathBuf contract, while listFiles.path, search.query, and search.path are required nullable unrestricted strings. The four read/listFiles/search/unknown variants reject crossed and unknown fields. Exporting this parsed-command value does not parse live commands, change CommandExecutionSource, bind it into Gollem's legacy command item, or claim that the runtime emits public command actions.

The exact public McpToolCallAppContext value is exported with required connectorId and required nullable linkId, resourceUri, appName, templateId, and actionName fields. All use the public camel-case spelling, and canonical output includes explicit nulls. This definition is not bound into Gollem's legacy MCP item, projected from deprecated mcpAppResourceUri, or treated as evidence that connector metadata exists on current runtime calls.

The exact public WebSearchAction union is exported independently with strict search, openPage, findInPage, and other variants. The search query and query-list, open-page URL, and find-in-page URL/pattern follow the generated v2 TypeScript contract: each variant field is required nullable and canonical output includes explicit nulls. This deliberately resolves the public JSON Schema's looser Option-derived required list in favor of the generated client contract. It does not alias the distinct snake-case ResponsesApiWebSearchAction, add a search provider, bind a public thread item, or change current runtime events.

The schema also exports the exact standalone collab/subagent prerequisite values: unrestricted logical AgentPath, non-empty open ReasoningEffort, closed collab status/tool/tool-call-status and subagent activity enums, and CollabAgentState with required status plus required nullable message. The state follows the generated v2 TypeScript required-nullable shape rather than the looser Option-derived public JSON Schema required list. These definitions do not alias current internal agent state, add multi-agent methods, bind collab or subagent items, alter provider reasoning settings, or claim full public item parity.

The exact standalone raw-response content prerequisites are exported as strict validated unions: snake-case input-text/encrypted-content agent message input, reasoning-text/text reasoning content, and summary-text reasoning summary. Required content stays non-null, crossed and unknown fields fail closed, and canonical output preserves public snake-case names. They remain independently validated dependencies; the parent ResponseItem export does not bind raw-response notifications, map provider payloads, or change live agent/reasoning deltas.

The distinct ResponsesApiWebSearchAction union is also exported independently with snake-case search/open-page/find-in-page/other discriminators. Optional query, query-list, URL, and pattern fields are non-null when present and omit canonically when absent, following generated TypeScript rather than the looser Option-derived JSON Schema nullability. This remains distinct from the app-server action referenced by ResponseItem and does not add a provider/tool or bind live web-search events.

The standalone ResponseItem dependencies and full 16-variant response-item union are exported as strict validated values. Optional ids, phases, statuses, namespaces, prompts, actions, content, encrypted content, and metadata are non-null when present; fields declared nullable by generated TypeScript remain required and explicit. Arbitrary tool-search arguments and tool arrays retain all valid JSON values with number precision. The union references the existing app-server WebSearchAction contract and does not bind provider payloads, durable timeline items, live shell execution, lifecycle methods, or raw-response notifications.

The exact standalone RawResponseItemCompletedNotification requires thread id, turn id, and a strict ResponseItem. It preserves nested arbitrary JSON number precision and rejects unknown or malformed fields. The rawResponseItem/completed method remains blocked and unbound because Gollem has no provider/runtime producer for this event; client-originated thread/inject_items keeps its existing durable lifecycle behavior.

The next standalone ThreadItem dependencies are also exported without live item adoption: recursive precision-preserving JsonValue, strict image generation records, and exact JSON-valued McpToolCallResult. The existing all-caps MCP runtime result remains distinct because it still carries legacy MCPContent[] rather than general JSON values.

The exact standalone CommandExecutionSource enum exports agent, userShell, unifiedExecStartup, and unifiedExecInteraction. Gollem's live v1 CommandExecutionItem.source deliberately remains its existing inline agent | userShell field and does not reference the broader public enum. This is an additive type definition only: it does not broaden accepted or emitted runtime item values, change command producers, or require a protocol-version bump.

The standalone WebSearchItem requires id, query, and an explicit nullable action. Its action references the existing camel-case v2 WebSearchAction; the root snake-case ResponsesApiWebSearchAction remains a separate Responses API value. The item is a strict generated prerequisite only and does not add a search provider/tool, alias runtime records, or bind item lifecycle methods.

The complete standalone public ThreadItem union exports all 18 generated v2 variants with strict closed objects. Generated required-nullable fields remain explicit, only deprecated mcpAppResourceUri is optional non-null, JSON-valued arguments retain number precision, string arrays and collab-agent state maps reject null entries, and sleep duration is a nonnegative integer. Parent-local validation keeps legacy command, dynamic, MCP, patch-status, file-change, and MCP-error runtime types unchanged. This definition is intentionally not adopted by live item producers, durable records, or public Thread/Turn projections.

Exact ItemStartedNotification and ItemCompletedNotification definitions require a strict ThreadItem, thread id, turn id, and their corresponding millisecond timestamp. They are additive canonical variants on item/started and item/completed; the prior generic durable payload and four specialized runtime payload families remain in each method union. Existing producers are unchanged and continue to emit those explicit compatibility forms.

The first public Thread/Turn prerequisite group exports standalone ThreadId, NonSteerableTurnKind, TurnItemsView, TurnStatus, ThreadActiveFlag, ThreadSource, and GitInfo. The two open strings and four closed enums match their generated contracts; GitInfo requires all three nullable string fields. These definitions remain separate from Gollem's durable ThreadLifecycleStatus, TurnLifecycleStatus, filter-facing ThreadSourceKind, and patch-shaped ThreadMetadataGitInfoUpdateParams. No method, item, store record, runtime producer, or parent Thread/Turn type is bound by this prerequisite-only addition.

The dependent prerequisite layer exports standalone CodexErrorInfo, TurnError, ThreadStatus, SubAgentSource, and SessionSource. Strict closed unions enforce uint16 HTTP status and int32 spawn-depth bounds, fixed generated required-nullable fields, exact camel/snake-case variants, and non-null status flag arrays. Upstream serde omission defaults and the legacy agent_type alias are intentionally rejected because they are absent from the fixed generated TypeScript contract. These definitions still do not bind methods/items, replace Gollem runtime or durable provenance/error records, or project the public parent Turn and Thread records.

The thread-response policy prerequisite layer exports exact standalone ApprovalsReviewer, AskForApproval, NetworkAccess, and SandboxPolicy values. Closed reviewer/network enums, every required granular approval flag, strict sandbox discriminants, fixed generated required booleans, non-null writable-root arrays, and absolute normalized writable paths are validated at the Go wire boundary. Upstream serde input defaults are intentionally rejected when the fixed generated TypeScript output requires the field. These values do not replace Gollem's runtime approval, permission-profile, workspace, or sandbox policy models, and no method, item, grant, producer, or enforcement path is bound by this prerequisite-only addition.

Exact standalone ThreadStartResponse, ThreadResumeResponse, and ThreadForkResponse definitions share the same strict ten-field public shape. Every fixed generated field is required; service tier and reasoning effort are explicit nullable values, instruction source arrays/elements are non-null, working directories are absolute and normalized, and nested public thread and policy values retain their own strict validation. Experimental response fields are excluded. The implemented live start/resume handlers still return incompatible durable thread/turn maps, and the live fork handler now binds the separate Gollem-native history-fork contract described below. These public session definitions remain outside the method-binding map and do not claim producer parity.

The request-prerequisite layer exports exact standalone Personality, SandboxMode, and ThreadStartSource closed string enums. Their fixed public spellings are validated at the Go wire boundary. SandboxMode remains distinct from the tagged response-side SandboxPolicy and Gollem runtime policy models; ThreadStartSource remains distinct from public thread provenance, list-filter source kinds, and session provenance. These leaves do not bind methods/items, export their parent start/resume/fork request records, or change runtime model, policy, or transport behavior.

Exact standalone ThreadStartParams, ThreadResumeParams, and ThreadForkParams expose only the fixed non-experimental generated fields. Optional nullable overrides accept omission or null; resume and fork require an open-string thread id; fork alone gives ephemeral optional non-null boolean semantics. Config values retain strict recursive JSON and request cwd remains a generic string. The current live start/resume handlers require incompatible prompt/input, provider/settings, and id-alias fields. The live fork handler binds a narrower Gollem-native request rather than pretending to apply these public session overrides, so the exact public records remain standalone.

thread/fork binds Gollem-native ThreadHistoryForkParams and ThreadHistoryForkResult for response-loss-safe full-history copies. Typed clients provide only the source thread id and a bounded idempotency key. SQLite records that key separately from public thread metadata, refuses new forks while the source has queued or running turns, copies durable turns and items transactionally with regenerated identities, and returns the same child after response loss or process restart. Reused requests do not emit a second thread/started notification. File-change timeline evidence is retained for audit, but private exact-restoration snapshots never transfer to the child and the result says so explicitly. Legacy untyped title/metadata/include-item requests remain accepted without this typed idempotency guarantee.

Exact standalone ReasoningSummary, TurnStartParams, and TurnStartResponse establish the fixed canonical turn-start contract. TurnStartParams requires an open-string thread id and non-null strict UserInput array, preserves nullable model/policy/reasoning/personality and strict JSON output-schema overrides, and excludes experimental plus Gollem v1 prompt/provider aliases. The current live handler accepts a broader prompt-driven request and returns a durable turn map, so these definitions remain outside method bindings pending a separate compatibility migration.

Exact standalone TurnInterruptParams and TurnInterruptResponse establish the fixed canonical turn-interrupt contract. The params require open-string thread and turn ids, and the response is a closed empty object. The current live handler accepts a legacy id alias without required thread correlation and returns a richer durable interrupt result, so these definitions remain outside method bindings pending a separate compatibility migration.

Exact TurnSteerParams and TurnSteerResponse establish the fixed canonical turn-steer contract. The params require thread id, strict user input, and an expected active turn id, with optional nullable client message id; the response requires turn id. The live handler binds these exact contracts, requires the supplied thread and expected turn to identify the active run, and currently accepts only text user-input parts. Other valid public input variants fail explicitly until the runtime supports multimodal steering.

Accepted text is persisted as a queued steer timeline item before it becomes visible to the run. At most 64 instructions may remain pending; further requests receive an overloaded error and a failed durable item. The agent consumes queued instructions in order at the next safe model-request boundary after the current response and any tool results. The item becomes completed only after that next provider stream starts; interruption, terminal completion, or request failure first marks it failed. Only completed steer items enter later thread-history replay. Repeating the same non-empty client message id and text while the turn remains active reuses the original item; reusing the id for different text fails closed. Clients reconcile the durable item through lifecycle notifications or a fresh thread/read. Steering does not cancel an in-flight provider stream and is not same-execution resume.

TurnRunRetryParams and TurnRunRetryResult define Gollem's restart-safe retry extension. Typed clients must persist a non-empty idempotency key before calling turn/retry; replaying the same source-turn/key pair returns the same durable retry turn without another model invocation. A key already bound to a different source fails closed. Retry requires a terminal source and creates a new turn whose retryOfTurnId and retryIdempotencyKey remain visible through durable thread reads; it does not claim same-turn execution resume, recreate pending approval authority, or silently treat prior tool side effects as resumed. A new model attempt can independently request the same mutation again, so clients must present that consequence before retrying a turn with incomplete tool work. On daemon startup, the process-lifetime store owner terminalizes stale queued or running turns with a stable owner-loss reason and one durable runtimeRecovery marker before accepting a transport.

Exact standalone TurnPlanStepStatus, TurnPlanStep, and TurnPlanUpdatedNotification establish the fixed turn-level plan snapshot. Canonical output requires an explicit nullable explanation and a non-null plan array; decoding also accepts an omitted explanation because the pinned Rust wire type accepts it before serializing the value back as null. Gollem has no exact live producer for turn/plan/updated, so the method remains blocked and unbound rather than claiming notification delivery that does not exist.

Exact standalone ThreadResumeInitialTurnsPageParams and TurnsPage establish the experimental resume-pagination value layer without widening the fixed ThreadResumeParams or binding the incompatible live resume handler. Params accept omitted or explicit-null uint32 limit, sort direction, and item view; pages require a non-null strict turn array and canonical TypeScript requires both nullable cursors. The pinned Rust decoder accepts omitted option values and its serializer emits them as explicit null, so Gollem preserves that decode compatibility and canonicalizes absent values to null on marshal.

Exact standalone agent-message, plan, reasoning-summary, and reasoning-text delta notification records establish the fixed item-progress value layer. All ids and deltas are required open strings; reasoning indexes are required signed int64 values and generate as TypeScript number. The live agent-message and reasoning-text producers remain unbound because they omit required itemId and emit incompatible index/at extensions. Plan and reasoning-summary methods remain blocked until exact producers exist.

The standalone external-agent import-history record is the narrow exception to the default integer mapping: its required completedAtMs remains signed int64 in Go and JSON Schema but generates as TypeScript bigint to match the pinned ts-rs contract. The history record and its read-response wrapper remain unbound and do not add import execution, persistence, or history-read behavior.

Exact standalone fuzzy-file-search params, result kind, result, response, and session notification records preserve the pinned camel-case envelopes and the intentional snake-case match_type/file_name result fields. Scores and match indices retain strict uint32 bounds, optional values canonicalize to explicit null, and non-null arrays canonicalize nil to []. The request and notification methods remain deferred and unbound; these values add no filesystem access, search, ranking, cancellation, session, or notification behavior. Their strict compile contract is typescript/testdata/fuzzy_file_search_contract.ts.

Exact standalone hook event, execution-mode, handler-type, output-kind, run-status, scope, source, and trust-status enums plus HookOutputEntry establish the dependency-free public hook value layer. All literals remain closed and case-sensitive; output entries require kind and text while serde input discards unknown fields. No hook summary, lifecycle/list parent, method binding, discovery, trust decision, execution, persistence, or notification producer is added. Their strict compile contract is typescript/testdata/hook_value_foundation_contract.ts.

Exact standalone HookRunSummary, HookStartedNotification, and HookCompletedNotification records extend that value layer without binding a producer. Summary input accepts omitted source as unknown and omitted option fields as null; canonical output includes every field and normalizes nil entries to []. Signed int64 fields remain integer/int64 in JSON Schema and generate as TypeScript bigint. Both hook/started and hook/completed remain blocked and unbound. Their strict compile contract is typescript/testdata/hook_run_notification_contract.ts.

Exact standalone Guardian approval review status, command source, risk level, user authorization, and network approval protocol enums establish the closed leaf layer needed by later Guardian review records. All literals are closed and case-sensitive, including camel-case inProgress, timedOut, unifiedExec, socks5Tcp, and socks5Udp. The standalone unstable GuardianApprovalReview record accepts omitted nullable options like serde but emits them explicitly like ts-rs. No Guardian action union, notification, assessment, replay, approval, policy enforcement, method/item binding, producer, persistence, or runtime behavior is added. Their strict compile contracts are typescript/testdata/guardian_enum_foundation_contract.ts and typescript/testdata/guardian_approval_review_contract.ts.

Exact standalone warning, guardian-warning, and error notification records establish the fixed public warning/error value layer. Canonical warning output requires explicit nullable thread id, while decoding also accepts omission to match the pinned Rust Option input. Guardian warnings require thread id and message; errors require strict TurnError, retry state, thread id, and turn id. The current live error producer remains unbound because it emits a string error, optional ids, and an at timestamp without retry state. Warning and guardian-warning methods remain blocked until exact producers exist.

Exact standalone config-warning position, range, and notification records establish the fixed public config-diagnostic value layer. Positions use unsigned line/column values; the source documents 1-based coordinates while the wire type still accepts zero. Canonical config warnings require explicit nullable details, while decoding also accepts omission to match the pinned Rust Option input. Path and range are optional non-null fields and are omitted from canonical output when absent. configWarning remains blocked and unbound until Gollem has an exact config-diagnostic producer.

Exact standalone model-reroute, model-verification, turn-moderation-metadata, and safety-buffering records establish the fixed public model-safety value layer. Reroute reasons and verification values are closed one-value enums; verification and buffering arrays are required non-null collections; moderation metadata preserves arbitrary precision-safe JsonValue; and canonical buffering output requires explicit nullable fasterModel while decoding also accepts omission. All four notification methods remain blocked and unbound until Gollem has exact model-safety producers.

Exact standalone input-modality, reasoning-effort-option, availability-notice, service-tier, and upgrade-info records establish the dependency-free public model-catalog leaf layer. Input modalities are closed; effort options reuse the existing strict open ReasoningEffort; and canonical upgrade output requires all three nullable strings while decoding also accepts their Rust Option omission form. These values remain separate from appserver/catalog's broader live model/request/response records and do not change method bindings or runtime JSON.

The exact standalone Model parent composes that leaf layer without binding model/list. Canonical output includes all sixteen fields and non-null arrays; decoding accepts omitted Rust Option values and applies the pinned serde defaults for modalities, personality support, speed/service tiers, and the default service tier. Gollem's live catalog intentionally adds provider ids, capabilities, token limits, and provider-filter request extensions. The two models remain distinct until an explicit list adapter can preserve those live features without claiming that the extended response is the exact public contract.

Exact standalone ModelListParams and ModelListResponse complete the public list-envelope value layer without binding model/list. Params accept optional nullable cursor, uint32 limit, and hidden-model selection while canonical output emits all three fields. Responses require a non-null exact Model array and canonical nullable next cursor while accepting omitted Rust Option cursor input. The live request and response remain provider-extended, so an explicit projection is still required before generated method inference can replace unknown.

Exact standalone ModelProviderCapabilitiesReadParams and ModelProviderCapabilitiesReadResponse expose the fixed empty request and required namespace-tools, image-generation, and web-search booleans without binding the live capability endpoint. Gollem's handler accepts provider selectors and returns a broader provider capability record, so generated method inference remains unknown pending an explicit compatibility adapter.

Exact standalone NewThreadModelDefaults and ModelsRequirements expose the fixed nullable new-thread model, reasoning-effort, and service-tier defaults. ComputerUseRequirements, ResidencyRequirement, WebSearchMode, WindowsSandboxSetupMode, ConfigRequirements, and ConfigRequirementsReadResponse complete the fixed public configuration- requirement graph with canonical required-nullable output. These values remain separate from Gollem's provider/environment requirement rows and data alias, so configRequirements/read inference remains unknown pending an explicit projection adapter.

Exact standalone ConfiguredHookHandler, ConfiguredHookMatcherGroup, and ManagedHooksRequirements expose the strict managed-hook configuration value graph. Command handlers canonicalize nullable Windows-command, timeout, and status fields; matcher groups and all ten case-sensitive event arrays are non-null. These values do not register or execute hooks, bind into the live config endpoint, or claim managed-hook enforcement; those runtime and policy decisions remain separate.

Generation

Run:

go generate ./appserver/protocol

This rewrites schema.json and typescript/gollem_appserver_protocol.ts from exported Go wire types and binding metadata. It also rewrites the TypeScript compile fixtures at typescript/testdata/runtime_wire_v1.ts, typescript/testdata/initialize_wire_v1.ts, and typescript/testdata/thread_discovery_wire_v1.ts, plus typescript/testdata/thread_control_wire_v1.ts and typescript/testdata/thread_goal_wire_v1.ts, plus typescript/testdata/thread_metadata_wire_v1.ts and typescript/testdata/thread_lifecycle_notification_wire_v1.ts, plus typescript/testdata/command_exec_control_wire_v1.ts and typescript/testdata/file_change_item_wire_v1.ts, plus typescript/testdata/dynamic_tool_call_wire_v1.ts, plus typescript/testdata/user_input_wire_v1.ts, plus typescript/testdata/mcp_elicitation_wire_v1.ts, plus typescript/testdata/command_approval_response_wire_v1.ts, plus the unbound permission profile fixture at typescript/testdata/permission_profile_wire_v1.ts. File-change item, dynamic tool-call, user-input, MCP-elicitation, command-approval, and permission-profile variants also have strict negative compile contracts. The exported thread-item message prerequisites have a separate strict compile contract at typescript/testdata/thread_item_message_contract.ts; standalone command source compatibility is covered at typescript/testdata/command_execution_source_contract.ts, and the standalone search item at typescript/testdata/web_search_item_contract.ts. The full standalone union has its strict equality and malformed-shape contract at typescript/testdata/thread_item_contract.ts; exact lifecycle records and their compatibility-preserving method unions are covered at typescript/testdata/item_lifecycle_notification_contract.ts; the standalone, unbound raw-response completion record is covered at typescript/testdata/raw_response_item_completed_contract.ts; the public thread/turn leaf prerequisites are covered at typescript/testdata/thread_turn_leaf_contract.ts; their dependent error, status, and session-source layer is covered at typescript/testdata/thread_turn_dependency_contract.ts; the standalone thread-response approval/sandbox prerequisites are covered at typescript/testdata/thread_response_policy_prerequisite_contract.ts; the three exact standalone start/resume/fork responses are covered at typescript/testdata/thread_session_response_contract.ts; and their request-side enum prerequisites are covered at typescript/testdata/thread_request_prerequisite_contract.ts; the exact standalone parent request records are covered at typescript/testdata/thread_session_param_contract.ts; the exact standalone turn-start enum, params, and response are covered at typescript/testdata/turn_start_contract.ts; and the exact standalone turn-interrupt params and empty response are covered at typescript/testdata/turn_interrupt_contract.ts; and the exact standalone turn-steer params and response are covered at typescript/testdata/turn_steer_contract.ts; and the exact standalone turn-plan status, step, and notification are covered at typescript/testdata/turn_plan_contract.ts; and the standalone initial-turn pagination params and page values are covered at typescript/testdata/thread_resume_pagination_contract.ts; and the exact standalone item-delta notification values are covered at typescript/testdata/item_delta_notification_contract.ts; the exact standalone config-warning position, range, and notification values are covered at typescript/testdata/config_warning_notification_contract.ts; the exact standalone model-safety enum and notification values are covered at typescript/testdata/model_safety_notification_contract.ts; the exact standalone model-catalog leaf values are covered at typescript/testdata/model_catalog_leaf_contract.ts; the exact standalone model parent is covered at typescript/testdata/model_contract.ts; and the exact standalone dynamic-tool specification graph is covered at typescript/testdata/dynamic_tool_spec_contract.ts. Tests compare generated bytes with the checked-in files, verify every type binding references a known method and definition, and enforce a compatibility floor for runtime items, daemon status, initialization, thread discovery, thread controls, thread goals, metadata, lifecycle notifications, command-exec controls, and file changes. Dynamic client-tool, dynamic-tool specification, structured user-input, MCP-elicitation, command approval, permission-profile, and thread-item prerequisite contracts are covered by the same floor and strict fixtures.

testdata/runtime_wire_v1.json contains versioned request, response, and notification examples for generated-client compatibility tests. testdata/initialize_wire_v1.json independently covers the initialize request, initialize response, advertised method metadata, and initialized notification. testdata/thread_discovery_wire_v1.json covers typed list/read requests and responses, including nested turns and timeline items. testdata/thread_control_wire_v1.json covers loaded-list and lifecycle-control requests/responses, including public empty response forms. testdata/thread_goal_wire_v1.json covers structured goal get/set/clear and goal update/clear notifications. testdata/thread_metadata_wire_v1.json covers public and legacy metadata/memory requests, their responses, and the public rename notification. testdata/thread_lifecycle_notification_wire_v1.json covers archive, close, delete, and unarchive notifications. testdata/command_exec_control_wire_v1.json covers public and legacy write, resize, and terminate controls, empty-compatible responses, and streamed output. testdata/file_change_item_wire_v1.json covers add/delete, public and legacy updates, public-field precedence, and all four patch statuses. testdata/dynamic_tool_call_wire_v1.json covers the exact public request, optional Gollem v1 request metadata, and text/image response variants. testdata/user_input_wire_v1.json covers the structured question/options request, optional Gollem v1 prompt metadata, and exact answer-map response. testdata/mcp_elicitation_wire_v1.json covers form, OpenAI-form, and URL requests, the exact primitive schema family, optional Gollem correlation metadata, and action/content/meta responses. testdata/command_approval_response_wire_v1.json covers the live command approval request's advertised decision subset and the exact direct response. testdata/permission_profile_wire_v1.json covers the exact exported public permission request/response and filesystem/network profile family without adding an incompatible live result binding. testdata/filesystem_wire_v1.json covers all public filesystem requests and responses, empty response forms, watch notifications, and the mutation notification extension.

The current request_mcp_elicitation runtime tool validates and emits only the public form variant. The openai/form and url variants are exported for wire-compatible clients but are not synthesized by the runtime. Bridging protocol-originated MCP elicitation requests remains separate work.

Consumers can use x-gollem-type-bindings to select method parameter/result definitions and x-gollem-item-payload-bindings to decode TimelineItem.payload by kind.

When TypeScript is installed, verify the generated binding and v1 fixtures with:

tsc --project appserver/protocol/typescript/tsconfig.json

The generated TypeScript uses unknown for open JSON values and unclassified timeline payloads. Consumers must narrow those values at runtime and preserve unknown item kinds rather than casting them to a known variant.

Documentation

Overview

Package protocol defines Gollem's app-server JSON-RPC contract.

The app-server wire format intentionally follows Codex-style JSON-RPC messages with the jsonrpc member omitted on outbound messages. Decoders still accept a jsonrpc member so tests and generic JSON-RPC clients can send ordinary JSON-RPC 2.0 envelopes during bring-up.

Code generated from docs/protocol-method-inventory.md; DO NOT EDIT.

Index

Constants

View Source 
const (
	CommandExecutionApprovalAccept                        = "accept"
	CommandExecutionApprovalAcceptForSession              = "acceptForSession"
	CommandExecutionApprovalAcceptWithExecpolicyAmendment = "acceptWithExecpolicyAmendment"
	CommandExecutionApprovalApplyNetworkPolicyAmendment   = "applyNetworkPolicyAmendment"
	CommandExecutionApprovalDecline                       = "decline"
	CommandExecutionApprovalCancel                        = "cancel"
)
View Source 
const (
	CodeParseError     = -32700
	CodeInvalidRequest = -32600
	CodeMethodNotFound = -32601
	CodeInvalidParams  = -32602
	CodeInternalError  = -32603

	// CodeOverloaded is the Codex-compatible app-server backpressure code.
	CodeOverloaded = -32001
	// CodeMethodUnavailable is used for known Codex-equivalent or Gollem
	// extension methods that are schema-defined but not implemented yet.
	CodeMethodUnavailable = -32004
)
View Source 
const (
	ProtocolVersion = "gollem.appserver.v1"
	SchemaVersion   = "gollem.appserver.schema.v1"
)
View Source 
const (
	McpServerElicitationModeForm       = "form"
	McpServerElicitationModeOpenAIForm = "openai/form"
	McpServerElicitationModeURL        = "url"
)
View Source 
const (
	FileSystemAccessRead  FileSystemAccessMode = "read"
	FileSystemAccessWrite FileSystemAccessMode = "write"
	FileSystemAccessDeny  FileSystemAccessMode = "deny"

	PermissionGrantTurn    PermissionGrantScope = "turn"
	PermissionGrantSession PermissionGrantScope = "session"
)
View Source 
const (
	ReviewDecisionApproved                    = "approved"
	ReviewDecisionApprovedExecPolicyAmendment = "approved_execpolicy_amendment"
	ReviewDecisionApprovedForSession          = "approved_for_session"
	ReviewDecisionNetworkPolicyAmendment      = "network_policy_amendment"
	ReviewDecisionDenied                      = "denied"
	ReviewDecisionTimedOut                    = "timed_out"
	ReviewDecisionAbort                       = "abort"
)
View Source 
const (
	ItemTypeDynamicToolCall   = "dynamicToolCall"
	ItemTypeCommandExecution  = "commandExecution"
	ItemTypeFileChange        = "fileChange"
	ItemTypeMCPToolCall       = "mcpToolCall"
	ItemTypeContextCompaction = "contextCompaction"

	ItemStatusInProgress = "inProgress"
	ItemStatusCompleted  = "completed"
	ItemStatusFailed     = "failed"
	ItemStatusDeclined   = "declined"
)
View Source 
const (
	ApprovalsReviewerUser             ApprovalsReviewer = "user"
	ApprovalsReviewerAutoReview       ApprovalsReviewer = "auto_review"
	ApprovalsReviewerGuardianSubagent ApprovalsReviewer = "guardian_subagent"

	NetworkAccessRestricted NetworkAccess = "restricted"
	NetworkAccessEnabled    NetworkAccess = "enabled"
)

Variables

This section is empty.

Functions

func IsKnownMethod 

func IsKnownMethod(method string) bool

IsKnownMethod reports whether method is in the app-server contract inventory.

func MarshalJSONSchema 

func MarshalJSONSchema() ([]byte, error)

func MarshalPermissionProfileTypeScriptFixture 

func MarshalPermissionProfileTypeScriptFixture(data []byte) ([]byte, error)

MarshalPermissionProfileTypeScriptFixture generates a strict compile fixture for the exported public permission types without creating a live binding.

func MarshalTypeScript 

func MarshalTypeScript() ([]byte, error)

MarshalTypeScript generates the TypeScript binding for the current public app-server schema and binding metadata.

func MarshalTypeScriptFixture 

func MarshalTypeScriptFixture(data []byte) ([]byte, error)

MarshalTypeScriptFixture converts the versioned JSON wire examples into a TypeScript compile fixture using the generated method and payload bindings.

Types

type AbsolutePathBuf 

type AbsolutePathBuf string

AbsolutePathBuf is an absolute, lexically normalized local path.

func (AbsolutePathBuf) MarshalJSON 

func (p AbsolutePathBuf) MarshalJSON() ([]byte, error)

func (*AbsolutePathBuf) UnmarshalJSON 

func (p *AbsolutePathBuf) UnmarshalJSON(data []byte) error

type Account 

type Account struct {
	// contains filtered or unexported fields
}

Account is exact standalone public account identity data. It does not expose credentials or imply that Gollem owns authentication state.

func (Account) MarshalJSON 

func (a Account) MarshalJSON() ([]byte, error)

func (Account) Type 

func (a Account) Type() string

Type returns the public account discriminant, or an empty string for an uninitialized or invalid internal value.

func (*Account) UnmarshalJSON 

func (a *Account) UnmarshalJSON(data []byte) error

type AccountLoginCompletedNotification 

type AccountLoginCompletedNotification struct {
	LoginID *string `json:"loginId,omitempty"`
	Success bool    `json:"success"`
	Error   *string `json:"error,omitempty"`
}

AccountLoginCompletedNotification is exact standalone public login-result data. The corresponding notification remains deferred and unbound.

func (AccountLoginCompletedNotification) MarshalJSON 

func (n AccountLoginCompletedNotification) MarshalJSON() ([]byte, error)

func (*AccountLoginCompletedNotification) UnmarshalJSON 

func (n *AccountLoginCompletedNotification) UnmarshalJSON(data []byte) error

type AccountRateLimitsUpdatedNotification 

type AccountRateLimitsUpdatedNotification struct {
	RateLimits RateLimitSnapshot `json:"rateLimits"`
}

AccountRateLimitsUpdatedNotification is exact standalone rolling-update data.

func (AccountRateLimitsUpdatedNotification) MarshalJSON 

func (n AccountRateLimitsUpdatedNotification) MarshalJSON() ([]byte, error)

func (*AccountRateLimitsUpdatedNotification) UnmarshalJSON 

func (n *AccountRateLimitsUpdatedNotification) UnmarshalJSON(data []byte) error

type AccountTokenUsageDailyBucket 

type AccountTokenUsageDailyBucket struct {
	StartDate string `json:"startDate"`
	Tokens    int64  `json:"tokens"`
}

AccountTokenUsageDailyBucket is exact standalone public account-usage data. Gollem does not fetch, aggregate, or persist account token usage.

func (AccountTokenUsageDailyBucket) MarshalJSON 

func (b AccountTokenUsageDailyBucket) MarshalJSON() ([]byte, error)

func (*AccountTokenUsageDailyBucket) UnmarshalJSON 

func (b *AccountTokenUsageDailyBucket) UnmarshalJSON(data []byte) error

type AccountTokenUsageSummary 

type AccountTokenUsageSummary struct {
	LifetimeTokens        *int64 `json:"lifetimeTokens,omitempty"`
	PeakDailyTokens       *int64 `json:"peakDailyTokens,omitempty"`
	LongestRunningTurnSec *int64 `json:"longestRunningTurnSec,omitempty"`
	CurrentStreakDays     *int64 `json:"currentStreakDays,omitempty"`
	LongestStreakDays     *int64 `json:"longestStreakDays,omitempty"`
}

AccountTokenUsageSummary is exact standalone public account-usage summary data. Nullable values are canonicalized explicitly without aggregation.

func (AccountTokenUsageSummary) MarshalJSON 

func (s AccountTokenUsageSummary) MarshalJSON() ([]byte, error)

func (*AccountTokenUsageSummary) UnmarshalJSON 

func (s *AccountTokenUsageSummary) UnmarshalJSON(data []byte) error

type AccountUpdatedNotification 

type AccountUpdatedNotification struct {
	AuthMode *AuthMode `json:"authMode,omitempty"`
	PlanType *PlanType `json:"planType,omitempty"`
}

AccountUpdatedNotification is exact standalone account metadata.

func (AccountUpdatedNotification) MarshalJSON 

func (n AccountUpdatedNotification) MarshalJSON() ([]byte, error)

func (*AccountUpdatedNotification) UnmarshalJSON 

func (n *AccountUpdatedNotification) UnmarshalJSON(data []byte) error

type ActivePermissionProfile 

type ActivePermissionProfile struct {
	ID      string  `json:"id"`
	Extends *string `json:"extends"`
}

func (*ActivePermissionProfile) UnmarshalJSON 

func (p *ActivePermissionProfile) UnmarshalJSON(data []byte) error

type AddCreditsNudgeCreditType 

type AddCreditsNudgeCreditType string

AddCreditsNudgeCreditType is the exact closed public credit category. It is standalone from account eligibility, billing, and email-delivery runtime. 

const (
	AddCreditsNudgeCreditTypeCredits    AddCreditsNudgeCreditType = "credits"
	AddCreditsNudgeCreditTypeUsageLimit AddCreditsNudgeCreditType = "usage_limit"
)

func (AddCreditsNudgeCreditType) MarshalJSON 

func (c AddCreditsNudgeCreditType) MarshalJSON() ([]byte, error)

func (*AddCreditsNudgeCreditType) UnmarshalJSON 

func (c *AddCreditsNudgeCreditType) UnmarshalJSON(data []byte) error

type AddCreditsNudgeEmailStatus 

type AddCreditsNudgeEmailStatus string

AddCreditsNudgeEmailStatus is the exact closed public email outcome. It does not imply that Gollem sends email or implements a cooldown. 

const (
	AddCreditsNudgeEmailStatusSent           AddCreditsNudgeEmailStatus = "sent"
	AddCreditsNudgeEmailStatusCooldownActive AddCreditsNudgeEmailStatus = "cooldown_active"
)

func (AddCreditsNudgeEmailStatus) MarshalJSON 

func (s AddCreditsNudgeEmailStatus) MarshalJSON() ([]byte, error)

func (*AddCreditsNudgeEmailStatus) UnmarshalJSON 

func (s *AddCreditsNudgeEmailStatus) UnmarshalJSON(data []byte) error

type AdditionalContextEntry 

type AdditionalContextEntry struct {
	Value string                `json:"value"`
	Kind  AdditionalContextKind `json:"kind"`
}

AdditionalContextEntry is an exact standalone public context fragment. Its decoder ignores unknown fields for Rust-compatible input evolution while canonical output contains only the two public fields.

func (*AdditionalContextEntry) UnmarshalJSON 

func (e *AdditionalContextEntry) UnmarshalJSON(data []byte) error

type AdditionalContextKind 

type AdditionalContextKind string

AdditionalContextKind is the exact closed public context trust category. 

const (
	AdditionalContextKindUntrusted   AdditionalContextKind = "untrusted"
	AdditionalContextKindApplication AdditionalContextKind = "application"
)

func (AdditionalContextKind) MarshalJSON 

func (k AdditionalContextKind) MarshalJSON() ([]byte, error)

func (*AdditionalContextKind) UnmarshalJSON 

func (k *AdditionalContextKind) UnmarshalJSON(data []byte) error

type AdditionalFileSystemPermissions 

type AdditionalFileSystemPermissions struct {
	Read             []LegacyAppPathString    `json:"read" jsonschema:"description=This will be removed in favor of entries."`
	Write            []LegacyAppPathString    `json:"write" jsonschema:"description=This will be removed in favor of entries."`
	GlobScanMaxDepth *uint64                  `json:"globScanMaxDepth,omitempty" jsonschema:"nonnullable=true"`
	Entries          []FileSystemSandboxEntry `json:"entries,omitempty" jsonschema:"nonnullable=true"`
}

func (AdditionalFileSystemPermissions) MarshalJSON 

func (p AdditionalFileSystemPermissions) MarshalJSON() ([]byte, error)

func (*AdditionalFileSystemPermissions) UnmarshalJSON 

func (p *AdditionalFileSystemPermissions) UnmarshalJSON(data []byte) error

type AdditionalNetworkPermissions 

type AdditionalNetworkPermissions struct {
	Enabled *bool `json:"enabled"`
}

func (*AdditionalNetworkPermissions) UnmarshalJSON 

func (p *AdditionalNetworkPermissions) UnmarshalJSON(data []byte) error

type AdditionalPermissionProfile 

type AdditionalPermissionProfile struct {
	Network    *AdditionalNetworkPermissions    `json:"network"`
	FileSystem *AdditionalFileSystemPermissions `json:"fileSystem"`
}

func (*AdditionalPermissionProfile) UnmarshalJSON 

func (p *AdditionalPermissionProfile) UnmarshalJSON(data []byte) error

type AgentMessageDeltaNotification 

type AgentMessageDeltaNotification struct {
	ThreadID string `json:"threadId"`
	TurnID   string `json:"turnId"`
	ItemID   string `json:"itemId"`
	Delta    string `json:"delta"`
}

func (*AgentMessageDeltaNotification) UnmarshalJSON 

func (n *AgentMessageDeltaNotification) UnmarshalJSON(data []byte) error

type AgentMessageInputContent 

type AgentMessageInputContent struct {
	// contains filtered or unexported fields
}

func (AgentMessageInputContent) MarshalJSON 

func (c AgentMessageInputContent) MarshalJSON() ([]byte, error)

func (*AgentMessageInputContent) UnmarshalJSON 

func (c *AgentMessageInputContent) UnmarshalJSON(data []byte) error

type AgentPath 

type AgentPath string

AgentPath is the public logical agent identifier path. It is not a local filesystem path and intentionally has no normalization or non-empty rule.

func (AgentPath) MarshalJSON 

func (p AgentPath) MarshalJSON() ([]byte, error)

func (*AgentPath) UnmarshalJSON 

func (p *AgentPath) UnmarshalJSON(data []byte) error

type AmazonBedrockCredentialSource 

type AmazonBedrockCredentialSource string

AmazonBedrockCredentialSource is the exact closed public credential ownership mode. It is standalone from Gollem's account and provider runtime. 

const (
	AmazonBedrockCredentialSourceCodexManaged AmazonBedrockCredentialSource = "codexManaged"
	AmazonBedrockCredentialSourceAWSManaged   AmazonBedrockCredentialSource = "awsManaged"
)

func (AmazonBedrockCredentialSource) MarshalJSON 

func (s AmazonBedrockCredentialSource) MarshalJSON() ([]byte, error)

func (*AmazonBedrockCredentialSource) UnmarshalJSON 

func (s *AmazonBedrockCredentialSource) UnmarshalJSON(data []byte) error

type AnalyticsConfig 

type AnalyticsConfig struct {
	Enabled    *bool                `json:"enabled"`
	Additional map[string]JsonValue `json:"-"`
}

AnalyticsConfig preserves public flattened analytics fields as exact JSON values while keeping enabled as the one known nullable field.

func (AnalyticsConfig) MarshalJSON 

func (c AnalyticsConfig) MarshalJSON() ([]byte, error)

func (*AnalyticsConfig) UnmarshalJSON 

func (c *AnalyticsConfig) UnmarshalJSON(data []byte) error

type AppBranding 

type AppBranding struct {
	Category          *string `json:"category,omitempty"`
	Developer         *string `json:"developer,omitempty"`
	Website           *string `json:"website,omitempty"`
	PrivacyPolicy     *string `json:"privacyPolicy,omitempty"`
	TermsOfService    *string `json:"termsOfService,omitempty"`
	IsDiscoverableApp bool    `json:"isDiscoverableApp"`
}

AppBranding is exact standalone public branding data for experimental apps. App discovery and runtime behavior remain deferred and unbound.

func (AppBranding) MarshalJSON 

func (b AppBranding) MarshalJSON() ([]byte, error)

func (*AppBranding) UnmarshalJSON 

func (b *AppBranding) UnmarshalJSON(data []byte) error

type AppConfig 

type AppConfig struct {
	Enabled                  bool               `json:"enabled"`
	ApprovalsReviewer        *ApprovalsReviewer `json:"approvals_reviewer,omitempty"`
	DestructiveEnabled       *bool              `json:"destructive_enabled,omitempty"`
	OpenWorldEnabled         *bool              `json:"open_world_enabled,omitempty"`
	DefaultToolsApprovalMode *AppToolApproval   `json:"default_tools_approval_mode,omitempty"`
	DefaultToolsEnabled      *bool              `json:"default_tools_enabled,omitempty"`
	Tools                    *AppToolsConfig    `json:"tools,omitempty"`
}

AppConfig is exact standalone configuration data for one app. Policy interpretation, persistence, and app-tool execution remain deferred.

func (AppConfig) MarshalJSON 

func (c AppConfig) MarshalJSON() ([]byte, error)

func (*AppConfig) UnmarshalJSON 

func (c *AppConfig) UnmarshalJSON(data []byte) error

type AppInfo 

type AppInfo struct {
	ID                  string             `json:"id"`
	Name                string             `json:"name"`
	Description         *string            `json:"description,omitempty"`
	LogoURL             *string            `json:"logoUrl,omitempty"`
	LogoURLDark         *string            `json:"logoUrlDark,omitempty"`
	IconAssets          *map[string]string `json:"iconAssets,omitempty"`
	IconDarkAssets      *map[string]string `json:"iconDarkAssets,omitempty"`
	DistributionChannel *string            `json:"distributionChannel,omitempty"`
	Branding            *AppBranding       `json:"branding,omitempty"`
	AppMetadata         *AppMetadata       `json:"appMetadata,omitempty"`
	Labels              *map[string]string `json:"labels,omitempty"`
	InstallURL          *string            `json:"installUrl,omitempty"`
	IsAccessible        bool               `json:"isAccessible"`
	IsEnabled           bool               `json:"isEnabled"`
	PluginDisplayNames  []string           `json:"pluginDisplayNames"`
}

AppInfo is exact standalone metadata for an experimental app. App discovery, policy interpretation, and runtime behavior remain deferred.

func (AppInfo) MarshalJSON 

func (i AppInfo) MarshalJSON() ([]byte, error)

func (*AppInfo) UnmarshalJSON 

func (i *AppInfo) UnmarshalJSON(data []byte) error

type AppListUpdatedNotification 

type AppListUpdatedNotification struct {
	Data []AppInfo `json:"data" jsonschema:"nonnullable=true"`
}

AppListUpdatedNotification is an exact standalone app-list snapshot value. Production, delivery, and app discovery remain deferred.

func (AppListUpdatedNotification) MarshalJSON 

func (n AppListUpdatedNotification) MarshalJSON() ([]byte, error)

func (*AppListUpdatedNotification) UnmarshalJSON 

func (n *AppListUpdatedNotification) UnmarshalJSON(data []byte) error

type AppMetadata 

type AppMetadata struct {
	Review                     *AppReview       `json:"review,omitempty"`
	Categories                 *[]string        `json:"categories,omitempty"`
	SubCategories              *[]string        `json:"subCategories,omitempty"`
	SEODescription             *string          `json:"seoDescription,omitempty"`
	Screenshots                *[]AppScreenshot `json:"screenshots,omitempty"`
	Developer                  *string          `json:"developer,omitempty"`
	Version                    *string          `json:"version,omitempty"`
	VersionID                  *string          `json:"versionId,omitempty"`
	VersionNotes               *string          `json:"versionNotes,omitempty"`
	FirstPartyType             *string          `json:"firstPartyType,omitempty"`
	FirstPartyRequiresInstall  *bool            `json:"firstPartyRequiresInstall,omitempty"`
	ShowInComposerWhenUnlinked *bool            `json:"showInComposerWhenUnlinked,omitempty"`
}

AppMetadata is exact standalone descriptive metadata for experimental apps. App discovery, policy interpretation, and runtime behavior remain deferred.

func (AppMetadata) MarshalJSON 

func (m AppMetadata) MarshalJSON() ([]byte, error)

func (*AppMetadata) UnmarshalJSON 

func (m *AppMetadata) UnmarshalJSON(data []byte) error

type AppReview 

type AppReview struct {
	Status string `json:"status"`
}

AppReview is an exact opaque app-review status value.

func (AppReview) MarshalJSON 

func (r AppReview) MarshalJSON() ([]byte, error)

func (*AppReview) UnmarshalJSON 

func (r *AppReview) UnmarshalJSON(data []byte) error

type AppScreenshot 

type AppScreenshot struct {
	URL        *string `json:"url,omitempty"`
	FileID     *string `json:"fileId,omitempty"`
	UserPrompt string  `json:"userPrompt"`
}

AppScreenshot is exact standalone public screenshot metadata. Gollem does not fetch or interpret the URL, file identifier, or user prompt.

func (AppScreenshot) MarshalJSON 

func (s AppScreenshot) MarshalJSON() ([]byte, error)

func (*AppScreenshot) UnmarshalJSON 

func (s *AppScreenshot) UnmarshalJSON(data []byte) error

type AppSummary 

type AppSummary struct {
	ID          string  `json:"id"`
	Name        string  `json:"name"`
	Description *string `json:"description,omitempty"`
	InstallURL  *string `json:"installUrl,omitempty"`
	Category    *string `json:"category,omitempty"`
}

AppSummary is exact standalone descriptive app metadata for plugin results. Category derivation, app discovery, and plugin runtime behavior remain absent.

func (AppSummary) MarshalJSON 

func (s AppSummary) MarshalJSON() ([]byte, error)

func (*AppSummary) UnmarshalJSON 

func (s *AppSummary) UnmarshalJSON(data []byte) error

type AppTemplateSummary 

type AppTemplateSummary struct {
	TemplateID           string                        `json:"templateId"`
	Name                 string                        `json:"name"`
	Description          *string                       `json:"description,omitempty"`
	Category             *string                       `json:"category,omitempty"`
	CanonicalConnectorID *string                       `json:"canonicalConnectorId,omitempty"`
	LogoURL              *string                       `json:"logoUrl,omitempty"`
	LogoURLDark          *string                       `json:"logoUrlDark,omitempty"`
	MaterializedAppIDs   []string                      `json:"materializedAppIds"`
	Reason               *AppTemplateUnavailableReason `json:"reason,omitempty"`
}

AppTemplateSummary is exact standalone descriptive app-template metadata. Template discovery, materialization, and plugin runtime behavior remain absent.

func (AppTemplateSummary) MarshalJSON 

func (s AppTemplateSummary) MarshalJSON() ([]byte, error)

func (*AppTemplateSummary) UnmarshalJSON 

func (s *AppTemplateSummary) UnmarshalJSON(data []byte) error

type AppTemplateUnavailableReason 

type AppTemplateUnavailableReason string

AppTemplateUnavailableReason is the exact closed reason a public app template cannot be materialized. It remains standalone from workspace and plugin runtime behavior. 

const (
	AppTemplateUnavailableReasonNotConfiguredForWorkspace AppTemplateUnavailableReason = "NOT_CONFIGURED_FOR_WORKSPACE"
	AppTemplateUnavailableReasonNoActiveWorkspace         AppTemplateUnavailableReason = "NO_ACTIVE_WORKSPACE"
)

func (AppTemplateUnavailableReason) MarshalJSON 

func (r AppTemplateUnavailableReason) MarshalJSON() ([]byte, error)

func (*AppTemplateUnavailableReason) UnmarshalJSON 

func (r *AppTemplateUnavailableReason) UnmarshalJSON(data []byte) error

type AppToolApproval 

type AppToolApproval string

AppToolApproval is the exact closed descriptive approval mode for app-tool configuration. Permission evaluation and app-tool execution remain absent. 

const (
	AppToolApprovalAuto    AppToolApproval = "auto"
	AppToolApprovalPrompt  AppToolApproval = "prompt"
	AppToolApprovalWrites  AppToolApproval = "writes"
	AppToolApprovalApprove AppToolApproval = "approve"
)

func (AppToolApproval) MarshalJSON 

func (a AppToolApproval) MarshalJSON() ([]byte, error)

func (*AppToolApproval) UnmarshalJSON 

func (a *AppToolApproval) UnmarshalJSON(data []byte) error

type AppToolConfig 

type AppToolConfig struct {
	Enabled      *bool            `json:"enabled,omitempty"`
	ApprovalMode *AppToolApproval `json:"approval_mode,omitempty"`
}

AppToolConfig is exact standalone configuration for one app tool. App-tool policy evaluation and execution remain deferred.

func (AppToolConfig) MarshalJSON 

func (c AppToolConfig) MarshalJSON() ([]byte, error)

func (*AppToolConfig) UnmarshalJSON 

func (c *AppToolConfig) UnmarshalJSON(data []byte) error

type AppToolsConfig 

type AppToolsConfig struct {
	Tools map[string]AppToolConfig `json:"-"`
}

AppToolsConfig is the flattened per-tool map for one app.

func (AppToolsConfig) MarshalJSON 

func (c AppToolsConfig) MarshalJSON() ([]byte, error)

func (*AppToolsConfig) UnmarshalJSON 

func (c *AppToolsConfig) UnmarshalJSON(data []byte) error

type ApplyPatchApprovalParams 

type ApplyPatchApprovalParams struct {
	ConversationID ThreadId              `json:"conversationId"`
	CallID         string                `json:"callId"`
	FileChanges    map[string]FileChange `json:"fileChanges"`
	Reason         *string               `json:"reason,omitempty"`
	GrantRoot      *string               `json:"grantRoot,omitempty"`
}

ApplyPatchApprovalParams is the exact legacy public patch-approval request data. It remains separate from Gollem's live file-change approval request.

func (ApplyPatchApprovalParams) MarshalJSON 

func (p ApplyPatchApprovalParams) MarshalJSON() ([]byte, error)

func (*ApplyPatchApprovalParams) UnmarshalJSON 

func (p *ApplyPatchApprovalParams) UnmarshalJSON(data []byte) error

type ApplyPatchApprovalResponse 

type ApplyPatchApprovalResponse struct {
	Decision ReviewDecision `json:"decision"`
}

ApplyPatchApprovalResponse is the legacy apply-patch callback response. It remains separate from the live file-change approval response.

func (ApplyPatchApprovalResponse) MarshalJSON 

func (r ApplyPatchApprovalResponse) MarshalJSON() ([]byte, error)

func (*ApplyPatchApprovalResponse) UnmarshalJSON 

func (r *ApplyPatchApprovalResponse) UnmarshalJSON(data []byte) error

type ApprovalRequestBase 

type ApprovalRequestBase struct {
	ThreadID    string `json:"threadId"`
	TurnID      string `json:"turnId"`
	ItemID      string `json:"itemId"`
	StartedAtMS int64  `json:"startedAtMs"`
	Reason      string `json:"reason,omitempty"`
}

type ApprovalRespondParams 

type ApprovalRespondParams struct {
	RequestID string `json:"requestId"`
	ID        string `json:"id,omitempty"`
	Approved  bool   `json:"approved"`
	Message   string `json:"message,omitempty"`
}

type ApprovalRespondResult 

type ApprovalRespondResult struct {
	OK        bool   `json:"ok"`
	RequestID string `json:"requestId"`
	Approved  bool   `json:"approved"`
}

type ApprovalsReviewer 

type ApprovalsReviewer string

func (ApprovalsReviewer) MarshalJSON 

func (r ApprovalsReviewer) MarshalJSON() ([]byte, error)

func (*ApprovalsReviewer) UnmarshalJSON 

func (r *ApprovalsReviewer) UnmarshalJSON(data []byte) error

type AppsConfig 

type AppsConfig struct {
	Default *AppsDefaultConfig   `json:"_default,omitempty"`
	Apps    map[string]AppConfig `json:"-"`
}

AppsConfig is exact standalone default and per-app configuration data.

func (AppsConfig) MarshalJSON 

func (c AppsConfig) MarshalJSON() ([]byte, error)

func (*AppsConfig) UnmarshalJSON 

func (c *AppsConfig) UnmarshalJSON(data []byte) error

type AppsDefaultConfig 

type AppsDefaultConfig struct {
	Enabled                  bool               `json:"enabled"`
	ApprovalsReviewer        *ApprovalsReviewer `json:"approvals_reviewer,omitempty"`
	DestructiveEnabled       bool               `json:"destructive_enabled"`
	OpenWorldEnabled         bool               `json:"open_world_enabled"`
	DefaultToolsApprovalMode *AppToolApproval   `json:"default_tools_approval_mode,omitempty"`
}

AppsDefaultConfig is exact standalone default policy data for apps. Default inheritance and policy evaluation remain deferred.

func (AppsDefaultConfig) MarshalJSON 

func (c AppsDefaultConfig) MarshalJSON() ([]byte, error)

func (*AppsDefaultConfig) UnmarshalJSON 

func (c *AppsDefaultConfig) UnmarshalJSON(data []byte) error

type AppsListParams 

type AppsListParams struct {
	Cursor       *string `json:"cursor,omitempty"`
	ForceRefetch bool    `json:"forceRefetch,omitempty"`
	Limit        *uint32 `json:"limit,omitempty"`
	ThreadID     *string `json:"threadId,omitempty"`
}

AppsListParams is the exact public app-catalog page selector. It remains separate from the deferred app/list method until a live adapter is defined.

func (AppsListParams) MarshalJSON 

func (p AppsListParams) MarshalJSON() ([]byte, error)

func (*AppsListParams) UnmarshalJSON 

func (p *AppsListParams) UnmarshalJSON(data []byte) error

type AppsListResponse 

type AppsListResponse struct {
	Data       []AppInfo `json:"data" jsonschema:"nonnullable=true"`
	NextCursor *string   `json:"nextCursor"`
}

AppsListResponse is the exact public page of strict AppInfo values. It stays outside the deferred app/list method binding until that method is implemented.

func (AppsListResponse) MarshalJSON 

func (r AppsListResponse) MarshalJSON() ([]byte, error)

func (*AppsListResponse) UnmarshalJSON 

func (r *AppsListResponse) UnmarshalJSON(data []byte) error

type AskForApproval 

type AskForApproval struct {
	// contains filtered or unexported fields
}

AskForApproval is the exact public approval-policy union used by thread responses. Gollem's runtime approval policy remains separately owned.

func (AskForApproval) Kind 

func (a AskForApproval) Kind() string

func (AskForApproval) MarshalJSON 

func (a AskForApproval) MarshalJSON() ([]byte, error)

func (*AskForApproval) UnmarshalJSON 

func (a *AskForApproval) UnmarshalJSON(data []byte) error

type AttestationGenerateParams 

type AttestationGenerateParams struct{}

AttestationGenerateParams is the exact empty public attestation request. It remains standalone until Slang owns an attestation provider and threat model.

func (*AttestationGenerateParams) UnmarshalJSON 

func (p *AttestationGenerateParams) UnmarshalJSON(data []byte) error

type AttestationGenerateResponse 

type AttestationGenerateResponse struct {
	Token string `json:"token" jsonschema:"description=Opaque client attestation token."`
}

AttestationGenerateResponse is the exact public opaque-token response. It describes wire data only and does not generate, validate, or trust a token.

func (*AttestationGenerateResponse) UnmarshalJSON 

func (r *AttestationGenerateResponse) UnmarshalJSON(data []byte) error

type AuthMode 

type AuthMode string

AuthMode is the exact closed public authentication-mode value. It is standalone from Gollem's account, credential, and provider runtime. 

const (
	AuthModeAPIKey              AuthMode = "apikey"
	AuthModeChatGPT             AuthMode = "chatgpt"
	AuthModeChatGPTAuthTokens   AuthMode = "chatgptAuthTokens"
	AuthModeHeaders             AuthMode = "headers"
	AuthModeAgentIdentity       AuthMode = "agentIdentity"
	AuthModePersonalAccessToken AuthMode = "personalAccessToken"
	AuthModeBedrockAPIKey       AuthMode = "bedrockApiKey"
)

func (AuthMode) MarshalJSON 

func (m AuthMode) MarshalJSON() ([]byte, error)

func (*AuthMode) UnmarshalJSON 

func (m *AuthMode) UnmarshalJSON(data []byte) error

type AutoCompactTokenLimitScope 

type AutoCompactTokenLimitScope string

AutoCompactTokenLimitScope selects the context charged against the automatic compaction token limit. 

const (
	AutoCompactTokenLimitScopeTotal           AutoCompactTokenLimitScope = "total"
	AutoCompactTokenLimitScopeBodyAfterPrefix AutoCompactTokenLimitScope = "body_after_prefix"
)

func (AutoCompactTokenLimitScope) MarshalJSON 

func (s AutoCompactTokenLimitScope) MarshalJSON() ([]byte, error)

func (*AutoCompactTokenLimitScope) UnmarshalJSON 

func (s *AutoCompactTokenLimitScope) UnmarshalJSON(data []byte) error

type AutoReviewDecisionSource 

type AutoReviewDecisionSource string

AutoReviewDecisionSource is the exact closed public source for a terminal approval auto-review decision. It is standalone from Guardian review runtime. 

const (
	AutoReviewDecisionSourceAgent AutoReviewDecisionSource = "agent"
)

func (AutoReviewDecisionSource) MarshalJSON 

func (s AutoReviewDecisionSource) MarshalJSON() ([]byte, error)

func (*AutoReviewDecisionSource) UnmarshalJSON 

func (s *AutoReviewDecisionSource) UnmarshalJSON(data []byte) error

type BackgroundTerminal added in v0.8.0 

type BackgroundTerminal struct {
	ID                string                   `json:"id"`
	TerminalID        string                   `json:"terminalId"`
	ProcessID         string                   `json:"processId"`
	PID               int                      `json:"pid"`
	Title             string                   `json:"title"`
	Command           string                   `json:"command"`
	WorkDir           string                   `json:"workDir"`
	Status            BackgroundTerminalStatus `json:"status" jsonschema:"enum=running|completed|failed|killed|timed_out"`
	ExitCode          *int                     `json:"exitCode,omitempty"`
	StartedAt         time.Time                `json:"startedAt"`
	EndedAt           *time.Time               `json:"endedAt,omitempty"`
	ArgumentCount     int                      `json:"argumentCount"`
	CommandRedacted   bool                     `json:"commandRedacted"`
	MetadataTruncated bool                     `json:"metadataTruncated"`
}

BackgroundTerminal is the bounded, redacted process record exposed to desktop clients. Process arguments, output, environment, and raw errors are intentionally absent.

type BackgroundTerminalCleanResponse added in v0.8.0 

type BackgroundTerminalCleanResponse struct {
	Removed             []BackgroundTerminal `json:"removed" jsonschema:"nonnullable=true"`
	BackgroundTerminals []BackgroundTerminal `json:"backgroundTerminals" jsonschema:"nonnullable=true"`
	Data                []BackgroundTerminal `json:"data" jsonschema:"nonnullable=true"`
	RemovedCount        int                  `json:"removedCount"`
	Truncated           bool                 `json:"truncated"`
	ObservedAt          time.Time            `json:"observedAt"`
}

type BackgroundTerminalListResponse added in v0.8.0 

type BackgroundTerminalListResponse struct {
	Terminals           []BackgroundTerminal `json:"terminals" jsonschema:"nonnullable=true"`
	BackgroundTerminals []BackgroundTerminal `json:"backgroundTerminals" jsonschema:"nonnullable=true"`
	Data                []BackgroundTerminal `json:"data" jsonschema:"nonnullable=true"`
	Total               int                  `json:"total"`
	Truncated           bool                 `json:"truncated"`
	SnapshotID          string               `json:"snapshotId"`
	NextCursor          string               `json:"nextCursor,omitempty"`
	ObservedAt          time.Time            `json:"observedAt"`
}

BackgroundTerminalListResponse is one stable page of the process inventory. The alias arrays preserve the existing wire surface while sharing the same bounded records.

type BackgroundTerminalStatus added in v0.8.0 

type BackgroundTerminalStatus string

BackgroundTerminalStatus is the lifecycle state of a workspace-owned background process. 

const (
	BackgroundTerminalStatusRunning   BackgroundTerminalStatus = "running"
	BackgroundTerminalStatusCompleted BackgroundTerminalStatus = "completed"
	BackgroundTerminalStatusFailed    BackgroundTerminalStatus = "failed"
	BackgroundTerminalStatusKilled    BackgroundTerminalStatus = "killed"
	BackgroundTerminalStatusTimedOut  BackgroundTerminalStatus = "timed_out"
)

type BackgroundTerminalTerminateParams added in v0.8.0 

type BackgroundTerminalTerminateParams struct {
	ID                   string `json:"id,omitempty"`
	TerminalID           string `json:"terminalId,omitempty"`
	BackgroundTerminalID string `json:"backgroundTerminalId,omitempty"`
	ProcessID            string `json:"processId,omitempty"`
}

BackgroundTerminalTerminateParams accepts the historical identifier aliases. Main-process callers should use id.

func (BackgroundTerminalTerminateParams) EffectiveID added in v0.8.0 

func (p BackgroundTerminalTerminateParams) EffectiveID() string

type BackgroundTerminalTerminateResponse added in v0.8.0 

type BackgroundTerminalTerminateResponse struct {
	OK       bool               `json:"ok"`
	ID       string             `json:"id"`
	Terminal BackgroundTerminal `json:"terminal"`
}

type ByteRange 

type ByteRange struct {
	Start uint64 `json:"start"`
	End   uint64 `json:"end"`
}

func (*ByteRange) UnmarshalJSON 

func (r *ByteRange) UnmarshalJSON(data []byte) error

type CancelLoginAccountParams 

type CancelLoginAccountParams struct {
	LoginID string `json:"loginId"`
}

CancelLoginAccountParams is the exact public login-cancellation target. It remains standalone from Gollem account and authentication runtime.

func (*CancelLoginAccountParams) UnmarshalJSON 

func (p *CancelLoginAccountParams) UnmarshalJSON(data []byte) error

type CancelLoginAccountResponse 

type CancelLoginAccountResponse struct {
	Status CancelLoginAccountStatus `json:"status"`
}

CancelLoginAccountResponse is the exact public cancellation outcome. It remains standalone from the deferred account/login/cancel method.

func (*CancelLoginAccountResponse) UnmarshalJSON 

func (r *CancelLoginAccountResponse) UnmarshalJSON(data []byte) error

type CancelLoginAccountStatus 

type CancelLoginAccountStatus string

CancelLoginAccountStatus is the exact closed public cancellation outcome. 

const (
	CancelLoginAccountStatusCanceled CancelLoginAccountStatus = "canceled"
	CancelLoginAccountStatusNotFound CancelLoginAccountStatus = "notFound"
)

func (CancelLoginAccountStatus) MarshalJSON 

func (s CancelLoginAccountStatus) MarshalJSON() ([]byte, error)

func (*CancelLoginAccountStatus) UnmarshalJSON 

func (s *CancelLoginAccountStatus) UnmarshalJSON(data []byte) error

type CapabilityRootLocation 

type CapabilityRootLocation struct {
	// contains filtered or unexported fields
}

CapabilityRootLocation describes an environment-owned path. It does not resolve the environment or grant access to the path.

func (CapabilityRootLocation) MarshalJSON 

func (l CapabilityRootLocation) MarshalJSON() ([]byte, error)

func (*CapabilityRootLocation) UnmarshalJSON 

func (l *CapabilityRootLocation) UnmarshalJSON(data []byte) error

type ChatgptAuthTokensRefreshParams 

type ChatgptAuthTokensRefreshParams struct {
	Reason            ChatgptAuthTokensRefreshReason `json:"reason"`
	PreviousAccountID *string                        `json:"previousAccountId,omitempty"`
}

ChatgptAuthTokensRefreshParams is exact standalone public refresh-request data. The corresponding sensitive server request remains deferred and unbound.

func (ChatgptAuthTokensRefreshParams) MarshalJSON 

func (p ChatgptAuthTokensRefreshParams) MarshalJSON() ([]byte, error)

func (*ChatgptAuthTokensRefreshParams) UnmarshalJSON 

func (p *ChatgptAuthTokensRefreshParams) UnmarshalJSON(data []byte) error

type ChatgptAuthTokensRefreshReason 

type ChatgptAuthTokensRefreshReason string

ChatgptAuthTokensRefreshReason is the exact closed public reason for a client-managed ChatGPT token refresh. It carries no authentication authority. 

const (
	ChatgptAuthTokensRefreshReasonUnauthorized ChatgptAuthTokensRefreshReason = "unauthorized"
)

func (ChatgptAuthTokensRefreshReason) MarshalJSON 

func (r ChatgptAuthTokensRefreshReason) MarshalJSON() ([]byte, error)

func (*ChatgptAuthTokensRefreshReason) UnmarshalJSON 

func (r *ChatgptAuthTokensRefreshReason) UnmarshalJSON(data []byte) error

type ChatgptAuthTokensRefreshResponse 

type ChatgptAuthTokensRefreshResponse struct {
	AccessToken      string  `json:"accessToken"` //nolint:gosec // Exact standalone protocol field; no runtime consumes it.
	ChatgptAccountID string  `json:"chatgptAccountId"`
	ChatgptPlanType  *string `json:"chatgptPlanType,omitempty"`
}

ChatgptAuthTokensRefreshResponse is exact standalone public refresh-response data. Gollem does not receive, store, log, validate, or return these tokens.

func (ChatgptAuthTokensRefreshResponse) MarshalJSON 

func (r ChatgptAuthTokensRefreshResponse) MarshalJSON() ([]byte, error)

func (*ChatgptAuthTokensRefreshResponse) UnmarshalJSON 

func (r *ChatgptAuthTokensRefreshResponse) UnmarshalJSON(data []byte) error

type ClientInfo 

type ClientInfo struct {
	Name    string  `json:"name"`
	Title   *string `json:"title,omitempty"`
	Version string  `json:"version"`
}

ClientInfo identifies a Codex-compatible app-server client.

type CodexErrorInfo 

type CodexErrorInfo struct {
	// contains filtered or unexported fields
}

func (CodexErrorInfo) MarshalJSON 

func (i CodexErrorInfo) MarshalJSON() ([]byte, error)

func (*CodexErrorInfo) UnmarshalJSON 

func (i *CodexErrorInfo) UnmarshalJSON(data []byte) error

type CollabAgentState 

type CollabAgentState struct {
	Status  CollabAgentStatus `json:"status"`
	Message *string           `json:"message"`
}

func (CollabAgentState) MarshalJSON 

func (s CollabAgentState) MarshalJSON() ([]byte, error)

func (*CollabAgentState) UnmarshalJSON 

func (s *CollabAgentState) UnmarshalJSON(data []byte) error

type CollabAgentStatus 

type CollabAgentStatus string
const (
	CollabAgentStatusPendingInit CollabAgentStatus = "pendingInit"
	CollabAgentStatusRunning     CollabAgentStatus = "running"
	CollabAgentStatusInterrupted CollabAgentStatus = "interrupted"
	CollabAgentStatusCompleted   CollabAgentStatus = "completed"
	CollabAgentStatusErrored     CollabAgentStatus = "errored"
	CollabAgentStatusShutdown    CollabAgentStatus = "shutdown"
	CollabAgentStatusNotFound    CollabAgentStatus = "notFound"
)

func (CollabAgentStatus) MarshalJSON 

func (s CollabAgentStatus) MarshalJSON() ([]byte, error)

func (*CollabAgentStatus) UnmarshalJSON 

func (s *CollabAgentStatus) UnmarshalJSON(data []byte) error

type CollabAgentTool 

type CollabAgentTool string
const (
	CollabAgentToolSpawnAgent  CollabAgentTool = "spawnAgent"
	CollabAgentToolSendInput   CollabAgentTool = "sendInput"
	CollabAgentToolResumeAgent CollabAgentTool = "resumeAgent"
	CollabAgentToolWait        CollabAgentTool = "wait"
	CollabAgentToolCloseAgent  CollabAgentTool = "closeAgent"
)

func (CollabAgentTool) MarshalJSON 

func (t CollabAgentTool) MarshalJSON() ([]byte, error)

func (*CollabAgentTool) UnmarshalJSON 

func (t *CollabAgentTool) UnmarshalJSON(data []byte) error

type CollabAgentToolCallStatus 

type CollabAgentToolCallStatus string
const (
	CollabAgentToolCallStatusInProgress CollabAgentToolCallStatus = "inProgress"
	CollabAgentToolCallStatusCompleted  CollabAgentToolCallStatus = "completed"
	CollabAgentToolCallStatusFailed     CollabAgentToolCallStatus = "failed"
)

func (CollabAgentToolCallStatus) MarshalJSON 

func (s CollabAgentToolCallStatus) MarshalJSON() ([]byte, error)

func (*CollabAgentToolCallStatus) UnmarshalJSON 

func (s *CollabAgentToolCallStatus) UnmarshalJSON(data []byte) error

type CollaborationMode 

type CollaborationMode struct {
	Mode     ModeKind `json:"mode"`
	Settings Settings `json:"settings"`
}

CollaborationMode is standalone session configuration data.

func (*CollaborationMode) UnmarshalJSON 

func (m *CollaborationMode) UnmarshalJSON(data []byte) error

type CollaborationModeMask 

type CollaborationModeMask struct {
	Name            string           `json:"name"`
	Mode            *ModeKind        `json:"mode"`
	Model           *string          `json:"model"`
	ReasoningEffort *ReasoningEffort `json:"reasoning_effort"`
}

CollaborationModeMask is the public app-server preset metadata record. Its nested optional effort collapses to one nullable Go pointer on the wire.

func (*CollaborationModeMask) UnmarshalJSON 

func (m *CollaborationModeMask) UnmarshalJSON(data []byte) error

type CommandAction 

type CommandAction struct {
	// contains filtered or unexported fields
}

CommandAction retains one validated public command-action variant without flattening its variant-specific path types into an invalid Go state.

func (CommandAction) MarshalJSON 

func (a CommandAction) MarshalJSON() ([]byte, error)

func (*CommandAction) UnmarshalJSON 

func (a *CommandAction) UnmarshalJSON(data []byte) error

type CommandExecOutputDeltaNotification 

type CommandExecOutputDeltaNotification struct {
	ProcessID   string                  `json:"processId"`
	Stream      CommandExecOutputStream `json:"stream"`
	DeltaBase64 string                  `json:"deltaBase64"`
	CapReached  bool                    `json:"capReached"`
}

type CommandExecOutputStream 

type CommandExecOutputStream string
const (
	CommandExecOutputStdout CommandExecOutputStream = "stdout"
	CommandExecOutputStderr CommandExecOutputStream = "stderr"
)

type CommandExecResizeParams 

type CommandExecResizeParams struct {
	ProcessID string                   `json:"processId,omitempty"`
	Size      *CommandExecTerminalSize `json:"size,omitempty" jsonschema:"nonnullable=true"`

	ID   string `json:"id,omitempty"`
	Cols int    `json:"cols,omitempty"`
	Rows int    `json:"rows,omitempty"`
	// contains filtered or unexported fields
}

func (CommandExecResizeParams) EffectiveProcessID 

func (p CommandExecResizeParams) EffectiveProcessID() string

func (CommandExecResizeParams) EffectiveSize 

func (p CommandExecResizeParams) EffectiveSize() (cols, rows int, valid bool)

func (CommandExecResizeParams) HasProcessID 

func (p CommandExecResizeParams) HasProcessID() bool

func (CommandExecResizeParams) HasSize 

func (p CommandExecResizeParams) HasSize() bool

func (CommandExecResizeParams) MarshalJSON 

func (p CommandExecResizeParams) MarshalJSON() ([]byte, error)

func (*CommandExecResizeParams) SetProcessID 

func (p *CommandExecResizeParams) SetProcessID(value string)

func (*CommandExecResizeParams) SetSize 

func (p *CommandExecResizeParams) SetSize(value *CommandExecTerminalSize)

func (*CommandExecResizeParams) UnmarshalJSON 

func (p *CommandExecResizeParams) UnmarshalJSON(data []byte) error

type CommandExecResizeResponse 

type CommandExecResizeResponse struct {
	OK   bool   `json:"ok,omitempty"`
	Path string `json:"path,omitempty"`
}

type CommandExecTerminalSize 

type CommandExecTerminalSize struct {
	Rows uint16 `json:"rows"`
	Cols uint16 `json:"cols"`
}

type CommandExecTerminateParams 

type CommandExecTerminateParams struct {
	ProcessID string `json:"processId,omitempty"`
	ID        string `json:"id,omitempty"`
	// contains filtered or unexported fields
}

func (CommandExecTerminateParams) EffectiveProcessID 

func (p CommandExecTerminateParams) EffectiveProcessID() string

func (CommandExecTerminateParams) HasProcessID 

func (p CommandExecTerminateParams) HasProcessID() bool

func (CommandExecTerminateParams) MarshalJSON 

func (p CommandExecTerminateParams) MarshalJSON() ([]byte, error)

func (*CommandExecTerminateParams) SetProcessID 

func (p *CommandExecTerminateParams) SetProcessID(value string)

func (*CommandExecTerminateParams) UnmarshalJSON 

func (p *CommandExecTerminateParams) UnmarshalJSON(data []byte) error

type CommandExecTerminateResponse 

type CommandExecTerminateResponse struct {
	OK   bool   `json:"ok,omitempty"`
	Path string `json:"path,omitempty"`
}

type CommandExecWriteParams 

type CommandExecWriteParams struct {
	ProcessID   string  `json:"processId,omitempty"`
	DeltaBase64 *string `json:"deltaBase64,omitempty"`
	CloseStdin  bool    `json:"closeStdin,omitempty"`

	ID       string `json:"id,omitempty"`
	Data     string `json:"data,omitempty"`
	Encoding string `json:"encoding,omitempty"`
	Close    bool   `json:"close,omitempty"`
	// contains filtered or unexported fields
}

func (CommandExecWriteParams) EffectiveInput 

func (p CommandExecWriteParams) EffectiveInput() (string, string)

func (CommandExecWriteParams) EffectiveProcessID 

func (p CommandExecWriteParams) EffectiveProcessID() string

func (CommandExecWriteParams) HasCloseStdin 

func (p CommandExecWriteParams) HasCloseStdin() bool

func (CommandExecWriteParams) HasDeltaBase64 

func (p CommandExecWriteParams) HasDeltaBase64() bool

func (CommandExecWriteParams) HasProcessID 

func (p CommandExecWriteParams) HasProcessID() bool

func (CommandExecWriteParams) MarshalJSON 

func (p CommandExecWriteParams) MarshalJSON() ([]byte, error)

func (*CommandExecWriteParams) SetCloseStdin 

func (p *CommandExecWriteParams) SetCloseStdin(value bool)

func (*CommandExecWriteParams) SetDeltaBase64 

func (p *CommandExecWriteParams) SetDeltaBase64(value *string)

func (*CommandExecWriteParams) SetProcessID 

func (p *CommandExecWriteParams) SetProcessID(value string)

func (CommandExecWriteParams) ShouldCloseStdin 

func (p CommandExecWriteParams) ShouldCloseStdin() bool

func (*CommandExecWriteParams) UnmarshalJSON 

func (p *CommandExecWriteParams) UnmarshalJSON(data []byte) error

type CommandExecWriteResponse 

type CommandExecWriteResponse struct {
	OK   bool   `json:"ok,omitempty"`
	Path string `json:"path,omitempty"`
}

type CommandExecutionAction 

type CommandExecutionAction struct {
	Type    string `json:"type"`
	Command string `json:"command"`
}

type CommandExecutionApprovalDecision 

type CommandExecutionApprovalDecision struct {
	// contains filtered or unexported fields
}

CommandExecutionApprovalDecision retains the validated JSON for the public string-or-object union without flattening amendment variants into invalid Go states.

func NewCommandExecutionApprovalDecisions 

func NewCommandExecutionApprovalDecisions(actions ...string) ([]CommandExecutionApprovalDecision, error)

func (CommandExecutionApprovalDecision) Action 

func (d CommandExecutionApprovalDecision) Action() string

func (CommandExecutionApprovalDecision) MarshalJSON 

func (d CommandExecutionApprovalDecision) MarshalJSON() ([]byte, error)

func (*CommandExecutionApprovalDecision) UnmarshalJSON 

func (d *CommandExecutionApprovalDecision) UnmarshalJSON(data []byte) error

type CommandExecutionApprovalRequestParams 

type CommandExecutionApprovalRequestParams struct {
	ApprovalRequestBase
	ApprovalID         string                             `json:"approvalId,omitempty"`
	Command            string                             `json:"command,omitempty"`
	Args               []string                           `json:"args,omitempty"`
	CWD                string                             `json:"cwd,omitempty"`
	Operation          string                             `json:"operation,omitempty"`
	Signal             string                             `json:"signal,omitempty"`
	Destructive        bool                               `json:"destructive,omitempty"`
	CommandActions     []CommandExecutionAction           `json:"commandActions,omitempty"`
	AvailableDecisions []CommandExecutionApprovalDecision `json:"availableDecisions,omitempty" jsonschema:"nonnullable=true"`
}

type CommandExecutionItem 

type CommandExecutionItem struct {
	Type             string                   `json:"type" jsonschema:"enum=commandExecution"`
	ID               string                   `json:"id,omitempty"`
	Command          string                   `json:"command"`
	CWD              string                   `json:"cwd"`
	ProcessID        *string                  `json:"processId"`
	Source           string                   `json:"source" jsonschema:"enum=agent|userShell"`
	Status           string                   `json:"status" jsonschema:"enum=inProgress|completed|failed|declined"`
	CommandActions   []CommandExecutionAction `json:"commandActions"`
	AggregatedOutput *string                  `json:"aggregatedOutput"`
	ExitCode         *int                     `json:"exitCode"`
	DurationMS       *int64                   `json:"durationMs"`
	StartedAt        time.Time                `json:"startedAt"`
	CompletedAt      *time.Time               `json:"completedAt"`
}

type CommandExecutionItemCompletedNotificationParams 

type CommandExecutionItemCompletedNotificationParams struct {
	Item          CommandExecutionItem `json:"item"`
	ThreadID      string               `json:"threadId"`
	TurnID        string               `json:"turnId"`
	CompletedAtMS int64                `json:"completedAtMs"`
}

type CommandExecutionItemStartedNotificationParams 

type CommandExecutionItemStartedNotificationParams struct {
	Item        CommandExecutionItem `json:"item"`
	ThreadID    string               `json:"threadId"`
	TurnID      string               `json:"turnId"`
	StartedAtMS int64                `json:"startedAtMs"`
}

type CommandExecutionOutputDeltaNotification 

type CommandExecutionOutputDeltaNotification struct {
	ThreadID string `json:"threadId"`
	TurnID   string `json:"turnId"`
	ItemID   string `json:"itemId"`
	Delta    string `json:"delta"`
}

type CommandExecutionOutputDeltaNotificationParams 

type CommandExecutionOutputDeltaNotificationParams = CommandExecutionOutputDeltaNotification

type CommandExecutionRequestApprovalResponse 

type CommandExecutionRequestApprovalResponse struct {
	Decision CommandExecutionApprovalDecision `json:"decision"`
}

func (CommandExecutionRequestApprovalResponse) MarshalJSON 

func (r CommandExecutionRequestApprovalResponse) MarshalJSON() ([]byte, error)

func (*CommandExecutionRequestApprovalResponse) UnmarshalJSON 

func (r *CommandExecutionRequestApprovalResponse) UnmarshalJSON(data []byte) error

type CommandExecutionSource 

type CommandExecutionSource string

CommandExecutionSource is the exact public command-origin contract. Gollem's narrower live v1 command item intentionally remains a separate inline field. 

const (
	CommandExecutionSourceAgent                  CommandExecutionSource = "agent"
	CommandExecutionSourceUserShell              CommandExecutionSource = "userShell"
	CommandExecutionSourceUnifiedExecStartup     CommandExecutionSource = "unifiedExecStartup"
	CommandExecutionSourceUnifiedExecInteraction CommandExecutionSource = "unifiedExecInteraction"
)

func (CommandExecutionSource) MarshalJSON 

func (s CommandExecutionSource) MarshalJSON() ([]byte, error)

func (*CommandExecutionSource) UnmarshalJSON 

func (s *CommandExecutionSource) UnmarshalJSON(data []byte) error

type CommandExecutionStatus 

type CommandExecutionStatus string
const (
	CommandExecutionStatusInProgress CommandExecutionStatus = ItemStatusInProgress
	CommandExecutionStatusCompleted  CommandExecutionStatus = ItemStatusCompleted
	CommandExecutionStatusFailed     CommandExecutionStatus = ItemStatusFailed
	CommandExecutionStatusDeclined   CommandExecutionStatus = ItemStatusDeclined
)

type CommandMigration 

type CommandMigration struct {
	Name string `json:"name"`
}

CommandMigration identifies one command configuration migration. It remains standalone until the external-agent migration contracts land.

func (*CommandMigration) UnmarshalJSON 

func (m *CommandMigration) UnmarshalJSON(data []byte) error

type ComputerUseRequirements 

type ComputerUseRequirements struct {
	AllowLockedComputerUse *bool `json:"allowLockedComputerUse"`
}

ComputerUseRequirements is the exact public computer-use requirement. Nullable Rust options remain explicit in canonical output.

func (*ComputerUseRequirements) UnmarshalJSON 

func (r *ComputerUseRequirements) UnmarshalJSON(data []byte) error

type Config 

type Config struct {
	Model                           *string                     `json:"model"`
	ReviewModel                     *string                     `json:"review_model"`
	ModelContextWindow              *int64                      `json:"model_context_window"`
	ModelAutoCompactTokenLimit      *int64                      `json:"model_auto_compact_token_limit"`
	ModelAutoCompactTokenLimitScope *AutoCompactTokenLimitScope `json:"model_auto_compact_token_limit_scope"`
	ModelProvider                   *string                     `json:"model_provider"`
	ApprovalPolicy                  *AskForApproval             `json:"approval_policy"`
	ApprovalsReviewer               *ApprovalsReviewer          `json:"approvals_reviewer"`
	SandboxMode                     *SandboxMode                `json:"sandbox_mode"`
	SandboxWorkspaceWrite           *SandboxWorkspaceWrite      `json:"sandbox_workspace_write"`
	ForcedChatgptWorkspaceID        *ForcedChatgptWorkspaceIds  `json:"forced_chatgpt_workspace_id"`
	ForcedLoginMethod               *ForcedLoginMethod          `json:"forced_login_method"`
	WebSearch                       *WebSearchMode              `json:"web_search"`
	Tools                           *ToolsV2                    `json:"tools"`
	Instructions                    *string                     `json:"instructions"`
	DeveloperInstructions           *string                     `json:"developer_instructions"`
	CompactPrompt                   *string                     `json:"compact_prompt"`
	ModelReasoningEffort            *ReasoningEffort            `json:"model_reasoning_effort"`
	ModelReasoningSummary           *ReasoningSummary           `json:"model_reasoning_summary"`
	ModelVerbosity                  *Verbosity                  `json:"model_verbosity"`
	ServiceTier                     *string                     `json:"service_tier"`
	Analytics                       *AnalyticsConfig            `json:"analytics"`
	Desktop                         map[string]JsonValue        `json:"desktop"`
	Additional                      map[string]JsonValue        `json:"-"`
}

Config is the exact standalone public effective-config value. It is kept separate from Gollem's memory-backed app-server config service.

func (Config) MarshalJSON 

func (c Config) MarshalJSON() ([]byte, error)

func (*Config) UnmarshalJSON 

func (c *Config) UnmarshalJSON(data []byte) error

type ConfigBatchWriteParams 

type ConfigBatchWriteParams struct {
	Edits            []ConfigEdit `json:"edits" jsonschema:"nonnullable=true"`
	FilePath         *string      `json:"filePath,omitempty"`
	ExpectedVersion  *string      `json:"expectedVersion,omitempty"`
	ReloadUserConfig bool         `json:"reloadUserConfig,omitempty"`
}

ConfigBatchWriteParams is the exact standalone public ordered edit batch.

func (ConfigBatchWriteParams) MarshalJSON 

func (p ConfigBatchWriteParams) MarshalJSON() ([]byte, error)

func (*ConfigBatchWriteParams) UnmarshalJSON 

func (p *ConfigBatchWriteParams) UnmarshalJSON(data []byte) error

type ConfigEdit 

type ConfigEdit struct {
	KeyPath       string        `json:"keyPath"`
	Value         JsonValue     `json:"value"`
	MergeStrategy MergeStrategy `json:"mergeStrategy"`
}

ConfigEdit is one exact public key-path edit.

func (*ConfigEdit) UnmarshalJSON 

func (e *ConfigEdit) UnmarshalJSON(data []byte) error

type ConfigLayer 

type ConfigLayer struct {
	Name           ConfigLayerSource `json:"name"`
	Version        string            `json:"version"`
	Config         JsonValue         `json:"config"`
	DisabledReason *string           `json:"disabledReason"`
}

ConfigLayer is one exact public configuration layer and its JSON value.

func (*ConfigLayer) UnmarshalJSON 

func (l *ConfigLayer) UnmarshalJSON(data []byte) error

type ConfigLayerMetadata 

type ConfigLayerMetadata struct {
	Name    ConfigLayerSource `json:"name"`
	Version string            `json:"version"`
}

ConfigLayerMetadata identifies one versioned public configuration layer.

func (*ConfigLayerMetadata) UnmarshalJSON 

func (m *ConfigLayerMetadata) UnmarshalJSON(data []byte) error

type ConfigLayerSource 

type ConfigLayerSource struct {
	// contains filtered or unexported fields
}

ConfigLayerSource is the exact public origin of a configuration layer. It is standalone from Gollem's live in-memory configuration service.

func (ConfigLayerSource) MarshalJSON 

func (s ConfigLayerSource) MarshalJSON() ([]byte, error)

func (ConfigLayerSource) Type 

func (s ConfigLayerSource) Type() string

func (*ConfigLayerSource) UnmarshalJSON 

func (s *ConfigLayerSource) UnmarshalJSON(data []byte) error

type ConfigReadParams 

type ConfigReadParams struct {
	IncludeLayers bool    `json:"includeLayers,omitempty"`
	CWD           *string `json:"cwd,omitempty"`
}

ConfigReadParams is the exact standalone public config-read request. Gollem's live key-filtered request remains a separate contract.

func (ConfigReadParams) MarshalJSON 

func (p ConfigReadParams) MarshalJSON() ([]byte, error)

func (*ConfigReadParams) UnmarshalJSON 

func (p *ConfigReadParams) UnmarshalJSON(data []byte) error

type ConfigReadResponse 

type ConfigReadResponse struct {
	Config  Config                         `json:"config"`
	Origins map[string]ConfigLayerMetadata `json:"origins"`
	Layers  []ConfigLayer                  `json:"layers"`
}

ConfigReadResponse is the exact standalone public effective-config response. It is kept separate from Gollem's memory-backed config/read result.

func (ConfigReadResponse) MarshalJSON 

func (r ConfigReadResponse) MarshalJSON() ([]byte, error)

func (*ConfigReadResponse) UnmarshalJSON 

func (r *ConfigReadResponse) UnmarshalJSON(data []byte) error

type ConfigRequirements 

type ConfigRequirements struct {
	AllowedApprovalPolicies              *[]AskForApproval          `json:"allowedApprovalPolicies"`
	AllowedSandboxModes                  *[]SandboxMode             `json:"allowedSandboxModes"`
	AllowedWindowsSandboxImplementations *[]WindowsSandboxSetupMode `json:"allowedWindowsSandboxImplementations"`
	AllowedPermissionProfiles            *map[string]bool           `json:"allowedPermissionProfiles"`
	DefaultPermissions                   *string                    `json:"defaultPermissions"`
	AllowedWebSearchModes                *[]WebSearchMode           `json:"allowedWebSearchModes"`
	AllowManagedHooksOnly                *bool                      `json:"allowManagedHooksOnly"`
	AllowAppshots                        *bool                      `json:"allowAppshots"`
	AllowRemoteControl                   *bool                      `json:"allowRemoteControl"`
	ComputerUse                          *ComputerUseRequirements   `json:"computerUse"`
	FeatureRequirements                  *map[string]bool           `json:"featureRequirements"`
	EnforceResidency                     *ResidencyRequirement      `json:"enforceResidency"`
	Models                               *ModelsRequirements        `json:"models"`
}

ConfigRequirements is the exact public configuration-requirements value. Gollem's broader live provider/workspace requirements remain separate.

func (*ConfigRequirements) UnmarshalJSON 

func (r *ConfigRequirements) UnmarshalJSON(data []byte) error

type ConfigRequirementsReadResponse 

type ConfigRequirementsReadResponse struct {
	Requirements *ConfigRequirements `json:"requirements"`
}

ConfigRequirementsReadResponse is the exact public read response. It stays standalone until the broader live handler has an explicit projection.

func (*ConfigRequirementsReadResponse) UnmarshalJSON 

func (r *ConfigRequirementsReadResponse) UnmarshalJSON(data []byte) error

type ConfigValueWriteParams 

type ConfigValueWriteParams struct {
	KeyPath         string        `json:"keyPath"`
	Value           JsonValue     `json:"value"`
	MergeStrategy   MergeStrategy `json:"mergeStrategy"`
	FilePath        *string       `json:"filePath,omitempty"`
	ExpectedVersion *string       `json:"expectedVersion,omitempty"`
}

ConfigValueWriteParams is the exact standalone public single-value write request. Gollem's live memory-backed request remains a separate contract.

func (ConfigValueWriteParams) MarshalJSON 

func (p ConfigValueWriteParams) MarshalJSON() ([]byte, error)

func (*ConfigValueWriteParams) UnmarshalJSON 

func (p *ConfigValueWriteParams) UnmarshalJSON(data []byte) error

type ConfigWarningNotification 

type ConfigWarningNotification struct {
	Summary string     `json:"summary"`
	Details *string    `json:"details"`
	Path    *string    `json:"path,omitempty" jsonschema:"nonnullable=true"`
	Range   *TextRange `json:"range,omitempty" jsonschema:"nonnullable=true"`
}

ConfigWarningNotification is the exact fixed public config warning value. It remains standalone until Gollem has a config-diagnostic producer.

func (*ConfigWarningNotification) UnmarshalJSON 

func (n *ConfigWarningNotification) UnmarshalJSON(data []byte) error

type ConfigWriteResponse 

type ConfigWriteResponse struct {
	Status             WriteStatus         `json:"status"`
	Version            string              `json:"version"`
	FilePath           AbsolutePathBuf     `json:"filePath"`
	OverriddenMetadata *OverriddenMetadata `json:"overriddenMetadata"`
}

ConfigWriteResponse is the exact standalone public config-write result. Gollem's live value/entry snapshot remains a separate response contract.

func (*ConfigWriteResponse) UnmarshalJSON 

func (r *ConfigWriteResponse) UnmarshalJSON(data []byte) error

type ConfiguredHookHandler 

type ConfiguredHookHandler struct {
	// contains filtered or unexported fields
}

ConfiguredHookHandler retains one exact public managed-hook handler without executing or binding it to Gollem runtime hook behavior.

func (ConfiguredHookHandler) MarshalJSON 

func (h ConfiguredHookHandler) MarshalJSON() ([]byte, error)

func (*ConfiguredHookHandler) UnmarshalJSON 

func (h *ConfiguredHookHandler) UnmarshalJSON(data []byte) error

type ConfiguredHookMatcherGroup 

type ConfiguredHookMatcherGroup struct {
	Matcher *string                 `json:"matcher"`
	Hooks   []ConfiguredHookHandler `json:"hooks" jsonschema:"nonnullable=true"`
}

ConfiguredHookMatcherGroup is the exact public matcher and non-null handler list used by managed hook requirements.

func (ConfiguredHookMatcherGroup) MarshalJSON 

func (g ConfiguredHookMatcherGroup) MarshalJSON() ([]byte, error)

func (*ConfiguredHookMatcherGroup) UnmarshalJSON 

func (g *ConfiguredHookMatcherGroup) UnmarshalJSON(data []byte) error

type ConsumeAccountRateLimitResetCreditOutcome 

type ConsumeAccountRateLimitResetCreditOutcome string

ConsumeAccountRateLimitResetCreditOutcome is the exact closed redemption result. 

const (
	ConsumeAccountRateLimitResetCreditOutcomeReset           ConsumeAccountRateLimitResetCreditOutcome = "reset"
	ConsumeAccountRateLimitResetCreditOutcomeNothingToReset  ConsumeAccountRateLimitResetCreditOutcome = "nothingToReset"
	ConsumeAccountRateLimitResetCreditOutcomeNoCredit        ConsumeAccountRateLimitResetCreditOutcome = "noCredit"
	ConsumeAccountRateLimitResetCreditOutcomeAlreadyRedeemed ConsumeAccountRateLimitResetCreditOutcome = "alreadyRedeemed"
)

func (ConsumeAccountRateLimitResetCreditOutcome) MarshalJSON 

func (o ConsumeAccountRateLimitResetCreditOutcome) MarshalJSON() ([]byte, error)

func (*ConsumeAccountRateLimitResetCreditOutcome) UnmarshalJSON 

func (o *ConsumeAccountRateLimitResetCreditOutcome) UnmarshalJSON(data []byte) error

type ConsumeAccountRateLimitResetCreditParams 

type ConsumeAccountRateLimitResetCreditParams struct {
	IdempotencyKey string  `json:"idempotencyKey"`
	CreditID       *string `json:"creditId,omitempty"`
}

ConsumeAccountRateLimitResetCreditParams is a standalone redemption request. It does not perform or persist redemption.

func (ConsumeAccountRateLimitResetCreditParams) MarshalJSON 

func (p ConsumeAccountRateLimitResetCreditParams) MarshalJSON() ([]byte, error)

func (*ConsumeAccountRateLimitResetCreditParams) UnmarshalJSON 

func (p *ConsumeAccountRateLimitResetCreditParams) UnmarshalJSON(data []byte) error

type ConsumeAccountRateLimitResetCreditResponse 

type ConsumeAccountRateLimitResetCreditResponse struct {
	Outcome ConsumeAccountRateLimitResetCreditOutcome `json:"outcome"`
}

ConsumeAccountRateLimitResetCreditResponse is the standalone redemption outcome.

func (ConsumeAccountRateLimitResetCreditResponse) MarshalJSON 

func (r ConsumeAccountRateLimitResetCreditResponse) MarshalJSON() ([]byte, error)

func (*ConsumeAccountRateLimitResetCreditResponse) UnmarshalJSON 

func (r *ConsumeAccountRateLimitResetCreditResponse) UnmarshalJSON(data []byte) error

type ContentItem 

type ContentItem struct {
	// contains filtered or unexported fields
}

func (ContentItem) MarshalJSON 

func (c ContentItem) MarshalJSON() ([]byte, error)

func (*ContentItem) UnmarshalJSON 

func (c *ContentItem) UnmarshalJSON(data []byte) error

type ContextCompactedNotification 

type ContextCompactedNotification struct {
	ThreadID string `json:"threadId"`
	TurnID   string `json:"turnId"`
}

type ContextCompactionItem 

type ContextCompactionItem struct {
	Type      string    `json:"type" jsonschema:"enum=contextCompaction"`
	Summary   string    `json:"summary,omitempty"`
	CreatedAt time.Time `json:"createdAt"`
}

type CreditsSnapshot 

type CreditsSnapshot struct {
	HasCredits bool    `json:"hasCredits"`
	Unlimited  bool    `json:"unlimited"`
	Balance    *string `json:"balance,omitempty"`
}

CreditsSnapshot is exact public account-credit availability data.

func (CreditsSnapshot) MarshalJSON 

func (s CreditsSnapshot) MarshalJSON() ([]byte, error)

func (*CreditsSnapshot) UnmarshalJSON 

func (s *CreditsSnapshot) UnmarshalJSON(data []byte) error

type DaemonShutdownParams 

type DaemonShutdownParams struct {
	Reason string `json:"reason,omitempty"`
}

type DaemonShutdownState 

type DaemonShutdownState struct {
	Requested bool   `json:"requested"`
	Restart   bool   `json:"restart"`
	Reason    string `json:"reason,omitempty"`
}

type DaemonStartResult 

type DaemonStartResult struct {
	OK             bool         `json:"ok"`
	AlreadyRunning bool         `json:"alreadyRunning"`
	Status         DaemonStatus `json:"status"`
}

type DaemonStatus 

type DaemonStatus struct {
	Status            string              `json:"status" jsonschema:"enum=running|stopping"`
	Name              string              `json:"name"`
	Version           string              `json:"version"`
	ProtocolVersion   string              `json:"protocolVersion"`
	PID               int                 `json:"pid"`
	StartedAt         time.Time           `json:"startedAt"`
	UptimeMillis      int64               `json:"uptimeMillis"`
	Transport         string              `json:"transport,omitempty"`
	WorkDir           string              `json:"workDir,omitempty"`
	StorePath         string              `json:"storePath,omitempty"`
	ShutdownRequested bool                `json:"shutdownRequested"`
	RestartRequested  bool                `json:"restartRequested"`
	Shutdown          DaemonShutdownState `json:"shutdown,omitempty"`
}

type DaemonStopResult 

type DaemonStopResult struct {
	OK       bool         `json:"ok"`
	Stopping bool         `json:"stopping"`
	Restart  bool         `json:"restart"`
	Status   DaemonStatus `json:"status"`
}

type DaemonVersion 

type DaemonVersion struct {
	Name            string `json:"name"`
	Version         string `json:"version"`
	ProtocolVersion string `json:"protocolVersion"`
	GoVersion       string `json:"goVersion"`
	GOOS            string `json:"goos"`
	GOARCH          string `json:"goarch"`
}

type DeprecationNoticeNotification 

type DeprecationNoticeNotification struct {
	Summary string  `json:"summary" jsonschema:"description=Concise summary of what is deprecated."`
	Details *string `json:"details" jsonschema:"description=Optional extra guidance such as migration steps or rationale."`
}

type DynamicToolCallContentItem 

type DynamicToolCallContentItem struct {
	Type string `json:"type"`
	Text string `json:"text"`
}

type DynamicToolCallItem 

type DynamicToolCallItem struct {
	Type         string                       `json:"type" jsonschema:"enum=dynamicToolCall"`
	ID           string                       `json:"id,omitempty"`
	Namespace    *string                      `json:"namespace"`
	Tool         string                       `json:"tool"`
	Arguments    any                          `json:"arguments"`
	Status       string                       `json:"status" jsonschema:"enum=inProgress|completed|failed"`
	ContentItems []DynamicToolCallContentItem `json:"contentItems"`
	Success      *bool                        `json:"success"`
	DurationMS   *int64                       `json:"durationMs"`
}

type DynamicToolCallItemCompletedNotificationParams 

type DynamicToolCallItemCompletedNotificationParams struct {
	Item          DynamicToolCallItem `json:"item"`
	ThreadID      string              `json:"threadId"`
	TurnID        string              `json:"turnId"`
	CompletedAtMS int64               `json:"completedAtMs"`
}

type DynamicToolCallItemStartedNotificationParams 

type DynamicToolCallItemStartedNotificationParams struct {
	Item        DynamicToolCallItem `json:"item"`
	ThreadID    string              `json:"threadId"`
	TurnID      string              `json:"turnId"`
	StartedAtMS int64               `json:"startedAtMs"`
}

type DynamicToolCallOutputContentItem 

type DynamicToolCallOutputContentItem struct {
	Type     string `json:"type"`
	Text     string `json:"text,omitempty"`
	ImageURL string `json:"imageUrl,omitempty"`
}

func (DynamicToolCallOutputContentItem) MarshalJSON 

func (i DynamicToolCallOutputContentItem) MarshalJSON() ([]byte, error)

func (*DynamicToolCallOutputContentItem) UnmarshalJSON 

func (i *DynamicToolCallOutputContentItem) UnmarshalJSON(data []byte) error

type DynamicToolCallParams 

type DynamicToolCallParams struct {
	ThreadID    string          `json:"threadId"`
	TurnID      string          `json:"turnId"`
	CallID      string          `json:"callId"`
	Namespace   *string         `json:"namespace"`
	Tool        string          `json:"tool"`
	Arguments   json.RawMessage `json:"arguments"`
	RequestID   string          `json:"requestId,omitempty"`
	ItemID      string          `json:"itemId,omitempty"`
	StartedAtMS int64           `json:"startedAtMs,omitempty"`
	ToolName    string          `json:"toolName,omitempty"`
	Name        string          `json:"name,omitempty"`
	Metadata    map[string]any  `json:"metadata,omitempty"`
	Reason      string          `json:"reason,omitempty"`
}

DynamicToolCallParams is the public client-tool request. The trailing fields preserve Gollem's v1 request metadata for existing clients.

type DynamicToolCallResponse 

type DynamicToolCallResponse struct {
	ContentItems []DynamicToolCallOutputContentItem `json:"contentItems" jsonschema:"nonnullable=true"`
	Success      bool                               `json:"success"`
}

func (DynamicToolCallResponse) MarshalJSON 

func (r DynamicToolCallResponse) MarshalJSON() ([]byte, error)

func (*DynamicToolCallResponse) UnmarshalJSON 

func (r *DynamicToolCallResponse) UnmarshalJSON(data []byte) error

type DynamicToolCallStatus 

type DynamicToolCallStatus string
const (
	DynamicToolCallStatusInProgress DynamicToolCallStatus = ItemStatusInProgress
	DynamicToolCallStatusCompleted  DynamicToolCallStatus = ItemStatusCompleted
	DynamicToolCallStatusFailed     DynamicToolCallStatus = ItemStatusFailed
)

type DynamicToolFunctionSpec 

type DynamicToolFunctionSpec struct {
	Name         string    `json:"name"`
	Description  string    `json:"description"`
	InputSchema  JsonValue `json:"inputSchema"`
	DeferLoading bool      `json:"deferLoading,omitempty"`
}

DynamicToolFunctionSpec is one standalone function declaration. Exporting it does not register, validate, defer, or execute a tool.

func (DynamicToolFunctionSpec) MarshalJSON 

func (s DynamicToolFunctionSpec) MarshalJSON() ([]byte, error)

func (*DynamicToolFunctionSpec) UnmarshalJSON 

func (s *DynamicToolFunctionSpec) UnmarshalJSON(data []byte) error

type DynamicToolNamespaceSpec 

type DynamicToolNamespaceSpec struct {
	Name        string                     `json:"name"`
	Description string                     `json:"description"`
	Tools       []DynamicToolNamespaceTool `json:"tools"`
}

DynamicToolNamespaceSpec is one ordered public namespace declaration.

func (DynamicToolNamespaceSpec) MarshalJSON 

func (s DynamicToolNamespaceSpec) MarshalJSON() ([]byte, error)

func (*DynamicToolNamespaceSpec) UnmarshalJSON 

func (s *DynamicToolNamespaceSpec) UnmarshalJSON(data []byte) error

type DynamicToolNamespaceTool 

type DynamicToolNamespaceTool struct {
	Function DynamicToolFunctionSpec
}

DynamicToolNamespaceTool is the only tool variant accepted inside a public namespace. Nested namespace declarations are intentionally impossible.

func (DynamicToolNamespaceTool) MarshalJSON 

func (t DynamicToolNamespaceTool) MarshalJSON() ([]byte, error)

func (*DynamicToolNamespaceTool) UnmarshalJSON 

func (t *DynamicToolNamespaceTool) UnmarshalJSON(data []byte) error

type DynamicToolSpec 

type DynamicToolSpec struct {
	Function  *DynamicToolFunctionSpec
	Namespace *DynamicToolNamespaceSpec
}

DynamicToolSpec retains exactly one public function or namespace variant. It remains separate from Gollem's live dynamic-call contracts.

func (DynamicToolSpec) MarshalJSON 

func (s DynamicToolSpec) MarshalJSON() ([]byte, error)

func (*DynamicToolSpec) UnmarshalJSON 

func (s *DynamicToolSpec) UnmarshalJSON(data []byte) error

type Error 

type Error struct {
	Code    int             `json:"code"`
	Message string          `json:"message"`
	Data    json.RawMessage `json:"data,omitempty"`
}

Error is a JSON-RPC error object.

func MethodUnavailableError 

func MethodUnavailableError(method string) *Error

MethodUnavailableError returns a typed unavailable error for a known method. Unknown methods still receive JSON-RPC method-not-found.

func MethodUnavailableErrorWithReason 

func MethodUnavailableErrorWithReason(method, reason string) *Error

MethodUnavailableErrorWithReason returns a typed unavailable error with a runtime-specific reason. Unknown methods still receive method-not-found.

func OverloadedError 

func OverloadedError(method string, limit, pending int, reason string) *Error

OverloadedError returns the Codex-compatible app-server backpressure error.

func (*Error) Error 

func (e *Error) Error() string

type ErrorNotification 

type ErrorNotification struct {
	Error     TurnError `json:"error"`
	WillRetry bool      `json:"willRetry"`
	ThreadID  string    `json:"threadId"`
	TurnID    string    `json:"turnId"`
}

ErrorNotification is the exact fixed public turn-error notification. It remains standalone while Gollem's live runtime error envelope is wire-incompatible.

func (*ErrorNotification) UnmarshalJSON 

func (n *ErrorNotification) UnmarshalJSON(data []byte) error

type ExecCommandApprovalParams 

type ExecCommandApprovalParams struct {
	ConversationID ThreadId        `json:"conversationId"`
	CallID         string          `json:"callId"`
	ApprovalID     *string         `json:"approvalId,omitempty"`
	Command        []string        `json:"command"`
	CWD            string          `json:"cwd"`
	Reason         *string         `json:"reason,omitempty"`
	ParsedCmd      []ParsedCommand `json:"parsedCmd"`
}

ExecCommandApprovalParams is the exact legacy public approval request data. It remains separate from Gollem's live command-execution approval request.

func (ExecCommandApprovalParams) MarshalJSON 

func (p ExecCommandApprovalParams) MarshalJSON() ([]byte, error)

func (*ExecCommandApprovalParams) UnmarshalJSON 

func (p *ExecCommandApprovalParams) UnmarshalJSON(data []byte) error

type ExecCommandApprovalResponse 

type ExecCommandApprovalResponse struct {
	Decision ReviewDecision `json:"decision"`
}

ExecCommandApprovalResponse is the legacy exec-command callback response. It remains separate from the live command-execution approval response.

func (ExecCommandApprovalResponse) MarshalJSON 

func (r ExecCommandApprovalResponse) MarshalJSON() ([]byte, error)

func (*ExecCommandApprovalResponse) UnmarshalJSON 

func (r *ExecCommandApprovalResponse) UnmarshalJSON(data []byte) error

type ExecPolicyAmendment 

type ExecPolicyAmendment []string

type ExperimentalFeature 

type ExperimentalFeature struct {
	Name           string                   `json:"name"`
	Stage          ExperimentalFeatureStage `json:"stage"`
	DisplayName    *string                  `json:"displayName,omitempty"`
	Description    *string                  `json:"description,omitempty"`
	Announcement   *string                  `json:"announcement,omitempty"`
	Enabled        bool                     `json:"enabled"`
	DefaultEnabled bool                     `json:"defaultEnabled"`
}

ExperimentalFeature is exact standalone feature metadata.

func (ExperimentalFeature) MarshalJSON 

func (f ExperimentalFeature) MarshalJSON() ([]byte, error)

func (*ExperimentalFeature) UnmarshalJSON 

func (f *ExperimentalFeature) UnmarshalJSON(data []byte) error

type ExperimentalFeatureEnablementSetParams 

type ExperimentalFeatureEnablementSetParams struct {
	Enablement map[string]bool `json:"enablement"`
}

ExperimentalFeatureEnablementSetParams is exact standalone enablement input.

func (ExperimentalFeatureEnablementSetParams) MarshalJSON 

func (p ExperimentalFeatureEnablementSetParams) MarshalJSON() ([]byte, error)

func (*ExperimentalFeatureEnablementSetParams) UnmarshalJSON 

func (p *ExperimentalFeatureEnablementSetParams) UnmarshalJSON(data []byte) error

type ExperimentalFeatureEnablementSetResponse 

type ExperimentalFeatureEnablementSetResponse struct {
	Enablement map[string]bool `json:"enablement"`
}

ExperimentalFeatureEnablementSetResponse is exact standalone enablement output.

func (ExperimentalFeatureEnablementSetResponse) MarshalJSON 

func (r ExperimentalFeatureEnablementSetResponse) MarshalJSON() ([]byte, error)

func (*ExperimentalFeatureEnablementSetResponse) UnmarshalJSON 

func (r *ExperimentalFeatureEnablementSetResponse) UnmarshalJSON(data []byte) error

type ExperimentalFeatureListParams 

type ExperimentalFeatureListParams struct {
	Cursor   *string `json:"cursor,omitempty"`
	Limit    *uint32 `json:"limit,omitempty"`
	ThreadID *string `json:"threadId,omitempty"`
}

ExperimentalFeatureListParams is exact optional pagination/thread context.

func (*ExperimentalFeatureListParams) UnmarshalJSON 

func (p *ExperimentalFeatureListParams) UnmarshalJSON(data []byte) error

type ExperimentalFeatureListResponse 

type ExperimentalFeatureListResponse struct {
	Data       []ExperimentalFeature `json:"data"`
	NextCursor *string               `json:"nextCursor,omitempty"`
}

ExperimentalFeatureListResponse is exact standalone paginated feature data.

func (ExperimentalFeatureListResponse) MarshalJSON 

func (r ExperimentalFeatureListResponse) MarshalJSON() ([]byte, error)

func (*ExperimentalFeatureListResponse) UnmarshalJSON 

func (r *ExperimentalFeatureListResponse) UnmarshalJSON(data []byte) error

type ExperimentalFeatureStage 

type ExperimentalFeatureStage string

ExperimentalFeatureStage is the exact closed public feature lifecycle. 

const (
	ExperimentalFeatureStageBeta             ExperimentalFeatureStage = "beta"
	ExperimentalFeatureStageUnderDevelopment ExperimentalFeatureStage = "underDevelopment"
	ExperimentalFeatureStageStable           ExperimentalFeatureStage = "stable"
	ExperimentalFeatureStageDeprecated       ExperimentalFeatureStage = "deprecated"
	ExperimentalFeatureStageRemoved          ExperimentalFeatureStage = "removed"
)

func (ExperimentalFeatureStage) MarshalJSON 

func (s ExperimentalFeatureStage) MarshalJSON() ([]byte, error)

func (*ExperimentalFeatureStage) UnmarshalJSON 

func (s *ExperimentalFeatureStage) UnmarshalJSON(data []byte) error

type ExternalAgentConfigDetectParams 

type ExternalAgentConfigDetectParams struct {
	IncludeHome bool     `json:"includeHome,omitempty"`
	CWDs        []string `json:"cwds"`
}

ExternalAgentConfigDetectParams is the exact standalone public request for describing detection scope. It does not grant filesystem access or authority.

func (ExternalAgentConfigDetectParams) MarshalJSON 

func (p ExternalAgentConfigDetectParams) MarshalJSON() ([]byte, error)

func (*ExternalAgentConfigDetectParams) UnmarshalJSON 

func (p *ExternalAgentConfigDetectParams) UnmarshalJSON(data []byte) error

type ExternalAgentConfigDetectResponse 

type ExternalAgentConfigDetectResponse struct {
	Items []ExternalAgentConfigMigrationItem `json:"items"`
}

ExternalAgentConfigDetectResponse is the exact standalone public collection of migration items. It does not imply that detection has been implemented.

func (ExternalAgentConfigDetectResponse) MarshalJSON 

func (r ExternalAgentConfigDetectResponse) MarshalJSON() ([]byte, error)

func (*ExternalAgentConfigDetectResponse) UnmarshalJSON 

func (r *ExternalAgentConfigDetectResponse) UnmarshalJSON(data []byte) error

type ExternalAgentConfigImportCompletedNotification 

type ExternalAgentConfigImportCompletedNotification struct {
	ImportID        string                                `json:"importId"`
	ItemTypeResults []ExternalAgentConfigImportTypeResult `json:"itemTypeResults"`
}

ExternalAgentConfigImportCompletedNotification is the exact standalone completion value. It does not imply that Gollem executes imports.

func (ExternalAgentConfigImportCompletedNotification) MarshalJSON 

func (n ExternalAgentConfigImportCompletedNotification) MarshalJSON() ([]byte, error)

func (*ExternalAgentConfigImportCompletedNotification) UnmarshalJSON 

func (n *ExternalAgentConfigImportCompletedNotification) UnmarshalJSON(data []byte) error

type ExternalAgentConfigImportHistoriesReadResponse 

type ExternalAgentConfigImportHistoriesReadResponse struct {
	Data []ExternalAgentConfigImportHistory `json:"data"`
}

ExternalAgentConfigImportHistoriesReadResponse is an exact standalone history-read response. Gollem does not bind it to a method or persist it.

func (ExternalAgentConfigImportHistoriesReadResponse) MarshalJSON 

func (r ExternalAgentConfigImportHistoriesReadResponse) MarshalJSON() ([]byte, error)

func (*ExternalAgentConfigImportHistoriesReadResponse) UnmarshalJSON 

func (r *ExternalAgentConfigImportHistoriesReadResponse) UnmarshalJSON(data []byte) error

type ExternalAgentConfigImportHistory 

type ExternalAgentConfigImportHistory struct {
	ImportID      string                                     `json:"importId"`
	CompletedAtMS int64                                      `json:"completedAtMs"`
	Successes     []ExternalAgentConfigImportItemTypeSuccess `json:"successes"`
	Failures      []ExternalAgentConfigImportItemTypeFailure `json:"failures"`
}

ExternalAgentConfigImportHistory is an exact standalone import-history record. Its contents are descriptive data and do not prove an import ran.

func (ExternalAgentConfigImportHistory) MarshalJSON 

func (h ExternalAgentConfigImportHistory) MarshalJSON() ([]byte, error)

func (*ExternalAgentConfigImportHistory) UnmarshalJSON 

func (h *ExternalAgentConfigImportHistory) UnmarshalJSON(data []byte) error

type ExternalAgentConfigImportItemTypeFailure 

type ExternalAgentConfigImportItemTypeFailure struct {
	ItemType     ExternalAgentConfigMigrationItemType `json:"itemType"`
	ErrorType    *string                              `json:"errorType"`
	FailureStage string                               `json:"failureStage"`
	Message      string                               `json:"message"`
	CWD          *string                              `json:"cwd"`
	Source       *string                              `json:"source"`
}

ExternalAgentConfigImportItemTypeFailure is an exact standalone import failure description. It does not imply that import execution occurred.

func (ExternalAgentConfigImportItemTypeFailure) MarshalJSON 

func (r ExternalAgentConfigImportItemTypeFailure) MarshalJSON() ([]byte, error)

func (*ExternalAgentConfigImportItemTypeFailure) UnmarshalJSON 

func (r *ExternalAgentConfigImportItemTypeFailure) UnmarshalJSON(data []byte) error

type ExternalAgentConfigImportItemTypeSuccess 

type ExternalAgentConfigImportItemTypeSuccess struct {
	ItemType ExternalAgentConfigMigrationItemType `json:"itemType"`
	CWD      *string                              `json:"cwd"`
	Source   *string                              `json:"source"`
	Target   *string                              `json:"target"`
}

ExternalAgentConfigImportItemTypeSuccess is an exact standalone import result. Its paths and strings are descriptive data, not evidence or authority.

func (ExternalAgentConfigImportItemTypeSuccess) MarshalJSON 

func (r ExternalAgentConfigImportItemTypeSuccess) MarshalJSON() ([]byte, error)

func (*ExternalAgentConfigImportItemTypeSuccess) UnmarshalJSON 

func (r *ExternalAgentConfigImportItemTypeSuccess) UnmarshalJSON(data []byte) error

type ExternalAgentConfigImportParams 

type ExternalAgentConfigImportParams struct {
	MigrationItems []ExternalAgentConfigMigrationItem `json:"migrationItems"`
	Source         *string                            `json:"source"`
}

ExternalAgentConfigImportParams is the exact standalone public import description. It does not grant path access or authorize import execution.

func (ExternalAgentConfigImportParams) MarshalJSON 

func (p ExternalAgentConfigImportParams) MarshalJSON() ([]byte, error)

func (*ExternalAgentConfigImportParams) UnmarshalJSON 

func (p *ExternalAgentConfigImportParams) UnmarshalJSON(data []byte) error

type ExternalAgentConfigImportProgressNotification 

type ExternalAgentConfigImportProgressNotification struct {
	ImportID        string                                `json:"importId"`
	ItemTypeResults []ExternalAgentConfigImportTypeResult `json:"itemTypeResults"`
}

ExternalAgentConfigImportProgressNotification is the exact standalone progress value. It does not imply that Gollem produces import progress.

func (ExternalAgentConfigImportProgressNotification) MarshalJSON 

func (n ExternalAgentConfigImportProgressNotification) MarshalJSON() ([]byte, error)

func (*ExternalAgentConfigImportProgressNotification) UnmarshalJSON 

func (n *ExternalAgentConfigImportProgressNotification) UnmarshalJSON(data []byte) error

type ExternalAgentConfigImportResponse 

type ExternalAgentConfigImportResponse struct {
	ImportID string `json:"importId"`
}

ExternalAgentConfigImportResponse is the exact standalone public import ID. It does not imply that an import has run or persisted any configuration.

func (ExternalAgentConfigImportResponse) MarshalJSON 

func (r ExternalAgentConfigImportResponse) MarshalJSON() ([]byte, error)

func (*ExternalAgentConfigImportResponse) UnmarshalJSON 

func (r *ExternalAgentConfigImportResponse) UnmarshalJSON(data []byte) error

type ExternalAgentConfigImportTypeResult 

type ExternalAgentConfigImportTypeResult struct {
	ItemType  ExternalAgentConfigMigrationItemType       `json:"itemType"`
	Successes []ExternalAgentConfigImportItemTypeSuccess `json:"successes"`
	Failures  []ExternalAgentConfigImportItemTypeFailure `json:"failures"`
}

ExternalAgentConfigImportTypeResult is an exact standalone result summary. Its nested records describe outcomes without proving that an import ran.

func (ExternalAgentConfigImportTypeResult) MarshalJSON 

func (r ExternalAgentConfigImportTypeResult) MarshalJSON() ([]byte, error)

func (*ExternalAgentConfigImportTypeResult) UnmarshalJSON 

func (r *ExternalAgentConfigImportTypeResult) UnmarshalJSON(data []byte) error

type ExternalAgentConfigMigrationItem 

type ExternalAgentConfigMigrationItem struct {
	ItemType    ExternalAgentConfigMigrationItemType `json:"itemType"`
	Description string                               `json:"description"`
	CWD         *string                              `json:"cwd"`
	Details     *MigrationDetails                    `json:"details"`
}

ExternalAgentConfigMigrationItem describes one standalone migration category. Its cwd and details fields are descriptive data, not filesystem authority.

func (ExternalAgentConfigMigrationItem) MarshalJSON 

func (i ExternalAgentConfigMigrationItem) MarshalJSON() ([]byte, error)

func (*ExternalAgentConfigMigrationItem) UnmarshalJSON 

func (i *ExternalAgentConfigMigrationItem) UnmarshalJSON(data []byte) error

type ExternalAgentConfigMigrationItemType 

type ExternalAgentConfigMigrationItemType string

ExternalAgentConfigMigrationItemType is the exact closed public category for an external-agent migration item. It remains standalone from discovery, import, configuration, and runtime behavior. 

const (
	ExternalAgentConfigMigrationItemTypeAgentsMD        ExternalAgentConfigMigrationItemType = "AGENTS_MD"
	ExternalAgentConfigMigrationItemTypeConfig          ExternalAgentConfigMigrationItemType = "CONFIG"
	ExternalAgentConfigMigrationItemTypeSkills          ExternalAgentConfigMigrationItemType = "SKILLS"
	ExternalAgentConfigMigrationItemTypePlugins         ExternalAgentConfigMigrationItemType = "PLUGINS"
	ExternalAgentConfigMigrationItemTypeMCPServerConfig ExternalAgentConfigMigrationItemType = "MCP_SERVER_CONFIG"
	ExternalAgentConfigMigrationItemTypeSubagents       ExternalAgentConfigMigrationItemType = "SUBAGENTS"
	ExternalAgentConfigMigrationItemTypeHooks           ExternalAgentConfigMigrationItemType = "HOOKS"
	ExternalAgentConfigMigrationItemTypeCommands        ExternalAgentConfigMigrationItemType = "COMMANDS"
	ExternalAgentConfigMigrationItemTypeSessions        ExternalAgentConfigMigrationItemType = "SESSIONS"
)

func (ExternalAgentConfigMigrationItemType) MarshalJSON 

func (t ExternalAgentConfigMigrationItemType) MarshalJSON() ([]byte, error)

func (*ExternalAgentConfigMigrationItemType) UnmarshalJSON 

func (t *ExternalAgentConfigMigrationItemType) UnmarshalJSON(data []byte) error

type FileChange 

type FileChange struct {
	// contains filtered or unexported fields
}

FileChange is the exact legacy public description of one file update. It is standalone and distinct from the live FileUpdateChange item payload.

func (FileChange) MarshalJSON 

func (c FileChange) MarshalJSON() ([]byte, error)

func (FileChange) Type 

func (c FileChange) Type() string

Type returns the exact public file-change discriminant.

func (*FileChange) UnmarshalJSON 

func (c *FileChange) UnmarshalJSON(data []byte) error

type FileChangeApprovalDecision 

type FileChangeApprovalDecision string
const (
	FileChangeApprovalAccept           FileChangeApprovalDecision = "accept"
	FileChangeApprovalAcceptForSession FileChangeApprovalDecision = "acceptForSession"
	FileChangeApprovalDecline          FileChangeApprovalDecision = "decline"
	FileChangeApprovalCancel           FileChangeApprovalDecision = "cancel"
)

type FileChangeApprovalRequestParams 

type FileChangeApprovalRequestParams struct {
	ApprovalRequestBase
	GrantRoot   *string `json:"grantRoot"`
	Operation   string  `json:"operation,omitempty"`
	Path        string  `json:"path,omitempty"`
	Destination string  `json:"destination,omitempty"`
	Destructive bool    `json:"destructive,omitempty"`
}

type FileChangeArtifactEvidence 

type FileChangeArtifactEvidence struct {
	Path                    string `json:"path"`
	Operation               string `json:"operation"`
	Bytes                   int64  `json:"bytes"`
	BeforeSHA256            string `json:"beforeSha256,omitempty"`
	AfterSHA256             string `json:"afterSha256,omitempty"`
	DiffTruncated           bool   `json:"diffTruncated,omitempty"`
	DiffOmittedReason       string `json:"diffOmittedReason,omitempty"`
	ContentEncoding         string `json:"contentEncoding,omitempty"`
	ContentTruncated        bool   `json:"contentTruncated,omitempty"`
	ContentOmittedReason    string `json:"contentOmittedReason,omitempty"`
	RevertSnapshotAvailable bool   `json:"revertSnapshotAvailable,omitempty"`
	RevertUnavailableReason string `json:"revertUnavailableReason,omitempty"`
}

type FileChangeItem 

type FileChangeItem struct {
	Type     string                       `json:"type" jsonschema:"enum=fileChange"`
	ID       string                       `json:"id,omitempty"`
	Changes  []FileUpdateChange           `json:"changes"`
	Status   PatchApplyStatus             `json:"status"`
	Evidence []FileChangeArtifactEvidence `json:"evidence,omitempty"`
}

type FileChangeItemCompletedNotificationParams 

type FileChangeItemCompletedNotificationParams struct {
	Item          FileChangeItem `json:"item"`
	ThreadID      string         `json:"threadId"`
	TurnID        string         `json:"turnId"`
	CompletedAtMS int64          `json:"completedAtMs"`
}

type FileChangeItemStartedNotificationParams 

type FileChangeItemStartedNotificationParams struct {
	Item        FileChangeItem `json:"item"`
	ThreadID    string         `json:"threadId"`
	TurnID      string         `json:"turnId"`
	StartedAtMS int64          `json:"startedAtMs"`
}

type FileChangeOutputDeltaNotification 

type FileChangeOutputDeltaNotification struct {
	ThreadID string `json:"threadId"`
	TurnID   string `json:"turnId"`
	ItemID   string `json:"itemId"`
	Delta    string `json:"delta"`
}

FileChangeOutputDeltaNotification is the exact deprecated public textual apply-patch output value. It remains standalone because the server no longer emits item/fileChange/outputDelta.

func (*FileChangeOutputDeltaNotification) UnmarshalJSON 

func (n *FileChangeOutputDeltaNotification) UnmarshalJSON(data []byte) error

type FileChangePatchUpdatedNotification 

type FileChangePatchUpdatedNotification struct {
	ThreadID string             `json:"threadId"`
	TurnID   string             `json:"turnId"`
	ItemID   string             `json:"itemId"`
	Changes  []FileUpdateChange `json:"changes" jsonschema:"nonnullable=true"`
}

func (FileChangePatchUpdatedNotification) MarshalJSON 

func (n FileChangePatchUpdatedNotification) MarshalJSON() ([]byte, error)

type FileChangePatchUpdatedNotificationParams 

type FileChangePatchUpdatedNotificationParams = FileChangePatchUpdatedNotification

type FileChangeRequestApprovalResponse 

type FileChangeRequestApprovalResponse struct {
	Decision FileChangeApprovalDecision `json:"decision"`
}

type FileChangeRevertParams 

type FileChangeRevertParams struct {
	ThreadID       string `json:"threadId"`
	ItemID         string `json:"itemId"`
	IdempotencyKey string `json:"idempotencyKey"`
}

FileChangeRevertParams identifies one Gollem-owned file-change item. The caller never supplies a path, patch, digest, or replacement content.

type FileChangeRevertResult 

type FileChangeRevertResult struct {
	ThreadID       string       `json:"threadId"`
	TurnID         string       `json:"turnId"`
	ItemID         string       `json:"itemId"`
	IdempotencyKey string       `json:"idempotencyKey"`
	Path           string       `json:"path"`
	BeforeExists   bool         `json:"beforeExists"`
	AfterExists    bool         `json:"afterExists"`
	BeforeSHA256   string       `json:"beforeSha256,omitempty"`
	AfterSHA256    string       `json:"afterSha256,omitempty"`
	RevertedAt     time.Time    `json:"revertedAt"`
	Marker         TimelineItem `json:"marker"`
	Reused         bool         `json:"reused"`
}

type FileChangedNotification 

type FileChangedNotification struct {
	Path        *string   `json:"path,omitempty" jsonschema:"nonnullable=true"`
	Destination *string   `json:"destination,omitempty" jsonschema:"nonnullable=true"`
	Operation   string    `json:"operation"`
	At          time.Time `json:"at"`
}

FileChangedNotification is Gollem's mutation-level extension on fs/changed. The public watch notification remains FsChangedNotification.

type FileSystemAccessMode 

type FileSystemAccessMode string

func (FileSystemAccessMode) MarshalJSON 

func (m FileSystemAccessMode) MarshalJSON() ([]byte, error)

func (*FileSystemAccessMode) UnmarshalJSON 

func (m *FileSystemAccessMode) UnmarshalJSON(data []byte) error

type FileSystemPath 

type FileSystemPath struct {
	// contains filtered or unexported fields
}

FileSystemPath is the closed public path/glob/special union.

func (FileSystemPath) MarshalJSON 

func (p FileSystemPath) MarshalJSON() ([]byte, error)

func (FileSystemPath) Type 

func (p FileSystemPath) Type() string

func (*FileSystemPath) UnmarshalJSON 

func (p *FileSystemPath) UnmarshalJSON(data []byte) error

type FileSystemSandboxEntry 

type FileSystemSandboxEntry struct {
	Path   FileSystemPath       `json:"path"`
	Access FileSystemAccessMode `json:"access"`
}

func (*FileSystemSandboxEntry) UnmarshalJSON 

func (e *FileSystemSandboxEntry) UnmarshalJSON(data []byte) error

type FileSystemSpecialPath 

type FileSystemSpecialPath struct {
	// contains filtered or unexported fields
}

FileSystemSpecialPath is the closed public special-path union.

func (FileSystemSpecialPath) Kind 

func (p FileSystemSpecialPath) Kind() string

func (FileSystemSpecialPath) MarshalJSON 

func (p FileSystemSpecialPath) MarshalJSON() ([]byte, error)

func (*FileSystemSpecialPath) UnmarshalJSON 

func (p *FileSystemSpecialPath) UnmarshalJSON(data []byte) error

type FileUpdateChange 

type FileUpdateChange struct {
	Path string          `json:"path"`
	Kind PatchChangeKind `json:"kind"`
	Diff string          `json:"diff"`
}

type ForcedChatgptWorkspaceIds 

type ForcedChatgptWorkspaceIds struct {
	// contains filtered or unexported fields
}

ForcedChatgptWorkspaceIds preserves whether the public compatibility value used its single-workspace or multiple-workspace wire form.

func (ForcedChatgptWorkspaceIds) MarshalJSON 

func (i ForcedChatgptWorkspaceIds) MarshalJSON() ([]byte, error)

func (*ForcedChatgptWorkspaceIds) UnmarshalJSON 

func (i *ForcedChatgptWorkspaceIds) UnmarshalJSON(data []byte) error

type ForcedLoginMethod 

type ForcedLoginMethod string

ForcedLoginMethod is the exact closed public login method. 

const (
	ForcedLoginMethodChatGPT ForcedLoginMethod = "chatgpt"
	ForcedLoginMethodAPI     ForcedLoginMethod = "api"
)

func (ForcedLoginMethod) MarshalJSON 

func (m ForcedLoginMethod) MarshalJSON() ([]byte, error)

func (*ForcedLoginMethod) UnmarshalJSON 

func (m *ForcedLoginMethod) UnmarshalJSON(data []byte) error

type FsChangedNotification 

type FsChangedNotification struct {
	WatchID      string            `json:"watchId"`
	ChangedPaths []AbsolutePathBuf `json:"changedPaths" jsonschema:"nonnullable=true"`
}

func (FsChangedNotification) MarshalJSON 

func (n FsChangedNotification) MarshalJSON() ([]byte, error)

func (*FsChangedNotification) UnmarshalJSON 

func (n *FsChangedNotification) UnmarshalJSON(data []byte) error

type FsCopyParams 

type FsCopyParams struct {
	SourcePath      AbsolutePathBuf `json:"sourcePath"`
	DestinationPath AbsolutePathBuf `json:"destinationPath"`
	Recursive       *bool           `json:"recursive,omitempty" jsonschema:"nonnullable=true"`
}

type FsCopyResponse 

type FsCopyResponse struct {
	OK          *bool   `json:"ok,omitempty" jsonschema:"nonnullable=true"`
	Source      *string `json:"source,omitempty" jsonschema:"nonnullable=true"`
	Destination *string `json:"destination,omitempty" jsonschema:"nonnullable=true"`
}

type FsCreateDirectoryParams 

type FsCreateDirectoryParams struct {
	Path      AbsolutePathBuf `json:"path"`
	Recursive *bool           `json:"recursive,omitempty"`
}

type FsCreateDirectoryResponse 

type FsCreateDirectoryResponse struct {
	OK   *bool   `json:"ok,omitempty" jsonschema:"nonnullable=true"`
	Path *string `json:"path,omitempty" jsonschema:"nonnullable=true"`
}

type FsGetMetadataParams 

type FsGetMetadataParams struct {
	Path AbsolutePathBuf `json:"path"`
}

type FsGetMetadataResponse 

type FsGetMetadataResponse struct {
	IsDirectory  bool       `json:"isDirectory"`
	IsFile       bool       `json:"isFile"`
	IsSymlink    bool       `json:"isSymlink"`
	CreatedAtMS  int64      `json:"createdAtMs"`
	ModifiedAtMS int64      `json:"modifiedAtMs"`
	Path         *string    `json:"path,omitempty" jsonschema:"nonnullable=true"`
	IsDir        *bool      `json:"isDir,omitempty" jsonschema:"nonnullable=true"`
	Size         *int64     `json:"size,omitempty" jsonschema:"nonnullable=true"`
	Mode         *uint32    `json:"mode,omitempty" jsonschema:"nonnullable=true"`
	ModTime      *time.Time `json:"modTime,omitempty" jsonschema:"nonnullable=true"`
}

type FsReadDirectoryEntry 

type FsReadDirectoryEntry struct {
	FileName      string     `json:"fileName"`
	IsDirectory   bool       `json:"isDirectory"`
	IsFile        bool       `json:"isFile"`
	LegacyPath    *string    `json:"Path,omitempty" jsonschema:"nonnullable=true"`
	LegacyName    *string    `json:"Name,omitempty" jsonschema:"nonnullable=true"`
	LegacyIsDir   *bool      `json:"IsDir,omitempty" jsonschema:"nonnullable=true"`
	LegacySize    *int64     `json:"Size,omitempty" jsonschema:"nonnullable=true"`
	LegacyMode    *uint32    `json:"Mode,omitempty" jsonschema:"nonnullable=true"`
	LegacyModTime *time.Time `json:"ModTime,omitempty" jsonschema:"nonnullable=true"`
}

type FsReadDirectoryParams 

type FsReadDirectoryParams struct {
	Path AbsolutePathBuf `json:"path"`
}

type FsReadDirectoryResponse 

type FsReadDirectoryResponse struct {
	Entries []FsReadDirectoryEntry `json:"entries" jsonschema:"nonnullable=true"`
}

func (FsReadDirectoryResponse) MarshalJSON 

func (r FsReadDirectoryResponse) MarshalJSON() ([]byte, error)

func (*FsReadDirectoryResponse) UnmarshalJSON 

func (r *FsReadDirectoryResponse) UnmarshalJSON(data []byte) error

type FsReadFileParams 

type FsReadFileParams struct {
	Path AbsolutePathBuf `json:"path"`
}

type FsReadFileResponse 

type FsReadFileResponse struct {
	DataBase64       string     `json:"dataBase64"`
	Path             *string    `json:"path,omitempty" jsonschema:"nonnullable=true"`
	Content          *string    `json:"content,omitempty" jsonschema:"nonnullable=true"`
	Encoding         *string    `json:"encoding,omitempty" jsonschema:"nonnullable=true"`
	Size             *int64     `json:"size,omitempty" jsonschema:"nonnullable=true"`
	Mode             *uint32    `json:"mode,omitempty" jsonschema:"nonnullable=true"`
	ModTime          *time.Time `json:"modTime,omitempty" jsonschema:"nonnullable=true"`
	ContentTruncated *bool      `json:"contentTruncated,omitempty" jsonschema:"nonnullable=true"`
}

type FsRemoveParams 

type FsRemoveParams struct {
	Path      AbsolutePathBuf `json:"path"`
	Recursive *bool           `json:"recursive,omitempty"`
	Force     *bool           `json:"force,omitempty"`
}

type FsRemoveResponse 

type FsRemoveResponse struct {
	OK   *bool   `json:"ok,omitempty" jsonschema:"nonnullable=true"`
	Path *string `json:"path,omitempty" jsonschema:"nonnullable=true"`
}

type FsUnwatchParams 

type FsUnwatchParams struct {
	WatchID string `json:"watchId"`
}

type FsUnwatchResponse 

type FsUnwatchResponse struct{}

type FsWatchParams 

type FsWatchParams struct {
	WatchID            string          `json:"watchId"`
	Path               AbsolutePathBuf `json:"path"`
	PollIntervalMillis *int64          `json:"pollIntervalMillis,omitempty" jsonschema:"nonnullable=true"`
}

type FsWatchResponse 

type FsWatchResponse struct {
	Path AbsolutePathBuf `json:"path"`
}

type FsWriteFileParams 

type FsWriteFileParams struct {
	Path       AbsolutePathBuf `json:"path"`
	DataBase64 string          `json:"dataBase64"`
}

type FsWriteFileResponse 

type FsWriteFileResponse struct {
	OK   *bool   `json:"ok,omitempty" jsonschema:"nonnullable=true"`
	Path *string `json:"path,omitempty" jsonschema:"nonnullable=true"`
}

type FunctionCallOutputBody 

type FunctionCallOutputBody struct {
	// contains filtered or unexported fields
}

func (FunctionCallOutputBody) MarshalJSON 

func (b FunctionCallOutputBody) MarshalJSON() ([]byte, error)

func (*FunctionCallOutputBody) UnmarshalJSON 

func (b *FunctionCallOutputBody) UnmarshalJSON(data []byte) error

type FunctionCallOutputContentItem 

type FunctionCallOutputContentItem struct {
	// contains filtered or unexported fields
}

func (FunctionCallOutputContentItem) MarshalJSON 

func (c FunctionCallOutputContentItem) MarshalJSON() ([]byte, error)

func (*FunctionCallOutputContentItem) UnmarshalJSON 

func (c *FunctionCallOutputContentItem) UnmarshalJSON(data []byte) error

type FuzzyFileSearchMatchType 

type FuzzyFileSearchMatchType string

FuzzyFileSearchMatchType is the exact closed public kind of a fuzzy-search result. It does not imply that Gollem searched or accessed a path. 

const (
	FuzzyFileSearchMatchTypeFile      FuzzyFileSearchMatchType = "file"
	FuzzyFileSearchMatchTypeDirectory FuzzyFileSearchMatchType = "directory"
)

func (FuzzyFileSearchMatchType) MarshalJSON 

func (t FuzzyFileSearchMatchType) MarshalJSON() ([]byte, error)

func (*FuzzyFileSearchMatchType) UnmarshalJSON 

func (t *FuzzyFileSearchMatchType) UnmarshalJSON(data []byte) error

type FuzzyFileSearchParams 

type FuzzyFileSearchParams struct {
	Query             string   `json:"query"`
	Roots             []string `json:"roots"`
	CancellationToken *string  `json:"cancellationToken"`
}

FuzzyFileSearchParams is an exact standalone search description. Its roots remain opaque strings and grant no filesystem authority.

func (FuzzyFileSearchParams) MarshalJSON 

func (p FuzzyFileSearchParams) MarshalJSON() ([]byte, error)

func (*FuzzyFileSearchParams) UnmarshalJSON 

func (p *FuzzyFileSearchParams) UnmarshalJSON(data []byte) error

type FuzzyFileSearchResponse 

type FuzzyFileSearchResponse struct {
	Files []FuzzyFileSearchResult `json:"files"`
}

FuzzyFileSearchResponse is an exact standalone fuzzy-search result envelope.

func (FuzzyFileSearchResponse) MarshalJSON 

func (r FuzzyFileSearchResponse) MarshalJSON() ([]byte, error)

func (*FuzzyFileSearchResponse) UnmarshalJSON 

func (r *FuzzyFileSearchResponse) UnmarshalJSON(data []byte) error

type FuzzyFileSearchResult 

type FuzzyFileSearchResult struct {
	Root      string                   `json:"root"`
	Path      string                   `json:"path"`
	MatchType FuzzyFileSearchMatchType `json:"match_type"`
	FileName  string                   `json:"file_name"`
	Score     uint32                   `json:"score"`
	Indices   *[]uint32                `json:"indices"`
}

FuzzyFileSearchResult is the exact standalone public result record. Scores, indices, and paths remain descriptive values with no ranking or path meaning.

func (FuzzyFileSearchResult) MarshalJSON 

func (r FuzzyFileSearchResult) MarshalJSON() ([]byte, error)

func (*FuzzyFileSearchResult) UnmarshalJSON 

func (r *FuzzyFileSearchResult) UnmarshalJSON(data []byte) error

type FuzzyFileSearchSessionCompletedNotification 

type FuzzyFileSearchSessionCompletedNotification struct {
	SessionID string `json:"sessionId"`
}

FuzzyFileSearchSessionCompletedNotification is an exact standalone session completion marker. Gollem does not produce or bind this notification.

func (FuzzyFileSearchSessionCompletedNotification) MarshalJSON 

func (n FuzzyFileSearchSessionCompletedNotification) MarshalJSON() ([]byte, error)

func (*FuzzyFileSearchSessionCompletedNotification) UnmarshalJSON 

func (n *FuzzyFileSearchSessionCompletedNotification) UnmarshalJSON(data []byte) error

type FuzzyFileSearchSessionUpdatedNotification 

type FuzzyFileSearchSessionUpdatedNotification struct {
	SessionID string                  `json:"sessionId"`
	Query     string                  `json:"query"`
	Files     []FuzzyFileSearchResult `json:"files"`
}

FuzzyFileSearchSessionUpdatedNotification is an exact standalone session snapshot. Gollem does not produce or bind this notification.

func (FuzzyFileSearchSessionUpdatedNotification) MarshalJSON 

func (n FuzzyFileSearchSessionUpdatedNotification) MarshalJSON() ([]byte, error)

func (*FuzzyFileSearchSessionUpdatedNotification) UnmarshalJSON 

func (n *FuzzyFileSearchSessionUpdatedNotification) UnmarshalJSON(data []byte) error

type GetAccountParams 

type GetAccountParams struct {
	RefreshToken bool `json:"refreshToken,omitempty"`
}

GetAccountParams is the exact standalone account-read request.

func (*GetAccountParams) UnmarshalJSON 

func (p *GetAccountParams) UnmarshalJSON(data []byte) error

type GetAccountRateLimitsResponse 

type GetAccountRateLimitsResponse struct {
	RateLimits            RateLimitSnapshot             `json:"rateLimits"`
	RateLimitsByLimitID   map[string]RateLimitSnapshot  `json:"rateLimitsByLimitId,omitempty"`
	RateLimitResetCredits *RateLimitResetCreditsSummary `json:"rateLimitResetCredits,omitempty"`
}

GetAccountRateLimitsResponse is exact standalone rate-limit read data.

func (GetAccountRateLimitsResponse) MarshalJSON 

func (r GetAccountRateLimitsResponse) MarshalJSON() ([]byte, error)

func (*GetAccountRateLimitsResponse) UnmarshalJSON 

func (r *GetAccountRateLimitsResponse) UnmarshalJSON(data []byte) error

type GetAccountResponse 

type GetAccountResponse struct {
	Account            *Account `json:"account,omitempty"`
	RequiresOpenAIAuth bool     `json:"requiresOpenaiAuth"`
}

GetAccountResponse is exact standalone account-read data.

func (GetAccountResponse) MarshalJSON 

func (r GetAccountResponse) MarshalJSON() ([]byte, error)

func (*GetAccountResponse) UnmarshalJSON 

func (r *GetAccountResponse) UnmarshalJSON(data []byte) error

type GetAccountTokenUsageResponse 

type GetAccountTokenUsageResponse struct {
	Summary           AccountTokenUsageSummary       `json:"summary"`
	DailyUsageBuckets []AccountTokenUsageDailyBucket `json:"dailyUsageBuckets,omitempty"`
}

GetAccountTokenUsageResponse is exact standalone usage-read data.

func (GetAccountTokenUsageResponse) MarshalJSON 

func (r GetAccountTokenUsageResponse) MarshalJSON() ([]byte, error)

func (*GetAccountTokenUsageResponse) UnmarshalJSON 

func (r *GetAccountTokenUsageResponse) UnmarshalJSON(data []byte) error

type GetWorkspaceMessagesResponse 

type GetWorkspaceMessagesResponse struct {
	FeatureEnabled bool               `json:"featureEnabled"`
	Messages       []WorkspaceMessage `json:"messages"`
}

GetWorkspaceMessagesResponse is exact standalone workspace-message list data. It does not imply that Gollem owns a workspace-message backend.

func (GetWorkspaceMessagesResponse) MarshalJSON 

func (r GetWorkspaceMessagesResponse) MarshalJSON() ([]byte, error)

func (*GetWorkspaceMessagesResponse) UnmarshalJSON 

func (r *GetWorkspaceMessagesResponse) UnmarshalJSON(data []byte) error

type GitInfo 

type GitInfo struct {
	SHA       *string `json:"sha"`
	Branch    *string `json:"branch"`
	OriginURL *string `json:"originUrl"`
}

func (GitInfo) MarshalJSON 

func (i GitInfo) MarshalJSON() ([]byte, error)

func (*GitInfo) UnmarshalJSON 

func (i *GitInfo) UnmarshalJSON(data []byte) error

type GitStatusEntry added in v0.8.0 

type GitStatusEntry struct {
	Code      string `json:"code"`
	Path      string `json:"path"`
	Truncated bool   `json:"truncated"`
}

GitStatusEntry is one bounded porcelain status record.

type GitStatusResponse added in v0.8.0 

type GitStatusResponse struct {
	Status     GitStatusSnapshot `json:"status"`
	SnapshotID string            `json:"snapshotId"`
	NextCursor string            `json:"nextCursor,omitempty"`
	ObservedAt time.Time         `json:"observedAt"`
}

type GitStatusSnapshot added in v0.8.0 

type GitStatusSnapshot struct {
	BranchLine       string           `json:"branchLine"`
	BranchTruncated  bool             `json:"branchTruncated"`
	Entries          []GitStatusEntry `json:"entries" jsonschema:"nonnullable=true"`
	Clean            bool             `json:"clean"`
	EntryCount       int              `json:"entryCount"`
	EntriesTruncated bool             `json:"entriesTruncated"`
}

type GitWorktree added in v0.8.0 

type GitWorktree struct {
	Path              string `json:"path"`
	Head              string `json:"head"`
	Branch            string `json:"branch"`
	Detached          bool   `json:"detached"`
	Bare              bool   `json:"bare"`
	MetadataTruncated bool   `json:"metadataTruncated"`
}

GitWorktree is bounded metadata for one repository worktree. Desktop main owns the path and may project an opaque identifier to the renderer.

type GitWorktreeListResponse added in v0.8.0 

type GitWorktreeListResponse struct {
	Worktrees  []GitWorktree `json:"worktrees" jsonschema:"nonnullable=true"`
	Total      int           `json:"total"`
	Truncated  bool          `json:"truncated"`
	SnapshotID string        `json:"snapshotId"`
	NextCursor string        `json:"nextCursor,omitempty"`
	ObservedAt time.Time     `json:"observedAt"`
}

type GrantedPermissionProfile 

type GrantedPermissionProfile struct {
	Network    *AdditionalNetworkPermissions    `json:"network,omitempty" jsonschema:"nonnullable=true"`
	FileSystem *AdditionalFileSystemPermissions `json:"fileSystem,omitempty" jsonschema:"nonnullable=true"`
}

func (*GrantedPermissionProfile) UnmarshalJSON 

func (p *GrantedPermissionProfile) UnmarshalJSON(data []byte) error

type GuardianApprovalReview 

type GuardianApprovalReview struct {
	Status            GuardianApprovalReviewStatus `json:"status"`
	RiskLevel         *GuardianRiskLevel           `json:"riskLevel"`
	UserAuthorization *GuardianUserAuthorization   `json:"userAuthorization"`
	Rationale         *string                      `json:"rationale"`
}

GuardianApprovalReview is the exact unstable public result of one approval auto-review. It is descriptive and does not perform or authorize a review.

func (GuardianApprovalReview) MarshalJSON 

func (r GuardianApprovalReview) MarshalJSON() ([]byte, error)

func (*GuardianApprovalReview) UnmarshalJSON 

func (r *GuardianApprovalReview) UnmarshalJSON(data []byte) error

type GuardianApprovalReviewAction 

type GuardianApprovalReviewAction struct {
	// contains filtered or unexported fields
}

GuardianApprovalReviewAction is the exact unstable public description of an action under approval review. It does not execute or authorize the action.

func (GuardianApprovalReviewAction) MarshalJSON 

func (a GuardianApprovalReviewAction) MarshalJSON() ([]byte, error)

func (GuardianApprovalReviewAction) Type 

func (a GuardianApprovalReviewAction) Type() string

Type returns the exact public action discriminant.

func (*GuardianApprovalReviewAction) UnmarshalJSON 

func (a *GuardianApprovalReviewAction) UnmarshalJSON(data []byte) error

type GuardianApprovalReviewStatus 

type GuardianApprovalReviewStatus string

GuardianApprovalReviewStatus is the exact closed public lifecycle state for an approval auto-review. It does not imply a live Guardian review producer. 

const (
	GuardianApprovalReviewStatusInProgress GuardianApprovalReviewStatus = "inProgress"
	GuardianApprovalReviewStatusApproved   GuardianApprovalReviewStatus = "approved"
	GuardianApprovalReviewStatusDenied     GuardianApprovalReviewStatus = "denied"
	GuardianApprovalReviewStatusTimedOut   GuardianApprovalReviewStatus = "timedOut"
	GuardianApprovalReviewStatusAborted    GuardianApprovalReviewStatus = "aborted"
)

func (GuardianApprovalReviewStatus) MarshalJSON 

func (s GuardianApprovalReviewStatus) MarshalJSON() ([]byte, error)

func (*GuardianApprovalReviewStatus) UnmarshalJSON 

func (s *GuardianApprovalReviewStatus) UnmarshalJSON(data []byte) error

type GuardianCommandSource 

type GuardianCommandSource string

GuardianCommandSource is the exact closed public source of a command under Guardian review. It does not grant command execution authority. 

const (
	GuardianCommandSourceShell       GuardianCommandSource = "shell"
	GuardianCommandSourceUnifiedExec GuardianCommandSource = "unifiedExec"
)

func (GuardianCommandSource) MarshalJSON 

func (s GuardianCommandSource) MarshalJSON() ([]byte, error)

func (*GuardianCommandSource) UnmarshalJSON 

func (s *GuardianCommandSource) UnmarshalJSON(data []byte) error

type GuardianRiskLevel 

type GuardianRiskLevel string

GuardianRiskLevel is the exact closed public risk classification assigned by an approval auto-review. It does not perform or authorize risk assessment. 

const (
	GuardianRiskLevelLow      GuardianRiskLevel = "low"
	GuardianRiskLevelMedium   GuardianRiskLevel = "medium"
	GuardianRiskLevelHigh     GuardianRiskLevel = "high"
	GuardianRiskLevelCritical GuardianRiskLevel = "critical"
)

func (GuardianRiskLevel) MarshalJSON 

func (l GuardianRiskLevel) MarshalJSON() ([]byte, error)

func (*GuardianRiskLevel) UnmarshalJSON 

func (l *GuardianRiskLevel) UnmarshalJSON(data []byte) error

type GuardianUserAuthorization 

type GuardianUserAuthorization string

GuardianUserAuthorization is the exact closed public user-authorization classification. It does not infer or grant user authorization. 

const (
	GuardianUserAuthorizationUnknown GuardianUserAuthorization = "unknown"
	GuardianUserAuthorizationLow     GuardianUserAuthorization = "low"
	GuardianUserAuthorizationMedium  GuardianUserAuthorization = "medium"
	GuardianUserAuthorizationHigh    GuardianUserAuthorization = "high"
)

func (GuardianUserAuthorization) MarshalJSON 

func (a GuardianUserAuthorization) MarshalJSON() ([]byte, error)

func (*GuardianUserAuthorization) UnmarshalJSON 

func (a *GuardianUserAuthorization) UnmarshalJSON(data []byte) error

type GuardianWarningNotification 

type GuardianWarningNotification struct {
	ThreadID string `json:"threadId"`
	Message  string `json:"message"`
}

GuardianWarningNotification is the exact fixed public guardian warning value. It remains standalone until Gollem has an exact live producer.

func (*GuardianWarningNotification) UnmarshalJSON 

func (n *GuardianWarningNotification) UnmarshalJSON(data []byte) error

type HookCompletedNotification 

type HookCompletedNotification struct {
	ThreadID string         `json:"threadId"`
	TurnID   *string        `json:"turnId"`
	Run      HookRunSummary `json:"run"`
}

HookCompletedNotification is the exact standalone public hook-completion payload.

func (HookCompletedNotification) MarshalJSON 

func (n HookCompletedNotification) MarshalJSON() ([]byte, error)

func (*HookCompletedNotification) UnmarshalJSON 

func (n *HookCompletedNotification) UnmarshalJSON(data []byte) error

type HookErrorInfo 

type HookErrorInfo struct {
	Path    string `json:"path"`
	Message string `json:"message"`
}

HookErrorInfo is one descriptive hook-discovery error. It does not imply that Gollem scans hook files.

func (HookErrorInfo) MarshalJSON 

func (e HookErrorInfo) MarshalJSON() ([]byte, error)

func (*HookErrorInfo) UnmarshalJSON 

func (e *HookErrorInfo) UnmarshalJSON(data []byte) error

type HookEventName 

type HookEventName string

HookEventName is the exact closed public hook lifecycle event name. It does not imply that Gollem discovers or executes hooks. 

const (
	HookEventNamePreToolUse        HookEventName = "preToolUse"
	HookEventNamePermissionRequest HookEventName = "permissionRequest"
	HookEventNamePostToolUse       HookEventName = "postToolUse"
	HookEventNamePreCompact        HookEventName = "preCompact"
	HookEventNamePostCompact       HookEventName = "postCompact"
	HookEventNameSessionStart      HookEventName = "sessionStart"
	HookEventNameUserPromptSubmit  HookEventName = "userPromptSubmit"
	HookEventNameSubagentStart     HookEventName = "subagentStart"
	HookEventNameSubagentStop      HookEventName = "subagentStop"
	HookEventNameStop              HookEventName = "stop"
)

func (HookEventName) MarshalJSON 

func (n HookEventName) MarshalJSON() ([]byte, error)

func (*HookEventName) UnmarshalJSON 

func (n *HookEventName) UnmarshalJSON(data []byte) error

type HookExecutionMode 

type HookExecutionMode string

HookExecutionMode is the exact closed public hook execution mode. 

const (
	HookExecutionModeSync  HookExecutionMode = "sync"
	HookExecutionModeAsync HookExecutionMode = "async"
)

func (HookExecutionMode) MarshalJSON 

func (m HookExecutionMode) MarshalJSON() ([]byte, error)

func (*HookExecutionMode) UnmarshalJSON 

func (m *HookExecutionMode) UnmarshalJSON(data []byte) error

type HookHandlerType 

type HookHandlerType string

HookHandlerType is the exact closed public hook handler type. 

const (
	HookHandlerTypeCommand HookHandlerType = "command"
	HookHandlerTypePrompt  HookHandlerType = "prompt"
	HookHandlerTypeAgent   HookHandlerType = "agent"
)

func (HookHandlerType) MarshalJSON 

func (h HookHandlerType) MarshalJSON() ([]byte, error)

func (*HookHandlerType) UnmarshalJSON 

func (h *HookHandlerType) UnmarshalJSON(data []byte) error

type HookMetadata 

type HookMetadata struct {
	Key           string          `json:"key"`
	EventName     HookEventName   `json:"eventName"`
	HandlerType   HookHandlerType `json:"handlerType"`
	Matcher       *string         `json:"matcher"`
	Command       *string         `json:"command"`
	TimeoutSec    uint64          `json:"timeoutSec"`
	StatusMessage *string         `json:"statusMessage"`
	SourcePath    AbsolutePathBuf `json:"sourcePath"`
	Source        HookSource      `json:"source"`
	PluginID      *string         `json:"pluginId"`
	DisplayOrder  int64           `json:"displayOrder"`
	Enabled       bool            `json:"enabled"`
	IsManaged     bool            `json:"isManaged"`
	CurrentHash   string          `json:"currentHash"`
	TrustStatus   HookTrustStatus `json:"trustStatus"`
}

HookMetadata is exact standalone public metadata for one configured hook. Its fields are descriptive and do not grant trust or execution authority.

func (HookMetadata) MarshalJSON 

func (m HookMetadata) MarshalJSON() ([]byte, error)

func (*HookMetadata) UnmarshalJSON 

func (m *HookMetadata) UnmarshalJSON(data []byte) error

type HookMigration 

type HookMigration struct {
	Name string `json:"name"`
}

HookMigration identifies one hook configuration migration. It remains standalone until the external-agent migration contracts land.

func (*HookMigration) UnmarshalJSON 

func (m *HookMigration) UnmarshalJSON(data []byte) error

type HookOutputEntry 

type HookOutputEntry struct {
	Kind HookOutputEntryKind `json:"kind"`
	Text string              `json:"text"`
}

HookOutputEntry is one exact standalone descriptive hook output value.

func (HookOutputEntry) MarshalJSON 

func (e HookOutputEntry) MarshalJSON() ([]byte, error)

func (*HookOutputEntry) UnmarshalJSON 

func (e *HookOutputEntry) UnmarshalJSON(data []byte) error

type HookOutputEntryKind 

type HookOutputEntryKind string

HookOutputEntryKind is the exact closed public hook output category. 

const (
	HookOutputEntryKindWarning  HookOutputEntryKind = "warning"
	HookOutputEntryKindStop     HookOutputEntryKind = "stop"
	HookOutputEntryKindFeedback HookOutputEntryKind = "feedback"
	HookOutputEntryKindContext  HookOutputEntryKind = "context"
	HookOutputEntryKindError    HookOutputEntryKind = "error"
)

func (HookOutputEntryKind) MarshalJSON 

func (k HookOutputEntryKind) MarshalJSON() ([]byte, error)

func (*HookOutputEntryKind) UnmarshalJSON 

func (k *HookOutputEntryKind) UnmarshalJSON(data []byte) error

type HookPromptFragment 

type HookPromptFragment struct {
	Text      string `json:"text"`
	HookRunID string `json:"hookRunId"`
}

func (*HookPromptFragment) UnmarshalJSON 

func (f *HookPromptFragment) UnmarshalJSON(data []byte) error

type HookRunStatus 

type HookRunStatus string

HookRunStatus is the exact closed public hook run status. 

const (
	HookRunStatusRunning   HookRunStatus = "running"
	HookRunStatusCompleted HookRunStatus = "completed"
	HookRunStatusFailed    HookRunStatus = "failed"
	HookRunStatusBlocked   HookRunStatus = "blocked"
	HookRunStatusStopped   HookRunStatus = "stopped"
)

func (HookRunStatus) MarshalJSON 

func (s HookRunStatus) MarshalJSON() ([]byte, error)

func (*HookRunStatus) UnmarshalJSON 

func (s *HookRunStatus) UnmarshalJSON(data []byte) error

type HookRunSummary 

type HookRunSummary struct {
	ID            string            `json:"id"`
	EventName     HookEventName     `json:"eventName"`
	HandlerType   HookHandlerType   `json:"handlerType"`
	ExecutionMode HookExecutionMode `json:"executionMode"`
	Scope         HookScope         `json:"scope"`
	SourcePath    AbsolutePathBuf   `json:"sourcePath"`
	Source        HookSource        `json:"source"`
	DisplayOrder  int64             `json:"displayOrder"`
	Status        HookRunStatus     `json:"status"`
	StatusMessage *string           `json:"statusMessage"`
	StartedAt     int64             `json:"startedAt"`
	CompletedAt   *int64            `json:"completedAt"`
	DurationMS    *int64            `json:"durationMs"`
	Entries       []HookOutputEntry `json:"entries"`
}

HookRunSummary is the exact standalone public summary of one hook run. It does not imply that Gollem discovers or executes hooks.

func (HookRunSummary) MarshalJSON 

func (s HookRunSummary) MarshalJSON() ([]byte, error)

func (*HookRunSummary) UnmarshalJSON 

func (s *HookRunSummary) UnmarshalJSON(data []byte) error

type HookScope 

type HookScope string

HookScope is the exact closed public hook run ownership scope. 

const (
	HookScopeThread HookScope = "thread"
	HookScopeTurn   HookScope = "turn"
)

func (HookScope) MarshalJSON 

func (s HookScope) MarshalJSON() ([]byte, error)

func (*HookScope) UnmarshalJSON 

func (s *HookScope) UnmarshalJSON(data []byte) error

type HookSource 

type HookSource string

HookSource is the exact closed public source classification for hook data. A value carries no path, trust, loading, or execution authority. 

const (
	HookSourceSystem                  HookSource = "system"
	HookSourceUser                    HookSource = "user"
	HookSourceProject                 HookSource = "project"
	HookSourceMDM                     HookSource = "mdm"
	HookSourceSessionFlags            HookSource = "sessionFlags"
	HookSourcePlugin                  HookSource = "plugin"
	HookSourceCloudRequirements       HookSource = "cloudRequirements"
	HookSourceCloudManagedConfig      HookSource = "cloudManagedConfig"
	HookSourceLegacyManagedConfigFile HookSource = "legacyManagedConfigFile"
	HookSourceLegacyManagedConfigMDM  HookSource = "legacyManagedConfigMdm"
	HookSourceUnknown                 HookSource = "unknown"
)

func (HookSource) MarshalJSON 

func (s HookSource) MarshalJSON() ([]byte, error)

func (*HookSource) UnmarshalJSON 

func (s *HookSource) UnmarshalJSON(data []byte) error

type HookStartedNotification 

type HookStartedNotification struct {
	ThreadID string         `json:"threadId"`
	TurnID   *string        `json:"turnId"`
	Run      HookRunSummary `json:"run"`
}

HookStartedNotification is the exact standalone public hook-start payload.

func (HookStartedNotification) MarshalJSON 

func (n HookStartedNotification) MarshalJSON() ([]byte, error)

func (*HookStartedNotification) UnmarshalJSON 

func (n *HookStartedNotification) UnmarshalJSON(data []byte) error

type HookTrustStatus 

type HookTrustStatus string

HookTrustStatus is the exact closed public hook trust classification. It is descriptive only and does not grant execution authority. 

const (
	HookTrustStatusManaged   HookTrustStatus = "managed"
	HookTrustStatusUntrusted HookTrustStatus = "untrusted"
	HookTrustStatusTrusted   HookTrustStatus = "trusted"
	HookTrustStatusModified  HookTrustStatus = "modified"
)

func (HookTrustStatus) MarshalJSON 

func (s HookTrustStatus) MarshalJSON() ([]byte, error)

func (*HookTrustStatus) UnmarshalJSON 

func (s *HookTrustStatus) UnmarshalJSON(data []byte) error

type HooksListEntry 

type HooksListEntry struct {
	CWD      string          `json:"cwd"`
	Hooks    []HookMetadata  `json:"hooks"`
	Warnings []string        `json:"warnings"`
	Errors   []HookErrorInfo `json:"errors"`
}

HooksListEntry is exact standalone hook metadata and diagnostics for one cwd.

func (HooksListEntry) MarshalJSON 

func (e HooksListEntry) MarshalJSON() ([]byte, error)

func (*HooksListEntry) UnmarshalJSON 

func (e *HooksListEntry) UnmarshalJSON(data []byte) error

type HooksListParams 

type HooksListParams struct {
	CWDs []string `json:"cwds,omitempty"`
}

HooksListParams is the exact standalone public request shape. Gollem does not bind it to hooks/list or interpret its working directories.

func (HooksListParams) MarshalJSON 

func (p HooksListParams) MarshalJSON() ([]byte, error)

func (*HooksListParams) UnmarshalJSON 

func (p *HooksListParams) UnmarshalJSON(data []byte) error

type HooksListResponse 

type HooksListResponse struct {
	Data []HooksListEntry `json:"data"`
}

HooksListResponse is the exact standalone public hook-list envelope.

func (HooksListResponse) MarshalJSON 

func (r HooksListResponse) MarshalJSON() ([]byte, error)

func (*HooksListResponse) UnmarshalJSON 

func (r *HooksListResponse) UnmarshalJSON(data []byte) error

type ImageDetail 

type ImageDetail string
const (
	ImageDetailAuto     ImageDetail = "auto"
	ImageDetailLow      ImageDetail = "low"
	ImageDetailHigh     ImageDetail = "high"
	ImageDetailOriginal ImageDetail = "original"
)

func (ImageDetail) MarshalJSON 

func (d ImageDetail) MarshalJSON() ([]byte, error)

func (*ImageDetail) UnmarshalJSON 

func (d *ImageDetail) UnmarshalJSON(data []byte) error

type ImageGenerationItem 

type ImageGenerationItem struct {
	ID            string           `json:"id"`
	Status        string           `json:"status"`
	RevisedPrompt *string          `json:"revisedPrompt"`
	Result        string           `json:"result"`
	SavedPath     *AbsolutePathBuf `json:"savedPath,omitempty" jsonschema:"nonnullable=true"`
}

func (*ImageGenerationItem) UnmarshalJSON 

func (i *ImageGenerationItem) UnmarshalJSON(data []byte) error

type ImplementationInfo 

type ImplementationInfo struct {
	Name    string `json:"name"`
	Version string `json:"version,omitempty"`
}

ImplementationInfo identifies the app-server implementation.

type InitializeCapabilities 

type InitializeCapabilities struct {
	ExperimentalAPI                bool            `json:"experimentalApi,omitempty"`
	RequestAttestation             bool            `json:"requestAttestation,omitempty"`
	MCPServerOpenAIFormElicitation bool            `json:"mcpServerOpenaiFormElicitation,omitempty"`
	OptOutNotificationMethods      []string        `json:"optOutNotificationMethods,omitempty"`
	Experimental                   map[string]bool `json:"experimental,omitempty"`
}

InitializeCapabilities are client-advertised connection capabilities.

type InitializeParams 

type InitializeParams struct {
	ClientInfo   ClientInfo              `json:"clientInfo"`
	Capabilities *InitializeCapabilities `json:"capabilities,omitempty"`
}

InitializeParams is sent by the client as the first request on a connection.

type InitializeResponse 

type InitializeResponse struct {
	UserAgent       string             `json:"userAgent"`
	CodexHome       string             `json:"codexHome"`
	PlatformFamily  string             `json:"platformFamily"`
	PlatformOS      string             `json:"platformOs"`
	ProtocolVersion string             `json:"protocolVersion"`
	ServerInfo      ImplementationInfo `json:"serverInfo"`
	Capabilities    ServerCapabilities `json:"capabilities"`
	Methods         []MethodInfo       `json:"methods,omitempty"`
}

InitializeResponse is returned after a successful initialize request.

func DefaultInitializeResponse 

func DefaultInitializeResponse(server ImplementationInfo, appHome string) InitializeResponse

DefaultInitializeResponse returns the Codex-compatible server identity plus Gollem protocol capabilities and method metadata.

type InputModality 

type InputModality string

InputModality is the exact closed public model input-modality value. 

const (
	InputModalityText  InputModality = "text"
	InputModalityImage InputModality = "image"
)

func (InputModality) MarshalJSON 

func (m InputModality) MarshalJSON() ([]byte, error)

func (*InputModality) UnmarshalJSON 

func (m *InputModality) UnmarshalJSON(data []byte) error

type InternalChatMessageMetadataPassthrough 

type InternalChatMessageMetadataPassthrough struct {
	TurnID *string `json:"turn_id,omitempty"`
}

func (InternalChatMessageMetadataPassthrough) MarshalJSON 

func (m InternalChatMessageMetadataPassthrough) MarshalJSON() ([]byte, error)

func (*InternalChatMessageMetadataPassthrough) UnmarshalJSON 

func (m *InternalChatMessageMetadataPassthrough) UnmarshalJSON(data []byte) error

type ItemCompletedNotification 

type ItemCompletedNotification struct {
	Item          ThreadItem `json:"item"`
	ThreadID      string     `json:"threadId"`
	TurnID        string     `json:"turnId"`
	CompletedAtMS int64      `json:"completedAtMs"`
}

ItemCompletedNotification is the exact public lifecycle-completion payload.

func (ItemCompletedNotification) MarshalJSON 

func (n ItemCompletedNotification) MarshalJSON() ([]byte, error)

func (*ItemCompletedNotification) UnmarshalJSON 

func (n *ItemCompletedNotification) UnmarshalJSON(data []byte) error

type ItemGuardianApprovalReviewCompletedNotification 

type ItemGuardianApprovalReviewCompletedNotification struct {
	ThreadID       string                       `json:"threadId"`
	TurnID         string                       `json:"turnId"`
	StartedAtMS    int64                        `json:"startedAtMs"`
	CompletedAtMS  int64                        `json:"completedAtMs"`
	ReviewID       string                       `json:"reviewId"`
	TargetItemID   *string                      `json:"targetItemId"`
	DecisionSource AutoReviewDecisionSource     `json:"decisionSource"`
	Review         GuardianApprovalReview       `json:"review"`
	Action         GuardianApprovalReviewAction `json:"action"`
}

ItemGuardianApprovalReviewCompletedNotification is the exact unstable public description of a Guardian review completion. It does not produce or authorize a review.

func (ItemGuardianApprovalReviewCompletedNotification) MarshalJSON 

func (n ItemGuardianApprovalReviewCompletedNotification) MarshalJSON() ([]byte, error)

func (*ItemGuardianApprovalReviewCompletedNotification) UnmarshalJSON 

func (n *ItemGuardianApprovalReviewCompletedNotification) UnmarshalJSON(data []byte) error

type ItemGuardianApprovalReviewStartedNotification 

type ItemGuardianApprovalReviewStartedNotification struct {
	ThreadID     string                       `json:"threadId"`
	TurnID       string                       `json:"turnId"`
	StartedAtMS  int64                        `json:"startedAtMs"`
	ReviewID     string                       `json:"reviewId"`
	TargetItemID *string                      `json:"targetItemId"`
	Review       GuardianApprovalReview       `json:"review"`
	Action       GuardianApprovalReviewAction `json:"action"`
}

ItemGuardianApprovalReviewStartedNotification is the exact unstable public description of a Guardian review start. It does not produce or authorize a review.

func (ItemGuardianApprovalReviewStartedNotification) MarshalJSON 

func (n ItemGuardianApprovalReviewStartedNotification) MarshalJSON() ([]byte, error)

func (*ItemGuardianApprovalReviewStartedNotification) UnmarshalJSON 

func (n *ItemGuardianApprovalReviewStartedNotification) UnmarshalJSON(data []byte) error

type ItemLifecycleNotificationParams 

type ItemLifecycleNotificationParams struct {
	ThreadID string        `json:"threadId"`
	TurnID   string        `json:"turnId,omitempty"`
	ItemID   string        `json:"itemId,omitempty"`
	Item     *TimelineItem `json:"item,omitempty"`
	At       time.Time     `json:"at"`
}

type ItemPayloadBinding 

type ItemPayloadBinding struct {
	Kind string `json:"kind"`
	Type string `json:"type"`
}

ItemPayloadBinding maps a durable timeline item kind to the exported type carried in TimelineItem.Payload.

func ItemPayloadBindings 

func ItemPayloadBindings() []ItemPayloadBinding

ItemPayloadBindings returns a stable copy of the known durable runtime item payload mappings.

type ItemStartedNotification 

type ItemStartedNotification struct {
	Item        ThreadItem `json:"item"`
	ThreadID    string     `json:"threadId"`
	TurnID      string     `json:"turnId"`
	StartedAtMS int64      `json:"startedAtMs"`
}

ItemStartedNotification is the exact public lifecycle-start payload. Gollem's existing runtime-specific payloads remain separate compatibility variants.

func (ItemStartedNotification) MarshalJSON 

func (n ItemStartedNotification) MarshalJSON() ([]byte, error)

func (*ItemStartedNotification) UnmarshalJSON 

func (n *ItemStartedNotification) UnmarshalJSON(data []byte) error

type JsonValue 

type JsonValue struct {
	// contains filtered or unexported fields
}

JsonValue retains one precision-preserving JSON value.

func (JsonValue) MarshalJSON 

func (v JsonValue) MarshalJSON() ([]byte, error)

func (*JsonValue) UnmarshalJSON 

func (v *JsonValue) UnmarshalJSON(data []byte) error

type LegacyAppPathString 

type LegacyAppPathString string

LegacyAppPathString preserves the public app-server's unrestricted UTF-8 path string while callers migrate to explicit path conventions.

type ListMcpServerStatusParams 

type ListMcpServerStatusParams struct {
	Cursor   *string                `json:"cursor,omitempty"`
	Limit    *uint32                `json:"limit,omitempty"`
	Detail   *McpServerStatusDetail `json:"detail,omitempty"`
	ThreadID *string                `json:"threadId,omitempty"`
}

ListMcpServerStatusParams is the exact public MCP inventory page selector. It remains separate from the live server-filter request until an adapter is defined.

func (ListMcpServerStatusParams) MarshalJSON 

func (p ListMcpServerStatusParams) MarshalJSON() ([]byte, error)

func (*ListMcpServerStatusParams) UnmarshalJSON 

func (p *ListMcpServerStatusParams) UnmarshalJSON(data []byte) error

type ListMcpServerStatusResponse 

type ListMcpServerStatusResponse struct {
	Data       []McpServerStatus `json:"data" jsonschema:"nonnullable=true"`
	NextCursor *string           `json:"nextCursor"`
}

ListMcpServerStatusResponse is one exact public MCP inventory page.

func (ListMcpServerStatusResponse) MarshalJSON 

func (r ListMcpServerStatusResponse) MarshalJSON() ([]byte, error)

func (*ListMcpServerStatusResponse) UnmarshalJSON 

func (r *ListMcpServerStatusResponse) UnmarshalJSON(data []byte) error

type LocalShellAction 

type LocalShellAction struct {
	// contains filtered or unexported fields
}

func (LocalShellAction) MarshalJSON 

func (a LocalShellAction) MarshalJSON() ([]byte, error)

func (*LocalShellAction) UnmarshalJSON 

func (a *LocalShellAction) UnmarshalJSON(data []byte) error

type LocalShellStatus 

type LocalShellStatus string
const (
	LocalShellStatusCompleted  LocalShellStatus = "completed"
	LocalShellStatusInProgress LocalShellStatus = "in_progress"
	LocalShellStatusIncomplete LocalShellStatus = "incomplete"
)

func (LocalShellStatus) MarshalJSON 

func (s LocalShellStatus) MarshalJSON() ([]byte, error)

func (*LocalShellStatus) UnmarshalJSON 

func (s *LocalShellStatus) UnmarshalJSON(data []byte) error

type LoginAccountParams 

type LoginAccountParams struct {
	// contains filtered or unexported fields
}

LoginAccountParams is the exact public login-start request union. It remains standalone until Gollem implements the account/login/start method itself.

func (LoginAccountParams) MarshalJSON 

func (p LoginAccountParams) MarshalJSON() ([]byte, error)

func (LoginAccountParams) Type 

func (p LoginAccountParams) Type() string

Type returns the request union's public discriminant, or an empty string for an uninitialized or invalid internal value.

func (*LoginAccountParams) UnmarshalJSON 

func (p *LoginAccountParams) UnmarshalJSON(data []byte) error

type LoginAccountResponse 

type LoginAccountResponse struct {
	// contains filtered or unexported fields
}

LoginAccountResponse is the exact public login-start response union. It remains standalone from Gollem's account and credential runtime.

func (LoginAccountResponse) MarshalJSON 

func (r LoginAccountResponse) MarshalJSON() ([]byte, error)

func (LoginAccountResponse) Type 

func (r LoginAccountResponse) Type() string

Type returns the response union's public discriminant, or an empty string for an uninitialized or invalid internal value.

func (*LoginAccountResponse) UnmarshalJSON 

func (r *LoginAccountResponse) UnmarshalJSON(data []byte) error

type LoginAppBrand 

type LoginAppBrand string

LoginAppBrand is the exact closed public brand for ChatGPT login UI. It is standalone from Gollem's account, credential, provider, and browser runtime. 

const (
	LoginAppBrandCodex   LoginAppBrand = "codex"
	LoginAppBrandChatGPT LoginAppBrand = "chatgpt"

	LoginAppBrandDefault = LoginAppBrandCodex
)

func (LoginAppBrand) MarshalJSON 

func (b LoginAppBrand) MarshalJSON() ([]byte, error)

func (*LoginAppBrand) UnmarshalJSON 

func (b *LoginAppBrand) UnmarshalJSON(data []byte) error

type LogoutAccountResponse 

type LogoutAccountResponse struct{}

LogoutAccountResponse is the exact empty public logout response. It remains standalone until Gollem implements account state and logout behavior.

func (*LogoutAccountResponse) UnmarshalJSON 

func (r *LogoutAccountResponse) UnmarshalJSON(data []byte) error

type MCPContent 

type MCPContent struct {
	Type string `json:"type"`
	Text string `json:"text,omitempty"`
}

type MCPToolCallError 

type MCPToolCallError = McpToolCallError

type MCPToolCallItem 

type MCPToolCallItem struct {
	Type              string             `json:"type" jsonschema:"enum=mcpToolCall"`
	ID                string             `json:"id,omitempty"`
	Server            string             `json:"server"`
	Tool              string             `json:"tool"`
	Status            string             `json:"status" jsonschema:"enum=inProgress|completed|failed"`
	Arguments         any                `json:"arguments"`
	AppContext        any                `json:"appContext"`
	MCPAppResourceURI *string            `json:"mcpAppResourceUri"`
	PluginID          *string            `json:"pluginId"`
	Result            *MCPToolCallResult `json:"result"`
	Error             *McpToolCallError  `json:"error"`
	DurationMS        *int64             `json:"durationMs"`
}

type MCPToolCallItemCompletedNotificationParams 

type MCPToolCallItemCompletedNotificationParams struct {
	Item          MCPToolCallItem `json:"item"`
	ThreadID      string          `json:"threadId"`
	TurnID        string          `json:"turnId"`
	CompletedAtMS int64           `json:"completedAtMs"`
}

type MCPToolCallItemStartedNotificationParams 

type MCPToolCallItemStartedNotificationParams struct {
	Item        MCPToolCallItem `json:"item"`
	ThreadID    string          `json:"threadId"`
	TurnID      string          `json:"turnId"`
	StartedAtMS int64           `json:"startedAtMs"`
}

type MCPToolCallProgressNotificationParams 

type MCPToolCallProgressNotificationParams = McpToolCallProgressNotification

type MCPToolCallResult 

type MCPToolCallResult struct {
	Content           []MCPContent `json:"content"`
	StructuredContent any          `json:"structuredContent"`
	Meta              any          `json:"_meta"`
}

type ManagedHooksRequirements 

type ManagedHooksRequirements struct {
	ManagedDir        *string                      `json:"managedDir"`
	WindowsManagedDir *string                      `json:"windowsManagedDir"`
	PreToolUse        []ConfiguredHookMatcherGroup `json:"PreToolUse" jsonschema:"nonnullable=true"`
	PermissionRequest []ConfiguredHookMatcherGroup `json:"PermissionRequest" jsonschema:"nonnullable=true"`
	PostToolUse       []ConfiguredHookMatcherGroup `json:"PostToolUse" jsonschema:"nonnullable=true"`
	PreCompact        []ConfiguredHookMatcherGroup `json:"PreCompact" jsonschema:"nonnullable=true"`
	PostCompact       []ConfiguredHookMatcherGroup `json:"PostCompact" jsonschema:"nonnullable=true"`
	SessionStart      []ConfiguredHookMatcherGroup `json:"SessionStart" jsonschema:"nonnullable=true"`
	UserPromptSubmit  []ConfiguredHookMatcherGroup `json:"UserPromptSubmit" jsonschema:"nonnullable=true"`
	SubagentStart     []ConfiguredHookMatcherGroup `json:"SubagentStart" jsonschema:"nonnullable=true"`
	SubagentStop      []ConfiguredHookMatcherGroup `json:"SubagentStop" jsonschema:"nonnullable=true"`
	Stop              []ConfiguredHookMatcherGroup `json:"Stop" jsonschema:"nonnullable=true"`
}

ManagedHooksRequirements is the exact standalone public managed-hook requirements value. It does not imply runtime hook execution or enforcement.

func (ManagedHooksRequirements) MarshalJSON 

func (r ManagedHooksRequirements) MarshalJSON() ([]byte, error)

func (*ManagedHooksRequirements) UnmarshalJSON 

func (r *ManagedHooksRequirements) UnmarshalJSON(data []byte) error

type McpAuthStatus 

type McpAuthStatus string

McpAuthStatus is the exact closed public MCP authentication status. It is standalone from Gollem's broader MCP status wire and authentication runtime. 

const (
	McpAuthStatusUnsupported McpAuthStatus = "unsupported"
	McpAuthStatusNotLoggedIn McpAuthStatus = "notLoggedIn"
	McpAuthStatusBearerToken McpAuthStatus = "bearerToken"
	McpAuthStatusOAuth       McpAuthStatus = "oAuth"
)

func (McpAuthStatus) MarshalJSON 

func (s McpAuthStatus) MarshalJSON() ([]byte, error)

func (*McpAuthStatus) UnmarshalJSON 

func (s *McpAuthStatus) UnmarshalJSON(data []byte) error

type McpElicitationArrayType 

type McpElicitationArrayType string
const McpElicitationArray McpElicitationArrayType = "array"

type McpElicitationBooleanSchema 

type McpElicitationBooleanSchema struct {
	Type        McpElicitationBooleanType `json:"type"`
	Title       *string                   `json:"title,omitempty" jsonschema:"nonnullable=true"`
	Description *string                   `json:"description,omitempty" jsonschema:"nonnullable=true"`
	Default     *bool                     `json:"default,omitempty" jsonschema:"nonnullable=true"`
}

type McpElicitationBooleanType 

type McpElicitationBooleanType string
const McpElicitationBoolean McpElicitationBooleanType = "boolean"

type McpElicitationConstOption 

type McpElicitationConstOption struct {
	Const string `json:"const"`
	Title string `json:"title"`
}

type McpElicitationEnumSchema 

type McpElicitationEnumSchema struct {
	// contains filtered or unexported fields
}

func (McpElicitationEnumSchema) MarshalJSON 

func (s McpElicitationEnumSchema) MarshalJSON() ([]byte, error)

func (*McpElicitationEnumSchema) UnmarshalJSON 

func (s *McpElicitationEnumSchema) UnmarshalJSON(data []byte) error

type McpElicitationLegacyTitledEnumSchema 

type McpElicitationLegacyTitledEnumSchema struct {
	Type        McpElicitationStringType `json:"type"`
	Title       *string                  `json:"title,omitempty" jsonschema:"nonnullable=true"`
	Description *string                  `json:"description,omitempty" jsonschema:"nonnullable=true"`
	Enum        []string                 `json:"enum" jsonschema:"nonnullable=true"`
	EnumNames   []string                 `json:"enumNames,omitempty" jsonschema:"nonnullable=true"`
	Default     *string                  `json:"default,omitempty" jsonschema:"nonnullable=true"`
}

type McpElicitationMultiSelectEnumSchema 

type McpElicitationMultiSelectEnumSchema struct {
	// contains filtered or unexported fields
}

func (McpElicitationMultiSelectEnumSchema) MarshalJSON 

func (s McpElicitationMultiSelectEnumSchema) MarshalJSON() ([]byte, error)

func (*McpElicitationMultiSelectEnumSchema) UnmarshalJSON 

func (s *McpElicitationMultiSelectEnumSchema) UnmarshalJSON(data []byte) error

type McpElicitationNumberSchema 

type McpElicitationNumberSchema struct {
	Type        McpElicitationNumberType `json:"type"`
	Title       *string                  `json:"title,omitempty" jsonschema:"nonnullable=true"`
	Description *string                  `json:"description,omitempty" jsonschema:"nonnullable=true"`
	Minimum     *float64                 `json:"minimum,omitempty" jsonschema:"nonnullable=true"`
	Maximum     *float64                 `json:"maximum,omitempty" jsonschema:"nonnullable=true"`
	Default     *float64                 `json:"default,omitempty" jsonschema:"nonnullable=true"`
}

type McpElicitationNumberType 

type McpElicitationNumberType string
const (
	McpElicitationNumber  McpElicitationNumberType = "number"
	McpElicitationInteger McpElicitationNumberType = "integer"
)

type McpElicitationObjectType 

type McpElicitationObjectType string
const McpElicitationObject McpElicitationObjectType = "object"

type McpElicitationPrimitiveSchema 

type McpElicitationPrimitiveSchema struct {
	// contains filtered or unexported fields
}

The public elicitation schema contains nested untagged unions. These wrapper types retain their validated JSON so generated clients receive exact unions without exposing a misleading flattened Go shape.

func (McpElicitationPrimitiveSchema) MarshalJSON 

func (s McpElicitationPrimitiveSchema) MarshalJSON() ([]byte, error)

func (*McpElicitationPrimitiveSchema) UnmarshalJSON 

func (s *McpElicitationPrimitiveSchema) UnmarshalJSON(data []byte) error

type McpElicitationSchema 

type McpElicitationSchema struct {
	SchemaURI  *string                                  `json:"$schema,omitempty" jsonschema:"nonnullable=true"`
	Type       McpElicitationObjectType                 `json:"type"`
	Properties map[string]McpElicitationPrimitiveSchema `json:"properties" jsonschema:"nonnullable=true"`
	Required   []string                                 `json:"required,omitempty" jsonschema:"nonnullable=true"`
}

func (McpElicitationSchema) MarshalJSON 

func (s McpElicitationSchema) MarshalJSON() ([]byte, error)

func (*McpElicitationSchema) UnmarshalJSON 

func (s *McpElicitationSchema) UnmarshalJSON(data []byte) error

type McpElicitationSingleSelectEnumSchema 

type McpElicitationSingleSelectEnumSchema struct {
	// contains filtered or unexported fields
}

func (McpElicitationSingleSelectEnumSchema) MarshalJSON 

func (s McpElicitationSingleSelectEnumSchema) MarshalJSON() ([]byte, error)

func (*McpElicitationSingleSelectEnumSchema) UnmarshalJSON 

func (s *McpElicitationSingleSelectEnumSchema) UnmarshalJSON(data []byte) error

type McpElicitationStringFormat 

type McpElicitationStringFormat string
const (
	McpElicitationFormatEmail    McpElicitationStringFormat = "email"
	McpElicitationFormatURI      McpElicitationStringFormat = "uri"
	McpElicitationFormatDate     McpElicitationStringFormat = "date"
	McpElicitationFormatDateTime McpElicitationStringFormat = "date-time"
)

type McpElicitationStringSchema 

type McpElicitationStringSchema struct {
	Type        McpElicitationStringType    `json:"type"`
	Title       *string                     `json:"title,omitempty" jsonschema:"nonnullable=true"`
	Description *string                     `json:"description,omitempty" jsonschema:"nonnullable=true"`
	MinLength   *uint32                     `json:"minLength,omitempty" jsonschema:"nonnullable=true"`
	MaxLength   *uint32                     `json:"maxLength,omitempty" jsonschema:"nonnullable=true"`
	Format      *McpElicitationStringFormat `json:"format,omitempty" jsonschema:"nonnullable=true"`
	Default     *string                     `json:"default,omitempty" jsonschema:"nonnullable=true"`
}

type McpElicitationStringType 

type McpElicitationStringType string
const McpElicitationString McpElicitationStringType = "string"

type McpElicitationTitledEnumItems 

type McpElicitationTitledEnumItems struct {
	AnyOf []McpElicitationConstOption `json:"anyOf" jsonschema:"nonnullable=true"`
}

type McpElicitationTitledMultiSelectEnumSchema 

type McpElicitationTitledMultiSelectEnumSchema struct {
	Type        McpElicitationArrayType       `json:"type"`
	Title       *string                       `json:"title,omitempty" jsonschema:"nonnullable=true"`
	Description *string                       `json:"description,omitempty" jsonschema:"nonnullable=true"`
	MinItems    *uint64                       `json:"minItems,omitempty" jsonschema:"nonnullable=true"`
	MaxItems    *uint64                       `json:"maxItems,omitempty" jsonschema:"nonnullable=true"`
	Items       McpElicitationTitledEnumItems `json:"items"`
	Default     []string                      `json:"default,omitempty" jsonschema:"nonnullable=true"`
}

type McpElicitationTitledSingleSelectEnumSchema 

type McpElicitationTitledSingleSelectEnumSchema struct {
	Type        McpElicitationStringType    `json:"type"`
	Title       *string                     `json:"title,omitempty" jsonschema:"nonnullable=true"`
	Description *string                     `json:"description,omitempty" jsonschema:"nonnullable=true"`
	OneOf       []McpElicitationConstOption `json:"oneOf" jsonschema:"nonnullable=true"`
	Default     *string                     `json:"default,omitempty" jsonschema:"nonnullable=true"`
}

type McpElicitationUntitledEnumItems 

type McpElicitationUntitledEnumItems struct {
	Type McpElicitationStringType `json:"type"`
	Enum []string                 `json:"enum" jsonschema:"nonnullable=true"`
}

type McpElicitationUntitledMultiSelectEnumSchema 

type McpElicitationUntitledMultiSelectEnumSchema struct {
	Type        McpElicitationArrayType         `json:"type"`
	Title       *string                         `json:"title,omitempty" jsonschema:"nonnullable=true"`
	Description *string                         `json:"description,omitempty" jsonschema:"nonnullable=true"`
	MinItems    *uint64                         `json:"minItems,omitempty" jsonschema:"nonnullable=true"`
	MaxItems    *uint64                         `json:"maxItems,omitempty" jsonschema:"nonnullable=true"`
	Items       McpElicitationUntitledEnumItems `json:"items"`
	Default     []string                        `json:"default,omitempty" jsonschema:"nonnullable=true"`
}

type McpElicitationUntitledSingleSelectEnumSchema 

type McpElicitationUntitledSingleSelectEnumSchema struct {
	Type        McpElicitationStringType `json:"type"`
	Title       *string                  `json:"title,omitempty" jsonschema:"nonnullable=true"`
	Description *string                  `json:"description,omitempty" jsonschema:"nonnullable=true"`
	Enum        []string                 `json:"enum" jsonschema:"nonnullable=true"`
	Default     *string                  `json:"default,omitempty" jsonschema:"nonnullable=true"`
}

type McpResourceReadParams 

type McpResourceReadParams struct {
	ThreadID *string `json:"threadId,omitempty"`
	Server   string  `json:"server"`
	URI      string  `json:"uri"`
}

McpResourceReadParams is the exact public MCP resource selector. It remains separate from the alias-compatible live request until an adapter is defined.

func (McpResourceReadParams) MarshalJSON 

func (p McpResourceReadParams) MarshalJSON() ([]byte, error)

func (*McpResourceReadParams) UnmarshalJSON 

func (p *McpResourceReadParams) UnmarshalJSON(data []byte) error

type McpResourceReadResponse 

type McpResourceReadResponse struct {
	Contents []ResourceContent `json:"contents" jsonschema:"nonnullable=true"`
}

McpResourceReadResponse is the exact public MCP resource-content envelope. It remains separate from Gollem's broader live result until an adapter exists.

func (McpResourceReadResponse) MarshalJSON 

func (r McpResourceReadResponse) MarshalJSON() ([]byte, error)

func (*McpResourceReadResponse) UnmarshalJSON 

func (r *McpResourceReadResponse) UnmarshalJSON(data []byte) error

type McpServerElicitationAction 

type McpServerElicitationAction string
const (
	McpServerElicitationAccept  McpServerElicitationAction = "accept"
	McpServerElicitationDecline McpServerElicitationAction = "decline"
	McpServerElicitationCancel  McpServerElicitationAction = "cancel"
)

type McpServerElicitationRequestParams 

type McpServerElicitationRequestParams struct {
	ThreadID        string          `json:"threadId"`
	TurnID          *string         `json:"turnId"`
	ServerName      string          `json:"serverName"`
	Mode            string          `json:"mode"`
	Meta            json.RawMessage `json:"_meta"`
	Message         string          `json:"message"`
	RequestedSchema json.RawMessage `json:"requestedSchema,omitempty"`
	URL             string          `json:"url,omitempty"`
	ElicitationID   string          `json:"elicitationId,omitempty"`
	RequestID       string          `json:"requestId,omitempty"`
	ItemID          string          `json:"itemId,omitempty"`
	StartedAtMS     int64           `json:"startedAtMs,omitempty"`
	ServerID        string          `json:"serverId,omitempty"`
	Schema          map[string]any  `json:"schema,omitempty"`
	Metadata        map[string]any  `json:"metadata,omitempty"`
	Reason          string          `json:"reason,omitempty"`
}

func (McpServerElicitationRequestParams) MarshalJSON 

func (p McpServerElicitationRequestParams) MarshalJSON() ([]byte, error)

func (*McpServerElicitationRequestParams) UnmarshalJSON 

func (p *McpServerElicitationRequestParams) UnmarshalJSON(data []byte) error

type McpServerElicitationRequestResponse 

type McpServerElicitationRequestResponse struct {
	Action  McpServerElicitationAction `json:"action"`
	Content json.RawMessage            `json:"content"`
	Meta    json.RawMessage            `json:"_meta"`
}

func (McpServerElicitationRequestResponse) MarshalJSON 

func (r McpServerElicitationRequestResponse) MarshalJSON() ([]byte, error)

func (*McpServerElicitationRequestResponse) UnmarshalJSON 

func (r *McpServerElicitationRequestResponse) UnmarshalJSON(data []byte) error

type McpServerInfo 

type McpServerInfo struct {
	Name        string      `json:"name"`
	Title       *string     `json:"title"`
	Version     string      `json:"version"`
	Description *string     `json:"description"`
	Icons       []JsonValue `json:"icons"`
	WebsiteURL  *string     `json:"websiteUrl"`
}

McpServerInfo is the exact public presentation metadata advertised by an initialized MCP server. It remains standalone until status projection exists.

func (*McpServerInfo) UnmarshalJSON 

func (i *McpServerInfo) UnmarshalJSON(data []byte) error

type McpServerMigration 

type McpServerMigration struct {
	Name string `json:"name"`
}

McpServerMigration identifies one MCP server configuration migration. It remains standalone until the external-agent migration contracts land.

func (*McpServerMigration) UnmarshalJSON 

func (m *McpServerMigration) UnmarshalJSON(data []byte) error

type McpServerOauthLoginCompletedNotification 

type McpServerOauthLoginCompletedNotification struct {
	Name     string  `json:"name"`
	ThreadID *string `json:"threadId"`
	Success  bool    `json:"success"`
	Error    *string `json:"error,omitempty"`
}

McpServerOauthLoginCompletedNotification is exact standalone public OAuth completion data. The corresponding notification remains producerless.

func (McpServerOauthLoginCompletedNotification) MarshalJSON 

func (n McpServerOauthLoginCompletedNotification) MarshalJSON() ([]byte, error)

func (*McpServerOauthLoginCompletedNotification) UnmarshalJSON 

func (n *McpServerOauthLoginCompletedNotification) UnmarshalJSON(data []byte) error

type McpServerOauthLoginParams 

type McpServerOauthLoginParams struct {
	Name        string    `json:"name"`
	ThreadID    *string   `json:"threadId"`
	Scopes      *[]string `json:"scopes,omitempty"`
	TimeoutSecs *int64    `json:"timeoutSecs,omitempty"`
}

McpServerOauthLoginParams is exact standalone public OAuth-login request data. It does not launch a browser, own credentials, or authorize a server.

func (McpServerOauthLoginParams) MarshalJSON 

func (p McpServerOauthLoginParams) MarshalJSON() ([]byte, error)

func (*McpServerOauthLoginParams) UnmarshalJSON 

func (p *McpServerOauthLoginParams) UnmarshalJSON(data []byte) error

type McpServerOauthLoginResponse 

type McpServerOauthLoginResponse struct {
	AuthorizationURL string `json:"authorizationUrl"`
}

McpServerOauthLoginResponse is exact standalone public OAuth authorization URL data. The URL remains opaque to Gollem's protocol package.

func (McpServerOauthLoginResponse) MarshalJSON 

func (r McpServerOauthLoginResponse) MarshalJSON() ([]byte, error)

func (*McpServerOauthLoginResponse) UnmarshalJSON 

func (r *McpServerOauthLoginResponse) UnmarshalJSON(data []byte) error

type McpServerRefreshResponse 

type McpServerRefreshResponse struct{}

McpServerRefreshResponse is the exact empty public MCP refresh response. It remains standalone from Gollem's broader live registry reload result.

func (*McpServerRefreshResponse) UnmarshalJSON 

func (r *McpServerRefreshResponse) UnmarshalJSON(data []byte) error

type McpServerStartupFailureReason 

type McpServerStartupFailureReason string

McpServerStartupFailureReason is the exact closed public MCP startup failure reason. It does not imply that Gollem performs reauthentication. 

const (
	McpServerStartupFailureReasonReauthenticationRequired McpServerStartupFailureReason = "reauthenticationRequired"
)

func (McpServerStartupFailureReason) MarshalJSON 

func (r McpServerStartupFailureReason) MarshalJSON() ([]byte, error)

func (*McpServerStartupFailureReason) UnmarshalJSON 

func (r *McpServerStartupFailureReason) UnmarshalJSON(data []byte) error

type McpServerStartupState 

type McpServerStartupState string

McpServerStartupState is the exact closed public MCP startup lifecycle. It remains standalone from Gollem's MCP registration and runtime state. 

const (
	McpServerStartupStateStarting  McpServerStartupState = "starting"
	McpServerStartupStateReady     McpServerStartupState = "ready"
	McpServerStartupStateFailed    McpServerStartupState = "failed"
	McpServerStartupStateCancelled McpServerStartupState = "cancelled"
)

func (McpServerStartupState) MarshalJSON 

func (s McpServerStartupState) MarshalJSON() ([]byte, error)

func (*McpServerStartupState) UnmarshalJSON 

func (s *McpServerStartupState) UnmarshalJSON(data []byte) error

type McpServerStatus 

type McpServerStatus struct {
	Name              string             `json:"name"`
	ServerInfo        *McpServerInfo     `json:"serverInfo"`
	Tools             map[string]Tool    `json:"tools" jsonschema:"nonnullable=true"`
	Resources         []Resource         `json:"resources" jsonschema:"nonnullable=true"`
	ResourceTemplates []ResourceTemplate `json:"resourceTemplates" jsonschema:"nonnullable=true"`
	AuthStatus        McpAuthStatus      `json:"authStatus"`
}

McpServerStatus is the exact public MCP inventory projection. Gollem's live status response remains a separate runtime contract until an adapter exists.

func (McpServerStatus) MarshalJSON 

func (s McpServerStatus) MarshalJSON() ([]byte, error)

func (*McpServerStatus) UnmarshalJSON 

func (s *McpServerStatus) UnmarshalJSON(data []byte) error

type McpServerStatusDetail 

type McpServerStatusDetail string

McpServerStatusDetail is the exact closed public MCP status detail selector. It remains standalone from Gollem's broader status request and runtime. 

const (
	McpServerStatusDetailFull             McpServerStatusDetail = "full"
	McpServerStatusDetailToolsAndAuthOnly McpServerStatusDetail = "toolsAndAuthOnly"
)

func (McpServerStatusDetail) MarshalJSON 

func (d McpServerStatusDetail) MarshalJSON() ([]byte, error)

func (*McpServerStatusDetail) UnmarshalJSON 

func (d *McpServerStatusDetail) UnmarshalJSON(data []byte) error

type McpServerStatusUpdatedNotification 

type McpServerStatusUpdatedNotification struct {
	ThreadID      *string                        `json:"threadId"`
	Name          string                         `json:"name"`
	Status        McpServerStartupState          `json:"status"`
	Error         *string                        `json:"error"`
	FailureReason *McpServerStartupFailureReason `json:"failureReason"`
}

McpServerStatusUpdatedNotification is the exact public MCP startup-status value. It remains standalone until Gollem has a startup producer.

func (McpServerStatusUpdatedNotification) MarshalJSON 

func (n McpServerStatusUpdatedNotification) MarshalJSON() ([]byte, error)

func (*McpServerStatusUpdatedNotification) UnmarshalJSON 

func (n *McpServerStatusUpdatedNotification) UnmarshalJSON(data []byte) error

type McpServerToolCallParams 

type McpServerToolCallParams struct {
	ThreadID  string     `json:"threadId"`
	Server    string     `json:"server"`
	Tool      string     `json:"tool"`
	Arguments *JsonValue `json:"arguments,omitempty"`
	Meta      *JsonValue `json:"_meta,omitempty"`
}

McpServerToolCallParams is the exact public MCP tool selector. It remains separate from the alias-compatible live request until an adapter is defined.

func (McpServerToolCallParams) MarshalJSON 

func (p McpServerToolCallParams) MarshalJSON() ([]byte, error)

func (*McpServerToolCallParams) UnmarshalJSON 

func (p *McpServerToolCallParams) UnmarshalJSON(data []byte) error

type McpServerToolCallResponse 

type McpServerToolCallResponse struct {
	Content           []JsonValue `json:"content" jsonschema:"nonnullable=true"`
	StructuredContent *JsonValue  `json:"structuredContent,omitempty"`
	IsError           *bool       `json:"isError,omitempty"`
	Meta              *JsonValue  `json:"_meta,omitempty"`
}

McpServerToolCallResponse is the exact public JSON-valued tool result. It remains separate from the broader live MCP response until an adapter exists.

func (McpServerToolCallResponse) MarshalJSON 

func (r McpServerToolCallResponse) MarshalJSON() ([]byte, error)

func (*McpServerToolCallResponse) UnmarshalJSON 

func (r *McpServerToolCallResponse) UnmarshalJSON(data []byte) error

type McpToolCallAppContext 

type McpToolCallAppContext struct {
	ConnectorID string  `json:"connectorId"`
	LinkID      *string `json:"linkId"`
	ResourceURI *string `json:"resourceUri"`
	AppName     *string `json:"appName"`
	TemplateID  *string `json:"templateId"`
	ActionName  *string `json:"actionName"`
}

func (*McpToolCallAppContext) UnmarshalJSON 

func (c *McpToolCallAppContext) UnmarshalJSON(data []byte) error

type McpToolCallError 

type McpToolCallError struct {
	Message string `json:"message"`
}

type McpToolCallProgressNotification 

type McpToolCallProgressNotification struct {
	ThreadID string `json:"threadId"`
	TurnID   string `json:"turnId"`
	ItemID   string `json:"itemId"`
	Message  string `json:"message"`
}

type McpToolCallResult 

type McpToolCallResult struct {
	Content           []JsonValue `json:"content" jsonschema:"nonnullable=true"`
	StructuredContent *JsonValue  `json:"structuredContent"`
	Meta              *JsonValue  `json:"_meta"`
}

McpToolCallResult is the exact public JSON-valued result. Gollem's live MCPToolCallResult remains a separate legacy MCPContent-backed value.

func (McpToolCallResult) MarshalJSON 

func (r McpToolCallResult) MarshalJSON() ([]byte, error)

func (*McpToolCallResult) UnmarshalJSON 

func (r *McpToolCallResult) UnmarshalJSON(data []byte) error

type McpToolCallStatus 

type McpToolCallStatus string
const (
	McpToolCallStatusInProgress McpToolCallStatus = ItemStatusInProgress
	McpToolCallStatusCompleted  McpToolCallStatus = ItemStatusCompleted
	McpToolCallStatusFailed     McpToolCallStatus = ItemStatusFailed
)

type MemoryCitation 

type MemoryCitation struct {
	Entries   []MemoryCitationEntry `json:"entries" jsonschema:"nonnullable=true"`
	ThreadIDs []string              `json:"threadIds" jsonschema:"nonnullable=true"`
}

func (MemoryCitation) MarshalJSON 

func (c MemoryCitation) MarshalJSON() ([]byte, error)

func (*MemoryCitation) UnmarshalJSON 

func (c *MemoryCitation) UnmarshalJSON(data []byte) error

type MemoryCitationEntry 

type MemoryCitationEntry struct {
	Path      string `json:"path"`
	LineStart uint32 `json:"lineStart"`
	LineEnd   uint32 `json:"lineEnd"`
	Note      string `json:"note"`
}

func (*MemoryCitationEntry) UnmarshalJSON 

func (e *MemoryCitationEntry) UnmarshalJSON(data []byte) error

type MergeStrategy 

type MergeStrategy string

MergeStrategy is the exact closed public config-write merge strategy. 

const (
	MergeStrategyReplace MergeStrategy = "replace"
	MergeStrategyUpsert  MergeStrategy = "upsert"
)

func (MergeStrategy) MarshalJSON 

func (s MergeStrategy) MarshalJSON() ([]byte, error)

func (*MergeStrategy) UnmarshalJSON 

func (s *MergeStrategy) UnmarshalJSON(data []byte) error

type MessagePhase 

type MessagePhase string
const (
	MessagePhaseCommentary  MessagePhase = "commentary"
	MessagePhaseFinalAnswer MessagePhase = "final_answer"
)

func (MessagePhase) MarshalJSON 

func (p MessagePhase) MarshalJSON() ([]byte, error)

func (*MessagePhase) UnmarshalJSON 

func (p *MessagePhase) UnmarshalJSON(data []byte) error

type MethodInfo 

type MethodInfo struct {
	Method  string      `json:"method"`
	Surface Surface     `json:"surface"`
	State   MethodState `json:"state"`
	Source  string      `json:"source,omitempty"`
}

MethodInfo describes one schema-known app-server method.

func LookupMethod 

func LookupMethod(method string) (MethodInfo, bool)

LookupMethod returns the first registered method with the given wire name.

func Methods 

func Methods() []MethodInfo

Methods returns a stable copy of the registered method inventory.

func MethodsBySurface 

func MethodsBySurface(surface Surface) []MethodInfo

MethodsBySurface returns registered methods for one surface.

type MethodState 

type MethodState string

MethodState is the current implementation state of a registered method. 

const (
	MethodImplemented       MethodState = "implemented"
	MethodBlocked           MethodState = "blocked"
	MethodDeferredStub      MethodState = "deferred-stub"
	MethodRenamedEquivalent MethodState = "renamed-equivalent"
	MethodNotApplicable     MethodState = "not-applicable"
)

type MigrationDetails 

type MigrationDetails struct {
	Plugins    []PluginsMigration   `json:"plugins"`
	Skills     []SkillMigration     `json:"skills"`
	Sessions   []SessionMigration   `json:"sessions"`
	MCPServers []McpServerMigration `json:"mcpServers"`
	Hooks      []HookMigration      `json:"hooks"`
	Subagents  []SubagentMigration  `json:"subagents"`
	Commands   []CommandMigration   `json:"commands"`
}

MigrationDetails groups the standalone external-agent migration leaves. It remains unbound until the external-agent request and runtime contracts land.

func (MigrationDetails) MarshalJSON 

func (d MigrationDetails) MarshalJSON() ([]byte, error)

func (*MigrationDetails) UnmarshalJSON 

func (d *MigrationDetails) UnmarshalJSON(data []byte) error

type ModeKind 

type ModeKind string
const (
	ModeKindPlan    ModeKind = "plan"
	ModeKindDefault ModeKind = "default"
)

func (ModeKind) MarshalJSON 

func (m ModeKind) MarshalJSON() ([]byte, error)

func (*ModeKind) UnmarshalJSON 

func (m *ModeKind) UnmarshalJSON(data []byte) error

type Model 

type Model struct {
	ID                        string                  `json:"id"`
	Model                     string                  `json:"model"`
	Upgrade                   *string                 `json:"upgrade"`
	UpgradeInfo               *ModelUpgradeInfo       `json:"upgradeInfo"`
	AvailabilityNux           *ModelAvailabilityNux   `json:"availabilityNux"`
	DisplayName               string                  `json:"displayName"`
	Description               string                  `json:"description"`
	Hidden                    bool                    `json:"hidden"`
	SupportedReasoningEfforts []ReasoningEffortOption `json:"supportedReasoningEfforts" jsonschema:"nonnullable=true"`
	DefaultReasoningEffort    ReasoningEffort         `json:"defaultReasoningEffort"`
	InputModalities           []InputModality         `json:"inputModalities" jsonschema:"nonnullable=true"`
	SupportsPersonality       bool                    `json:"supportsPersonality"`
	AdditionalSpeedTiers      []string                `json:"additionalSpeedTiers" jsonschema:"nonnullable=true"`
	ServiceTiers              []ModelServiceTier      `json:"serviceTiers" jsonschema:"nonnullable=true"`
	DefaultServiceTier        *string                 `json:"defaultServiceTier"`
	IsDefault                 bool                    `json:"isDefault"`
}

Model is the exact public model-catalog entry. It remains separate from the provider-neutral runtime catalog until the list boundary has an explicit projection between the two contracts.

func (Model) MarshalJSON 

func (m Model) MarshalJSON() ([]byte, error)

func (*Model) UnmarshalJSON 

func (m *Model) UnmarshalJSON(data []byte) error

type ModelAvailabilityNux 

type ModelAvailabilityNux struct {
	Message string `json:"message"`
}

ModelAvailabilityNux is the exact public model-availability notice value.

func (*ModelAvailabilityNux) UnmarshalJSON 

func (n *ModelAvailabilityNux) UnmarshalJSON(data []byte) error

type ModelCatalogAvailabilityNux 

type ModelCatalogAvailabilityNux struct {
	Message string `json:"message"`
}

type ModelCatalogCapabilities 

type ModelCatalogCapabilities struct {
	ToolCalls        bool `json:"toolCalls"`
	StructuredOutput bool `json:"structuredOutput"`
	Vision           bool `json:"vision"`
	Streaming        bool `json:"streaming"`
	PromptCache      bool `json:"promptCache"`
	ToolSearch       bool `json:"toolSearch"`
	Reasoning        bool `json:"reasoning"`
}

type ModelCatalogEntry 

type ModelCatalogEntry struct {
	ID                        string                              `json:"id"`
	ProviderID                string                              `json:"providerId"`
	Model                     string                              `json:"model"`
	Upgrade                   *string                             `json:"upgrade"`
	UpgradeInfo               *ModelCatalogUpgradeInfo            `json:"upgradeInfo"`
	AvailabilityNux           *ModelCatalogAvailabilityNux        `json:"availabilityNux"`
	DisplayName               string                              `json:"displayName"`
	Description               string                              `json:"description"`
	Hidden                    bool                                `json:"hidden"`
	SupportedReasoningEfforts []ModelCatalogReasoningEffortOption `json:"supportedReasoningEfforts"`
	DefaultReasoningEffort    string                              `json:"defaultReasoningEffort"`
	InputModalities           []string                            `json:"inputModalities"`
	SupportsPersonality       bool                                `json:"supportsPersonality"`
	AdditionalSpeedTiers      []string                            `json:"additionalSpeedTiers"`
	ServiceTiers              []ModelCatalogServiceTier           `json:"serviceTiers"`
	DefaultServiceTier        *string                             `json:"defaultServiceTier"`
	IsDefault                 bool                                `json:"isDefault"`
	Capabilities              ModelCatalogCapabilities            `json:"capabilities"`
	MaxContextTokens          int                                 `json:"maxContextTokens,omitempty"`
	MaxOutputTokens           int                                 `json:"maxOutputTokens,omitempty"`
}

ModelCatalogEntry extends the exact standalone Model value with Gollem provider identity, executable capabilities, and runtime token limits.

type ModelCatalogListParams 

type ModelCatalogListParams struct {
	Cursor        *string  `json:"cursor,omitempty"`
	Limit         *uint32  `json:"limit,omitempty"`
	IncludeHidden *bool    `json:"includeHidden,omitempty"`
	ProviderID    string   `json:"providerId,omitempty"`
	ProviderIDs   []string `json:"providerIds,omitempty"`
}

type ModelCatalogListResponse 

type ModelCatalogListResponse struct {
	Data       []ModelCatalogEntry `json:"data"`
	NextCursor *string             `json:"nextCursor"`
}

type ModelCatalogReasoningEffortOption 

type ModelCatalogReasoningEffortOption struct {
	ReasoningEffort string `json:"reasoningEffort"`
	Description     string `json:"description"`
}

type ModelCatalogServiceTier 

type ModelCatalogServiceTier struct {
	ID          string `json:"id"`
	Name        string `json:"name"`
	Description string `json:"description"`
}

type ModelCatalogUpgradeInfo 

type ModelCatalogUpgradeInfo struct {
	Model             string  `json:"model"`
	UpgradeCopy       *string `json:"upgradeCopy"`
	ModelLink         *string `json:"modelLink"`
	MigrationMarkdown *string `json:"migrationMarkdown"`
}

type ModelListParams 

type ModelListParams struct {
	Cursor        *string `json:"cursor,omitempty"`
	Limit         *uint32 `json:"limit,omitempty"`
	IncludeHidden *bool   `json:"includeHidden,omitempty"`
}

ModelListParams is the exact public model-catalog page selector. It remains separate from the provider-filtered live request until an adapter is defined.

func (ModelListParams) MarshalJSON 

func (p ModelListParams) MarshalJSON() ([]byte, error)

func (*ModelListParams) UnmarshalJSON 

func (p *ModelListParams) UnmarshalJSON(data []byte) error

type ModelListResponse 

type ModelListResponse struct {
	Data       []Model `json:"data" jsonschema:"nonnullable=true"`
	NextCursor *string `json:"nextCursor"`
}

ModelListResponse is the exact public page of strict Model values. It stays outside the live method binding until provider extensions can be projected.

func (ModelListResponse) MarshalJSON 

func (r ModelListResponse) MarshalJSON() ([]byte, error)

func (*ModelListResponse) UnmarshalJSON 

func (r *ModelListResponse) UnmarshalJSON(data []byte) error

type ModelProviderCapabilitiesReadParams 

type ModelProviderCapabilitiesReadParams struct{}

ModelProviderCapabilitiesReadParams is the exact empty public capability request. It stays separate from Gollem's provider-selector live extension.

func (*ModelProviderCapabilitiesReadParams) UnmarshalJSON 

func (p *ModelProviderCapabilitiesReadParams) UnmarshalJSON(data []byte) error

type ModelProviderCapabilitiesReadResponse 

type ModelProviderCapabilitiesReadResponse struct {
	NamespaceTools  bool `json:"namespaceTools"`
	ImageGeneration bool `json:"imageGeneration"`
	WebSearch       bool `json:"webSearch"`
}

ModelProviderCapabilitiesReadResponse is the exact public capability projection. Gollem's broader live response remains unbound.

func (*ModelProviderCapabilitiesReadResponse) UnmarshalJSON 

func (r *ModelProviderCapabilitiesReadResponse) UnmarshalJSON(data []byte) error

type ModelRerouteReason 

type ModelRerouteReason string
const ModelRerouteReasonHighRiskCyberActivity ModelRerouteReason = "highRiskCyberActivity"

func (ModelRerouteReason) MarshalJSON 

func (r ModelRerouteReason) MarshalJSON() ([]byte, error)

func (*ModelRerouteReason) UnmarshalJSON 

func (r *ModelRerouteReason) UnmarshalJSON(data []byte) error

type ModelReroutedNotification 

type ModelReroutedNotification struct {
	ThreadID  string             `json:"threadId"`
	TurnID    string             `json:"turnId"`
	FromModel string             `json:"fromModel"`
	ToModel   string             `json:"toModel"`
	Reason    ModelRerouteReason `json:"reason"`
}

ModelReroutedNotification is the exact fixed public model-reroute value. It remains standalone until Gollem has a model-safety producer.

func (*ModelReroutedNotification) UnmarshalJSON 

func (n *ModelReroutedNotification) UnmarshalJSON(data []byte) error

type ModelSafetyBufferingUpdatedNotification 

type ModelSafetyBufferingUpdatedNotification struct {
	ThreadID        string   `json:"threadId"`
	TurnID          string   `json:"turnId"`
	Model           string   `json:"model"`
	UseCases        []string `json:"useCases" jsonschema:"nonnullable=true"`
	Reasons         []string `json:"reasons" jsonschema:"nonnullable=true"`
	ShowBufferingUI bool     `json:"showBufferingUi"`
	FasterModel     *string  `json:"fasterModel"`
}

ModelSafetyBufferingUpdatedNotification is the exact fixed public buffering state value. It remains standalone until Gollem has a model-safety producer.

func (ModelSafetyBufferingUpdatedNotification) MarshalJSON 

func (n ModelSafetyBufferingUpdatedNotification) MarshalJSON() ([]byte, error)

func (*ModelSafetyBufferingUpdatedNotification) UnmarshalJSON 

func (n *ModelSafetyBufferingUpdatedNotification) UnmarshalJSON(data []byte) error

type ModelServiceTier 

type ModelServiceTier struct {
	ID          string `json:"id"`
	Name        string `json:"name"`
	Description string `json:"description"`
}

ModelServiceTier is the exact public model service-tier descriptor.

func (*ModelServiceTier) UnmarshalJSON 

func (t *ModelServiceTier) UnmarshalJSON(data []byte) error

type ModelUpgradeInfo 

type ModelUpgradeInfo struct {
	Model             string  `json:"model"`
	UpgradeCopy       *string `json:"upgradeCopy"`
	ModelLink         *string `json:"modelLink"`
	MigrationMarkdown *string `json:"migrationMarkdown"`
}

ModelUpgradeInfo is the exact public model-upgrade descriptor. Nullable fields are canonical output fields, while decode accepts their Rust Option omission form.

func (*ModelUpgradeInfo) UnmarshalJSON 

func (i *ModelUpgradeInfo) UnmarshalJSON(data []byte) error

type ModelVerification 

type ModelVerification string
const ModelVerificationTrustedAccessForCyber ModelVerification = "trustedAccessForCyber"

func (ModelVerification) MarshalJSON 

func (v ModelVerification) MarshalJSON() ([]byte, error)

func (*ModelVerification) UnmarshalJSON 

func (v *ModelVerification) UnmarshalJSON(data []byte) error

type ModelVerificationNotification 

type ModelVerificationNotification struct {
	ThreadID      string              `json:"threadId"`
	TurnID        string              `json:"turnId"`
	Verifications []ModelVerification `json:"verifications" jsonschema:"nonnullable=true"`
}

ModelVerificationNotification is the exact fixed public model-verification value. It remains standalone until Gollem has a model-safety producer.

func (ModelVerificationNotification) MarshalJSON 

func (n ModelVerificationNotification) MarshalJSON() ([]byte, error)

func (*ModelVerificationNotification) UnmarshalJSON 

func (n *ModelVerificationNotification) UnmarshalJSON(data []byte) error

type ModelsRequirements 

type ModelsRequirements struct {
	NewThread *NewThreadModelDefaults `json:"newThread"`
}

ModelsRequirements is the exact public model-requirements configuration. The live Gollem configuration-requirements response remains separate.

func (*ModelsRequirements) UnmarshalJSON 

func (r *ModelsRequirements) UnmarshalJSON(data []byte) error

type MultiAgentMode 

type MultiAgentMode struct {
	// contains filtered or unexported fields
}

MultiAgentMode is standalone policy-description data. It does not enable delegation or subagent execution.

func (MultiAgentMode) MarshalJSON 

func (m MultiAgentMode) MarshalJSON() ([]byte, error)

func (*MultiAgentMode) UnmarshalJSON 

func (m *MultiAgentMode) UnmarshalJSON(data []byte) error

type NetworkAccess 

type NetworkAccess string

func (NetworkAccess) MarshalJSON 

func (a NetworkAccess) MarshalJSON() ([]byte, error)

func (*NetworkAccess) UnmarshalJSON 

func (a *NetworkAccess) UnmarshalJSON(data []byte) error

type NetworkApprovalContext 

type NetworkApprovalContext struct {
	Host     string                  `json:"host"`
	Protocol NetworkApprovalProtocol `json:"protocol"`
}

NetworkApprovalContext is the exact standalone public context for a network approval. It describes protocol data only and does not grant network access.

func (*NetworkApprovalContext) UnmarshalJSON 

func (c *NetworkApprovalContext) UnmarshalJSON(data []byte) error

type NetworkApprovalProtocol 

type NetworkApprovalProtocol string

NetworkApprovalProtocol is the exact closed public protocol classification for network approval review. It does not grant or enforce network access. 

const (
	NetworkApprovalProtocolHTTP      NetworkApprovalProtocol = "http"
	NetworkApprovalProtocolHTTPS     NetworkApprovalProtocol = "https"
	NetworkApprovalProtocolSocks5TCP NetworkApprovalProtocol = "socks5Tcp"
	NetworkApprovalProtocolSocks5UDP NetworkApprovalProtocol = "socks5Udp"
)

func (NetworkApprovalProtocol) MarshalJSON 

func (p NetworkApprovalProtocol) MarshalJSON() ([]byte, error)

func (*NetworkApprovalProtocol) UnmarshalJSON 

func (p *NetworkApprovalProtocol) UnmarshalJSON(data []byte) error

type NetworkDomainPermission 

type NetworkDomainPermission string

NetworkDomainPermission is the exact closed public domain permission. 

const (
	NetworkDomainPermissionAllow NetworkDomainPermission = "allow"
	NetworkDomainPermissionDeny  NetworkDomainPermission = "deny"
)

func (NetworkDomainPermission) MarshalJSON 

func (p NetworkDomainPermission) MarshalJSON() ([]byte, error)

func (*NetworkDomainPermission) UnmarshalJSON 

func (p *NetworkDomainPermission) UnmarshalJSON(data []byte) error

type NetworkPolicyAmendment 

type NetworkPolicyAmendment struct {
	Host   string                  `json:"host"`
	Action NetworkPolicyRuleAction `json:"action"`
}

type NetworkPolicyRuleAction 

type NetworkPolicyRuleAction string
const (
	NetworkPolicyRuleAllow NetworkPolicyRuleAction = "allow"
	NetworkPolicyRuleDeny  NetworkPolicyRuleAction = "deny"
)

type NetworkRequirements 

type NetworkRequirements struct {
	Enabled                          *bool                                   `json:"enabled"`
	HTTPPort                         *uint16                                 `json:"httpPort"`
	SOCKSPort                        *uint16                                 `json:"socksPort"`
	AllowUpstreamProxy               *bool                                   `json:"allowUpstreamProxy"`
	DangerouslyAllowNonLoopbackProxy *bool                                   `json:"dangerouslyAllowNonLoopbackProxy"`
	DangerouslyAllowAllUnixSockets   *bool                                   `json:"dangerouslyAllowAllUnixSockets"`
	Domains                          *map[string]NetworkDomainPermission     `json:"domains"`
	ManagedAllowedDomainsOnly        *bool                                   `json:"managedAllowedDomainsOnly"`
	AllowedDomains                   *[]string                               `json:"allowedDomains"`
	DeniedDomains                    *[]string                               `json:"deniedDomains"`
	UnixSockets                      *map[string]NetworkUnixSocketPermission `json:"unixSockets"`
	AllowUnixSockets                 *[]string                               `json:"allowUnixSockets"`
	AllowLocalBinding                *bool                                   `json:"allowLocalBinding"`
}

NetworkRequirements is the exact standalone public network-requirements value. It does not configure a proxy or imply runtime network enforcement.

func (*NetworkRequirements) UnmarshalJSON 

func (r *NetworkRequirements) UnmarshalJSON(data []byte) error

type NetworkUnixSocketPermission 

type NetworkUnixSocketPermission string

NetworkUnixSocketPermission is the exact closed public Unix-socket permission. 

const (
	NetworkUnixSocketPermissionAllow NetworkUnixSocketPermission = "allow"
	NetworkUnixSocketPermissionDeny  NetworkUnixSocketPermission = "deny"
)

func (NetworkUnixSocketPermission) MarshalJSON 

func (p NetworkUnixSocketPermission) MarshalJSON() ([]byte, error)

func (*NetworkUnixSocketPermission) UnmarshalJSON 

func (p *NetworkUnixSocketPermission) UnmarshalJSON(data []byte) error

type NewThreadModelDefaults 

type NewThreadModelDefaults struct {
	Model                *string          `json:"model"`
	ModelReasoningEffort *ReasoningEffort `json:"modelReasoningEffort"`
	ServiceTier          *string          `json:"serviceTier"`
}

NewThreadModelDefaults is the exact public model-default configuration for new threads. Nullable fields stay explicit in canonical output.

func (*NewThreadModelDefaults) UnmarshalJSON 

func (d *NewThreadModelDefaults) UnmarshalJSON(data []byte) error

type NonSteerableTurnKind 

type NonSteerableTurnKind string
const (
	NonSteerableTurnKindReview  NonSteerableTurnKind = "review"
	NonSteerableTurnKindCompact NonSteerableTurnKind = "compact"
)

func (NonSteerableTurnKind) MarshalJSON 

func (k NonSteerableTurnKind) MarshalJSON() ([]byte, error)

func (*NonSteerableTurnKind) UnmarshalJSON 

func (k *NonSteerableTurnKind) UnmarshalJSON(data []byte) error

type Notification 

type Notification struct {
	JSONRPC string          `json:"-"`
	Method  string          `json:"method"`
	Params  json.RawMessage `json:"params,omitempty"`
}

Notification is a JSON-RPC notification without a response id.

func (Notification) MarshalJSON 

func (n Notification) MarshalJSON() ([]byte, error)

MarshalJSON emits a Codex-style notification without a jsonrpc member.

func (*Notification) UnmarshalJSON 

func (n *Notification) UnmarshalJSON(data []byte) error

UnmarshalJSON accepts notifications with or without the jsonrpc member.

type OperationalListParams added in v0.8.0 

type OperationalListParams struct {
	Limit  int    `json:"limit,omitempty"`
	Cursor string `json:"cursor,omitempty"`
}

OperationalListParams requests one bounded page from an operational inventory. Cursors are opaque and scoped to the method that issued them.

type OverloadedData 

type OverloadedData struct {
	Method           string `json:"method,omitempty"`
	Limit            int    `json:"limit,omitempty"`
	Pending          int    `json:"pending,omitempty"`
	Retryable        bool   `json:"retryable"`
	RetryAfterMillis int    `json:"retryAfterMillis,omitempty"`
	Reason           string `json:"reason"`
}

OverloadedData describes a retryable app-server backpressure rejection.

type OverriddenMetadata 

type OverriddenMetadata struct {
	Message         string              `json:"message"`
	OverridingLayer ConfigLayerMetadata `json:"overridingLayer"`
	EffectiveValue  JsonValue           `json:"effectiveValue"`
}

OverriddenMetadata describes the layer and value that overrides a setting.

func (*OverriddenMetadata) UnmarshalJSON 

func (m *OverriddenMetadata) UnmarshalJSON(data []byte) error

type ParsedCommand 

type ParsedCommand struct {
	// contains filtered or unexported fields
}

ParsedCommand retains one exact public parsed-command variant without aliasing Gollem's distinct live command-action types.

func (ParsedCommand) MarshalJSON 

func (c ParsedCommand) MarshalJSON() ([]byte, error)

func (*ParsedCommand) UnmarshalJSON 

func (c *ParsedCommand) UnmarshalJSON(data []byte) error

type PatchApplyStatus 

type PatchApplyStatus string
const (
	PatchApplyStatusInProgress PatchApplyStatus = ItemStatusInProgress
	PatchApplyStatusCompleted  PatchApplyStatus = ItemStatusCompleted
	PatchApplyStatusFailed     PatchApplyStatus = ItemStatusFailed
	PatchApplyStatusDeclined   PatchApplyStatus = ItemStatusDeclined
)

type PatchChangeKind 

type PatchChangeKind struct {
	Type     string  `json:"type" jsonschema:"enum=add|delete|update"`
	MovePath *string `json:"-"`
}

func (PatchChangeKind) MarshalJSON 

func (k PatchChangeKind) MarshalJSON() ([]byte, error)

func (*PatchChangeKind) UnmarshalJSON 

func (k *PatchChangeKind) UnmarshalJSON(data []byte) error

type PermissionGrantScope 

type PermissionGrantScope string

func (PermissionGrantScope) MarshalJSON 

func (s PermissionGrantScope) MarshalJSON() ([]byte, error)

func (*PermissionGrantScope) UnmarshalJSON 

func (s *PermissionGrantScope) UnmarshalJSON(data []byte) error

type PermissionProfileListParams 

type PermissionProfileListParams struct {
	Cursor *string `json:"cursor"`
	Limit  *uint32 `json:"limit"`
	CWD    *string `json:"cwd"`
}

PermissionProfileListParams is the exact public permission-profile page selector. It remains separate from Gollem's broader live catalog request.

func (PermissionProfileListParams) MarshalJSON 

func (p PermissionProfileListParams) MarshalJSON() ([]byte, error)

func (*PermissionProfileListParams) UnmarshalJSON 

func (p *PermissionProfileListParams) UnmarshalJSON(data []byte) error

type PermissionProfileListResponse 

type PermissionProfileListResponse struct {
	Data       []PermissionProfileSummary `json:"data"`
	NextCursor *string                    `json:"nextCursor"`
}

PermissionProfileListResponse is one exact public ordered profile-summary page. The records remain descriptive and carry no permission authority.

func (PermissionProfileListResponse) MarshalJSON 

func (r PermissionProfileListResponse) MarshalJSON() ([]byte, error)

func (*PermissionProfileListResponse) UnmarshalJSON 

func (r *PermissionProfileListResponse) UnmarshalJSON(data []byte) error

type PermissionProfileSummary 

type PermissionProfileSummary struct {
	ID          string  `json:"id"`
	Description *string `json:"description"`
	Allowed     bool    `json:"allowed"`
}

PermissionProfileSummary is exact public display and selectability data. It does not grant permissions or prove that a profile is enforced.

func (PermissionProfileSummary) MarshalJSON 

func (s PermissionProfileSummary) MarshalJSON() ([]byte, error)

func (*PermissionProfileSummary) UnmarshalJSON 

func (s *PermissionProfileSummary) UnmarshalJSON(data []byte) error

type PermissionsApprovalRequestParams 

type PermissionsApprovalRequestParams struct {
	ApprovalRequestBase
	CWD         string         `json:"cwd"`
	Operation   string         `json:"operation,omitempty"`
	Path        string         `json:"path,omitempty"`
	Branch      string         `json:"branch,omitempty"`
	Base        string         `json:"base,omitempty"`
	Message     string         `json:"message,omitempty"`
	Pathspecs   []string       `json:"pathspecs,omitempty"`
	Permissions map[string]any `json:"permissions"`
}

type PermissionsRequestApprovalParams 

type PermissionsRequestApprovalParams struct {
	ThreadID      string                   `json:"threadId"`
	TurnID        string                   `json:"turnId"`
	ItemID        string                   `json:"itemId"`
	EnvironmentID *string                  `json:"environmentId"`
	StartedAtMS   int64                    `json:"startedAtMs"`
	CWD           AbsolutePathBuf          `json:"cwd"`
	Reason        *string                  `json:"reason"`
	Permissions   RequestPermissionProfile `json:"permissions"`
}

PermissionsRequestApprovalParams is the public scoped permission request. Gollem's live Git/MCP approval request remains a separately named extension.

func (*PermissionsRequestApprovalParams) UnmarshalJSON 

func (p *PermissionsRequestApprovalParams) UnmarshalJSON(data []byte) error

type PermissionsRequestApprovalResponse 

type PermissionsRequestApprovalResponse struct {
	Permissions      GrantedPermissionProfile `json:"permissions"`
	Scope            PermissionGrantScope     `json:"scope"`
	StrictAutoReview *bool                    `json:"strictAutoReview,omitempty" jsonschema:"nonnullable=true"`
}

PermissionsRequestApprovalResponse is exported for wire compatibility but is not bound until Gollem can enforce profile intersection and grant scope.

func (PermissionsRequestApprovalResponse) MarshalJSON 

func (r PermissionsRequestApprovalResponse) MarshalJSON() ([]byte, error)

func (*PermissionsRequestApprovalResponse) UnmarshalJSON 

func (r *PermissionsRequestApprovalResponse) UnmarshalJSON(data []byte) error

type Personality 

type Personality string

Personality is the exact public request-side response-style preference. It does not by itself change Gollem model behavior. 

const (
	PersonalityNone      Personality = "none"
	PersonalityFriendly  Personality = "friendly"
	PersonalityPragmatic Personality = "pragmatic"
)

func (Personality) MarshalJSON 

func (p Personality) MarshalJSON() ([]byte, error)

func (*Personality) UnmarshalJSON 

func (p *Personality) UnmarshalJSON(data []byte) error

type PlanDeltaNotification 

type PlanDeltaNotification struct {
	ThreadID string `json:"threadId"`
	TurnID   string `json:"turnId"`
	ItemID   string `json:"itemId"`
	Delta    string `json:"delta"`
}

PlanDeltaNotification is the exact experimental plan-item delta value. It remains standalone until Gollem has an exact producer.

func (*PlanDeltaNotification) UnmarshalJSON 

func (n *PlanDeltaNotification) UnmarshalJSON(data []byte) error

type PlanType 

type PlanType string

PlanType is the public account plan classification. Unknown upstream strings collapse to the serde fallback literal instead of retaining provider data. 

const (
	PlanTypeFree                        PlanType = "free"
	PlanTypeGo                          PlanType = "go"
	PlanTypePlus                        PlanType = "plus"
	PlanTypePro                         PlanType = "pro"
	PlanTypeProLite                     PlanType = "prolite"
	PlanTypeTeam                        PlanType = "team"
	PlanTypeSelfServeBusinessUsageBased PlanType = "self_serve_business_usage_based"
	PlanTypeBusiness                    PlanType = "business"
	PlanTypeEnterpriseCBPUsageBased     PlanType = "enterprise_cbp_usage_based"
	PlanTypeEnterprise                  PlanType = "enterprise"
	PlanTypeEdu                         PlanType = "edu"
	PlanTypeUnknown                     PlanType = "unknown"
)

func (PlanType) MarshalJSON 

func (p PlanType) MarshalJSON() ([]byte, error)

func (*PlanType) UnmarshalJSON 

func (p *PlanType) UnmarshalJSON(data []byte) error

type PluginsMigration 

type PluginsMigration struct {
	MarketplaceName string   `json:"marketplaceName"`
	PluginNames     []string `json:"pluginNames" jsonschema:"nonnullable=true"`
}

PluginsMigration identifies plugin names from one marketplace migration. It remains standalone until the external-agent migration contracts land.

func (PluginsMigration) MarshalJSON 

func (m PluginsMigration) MarshalJSON() ([]byte, error)

func (*PluginsMigration) UnmarshalJSON 

func (m *PluginsMigration) UnmarshalJSON(data []byte) error

type ProcessExitedNotification 

type ProcessExitedNotification struct {
	ProcessHandle    string `json:"processHandle"`
	ExitCode         int32  `json:"exitCode"`
	Stdout           string `json:"stdout"`
	StdoutCapReached bool   `json:"stdoutCapReached"`
	Stderr           string `json:"stderr"`
	StderrCapReached bool   `json:"stderrCapReached"`
}

ProcessExitedNotification is the standalone public final process payload. It remains unbound until the process runtime emits this exact wire shape.

func (ProcessExitedNotification) MarshalJSON 

func (n ProcessExitedNotification) MarshalJSON() ([]byte, error)

func (*ProcessExitedNotification) UnmarshalJSON 

func (n *ProcessExitedNotification) UnmarshalJSON(data []byte) error

type ProcessOutputDeltaNotification 

type ProcessOutputDeltaNotification struct {
	ProcessHandle string              `json:"processHandle"`
	Stream        ProcessOutputStream `json:"stream"`
	DeltaBase64   string              `json:"deltaBase64"`
	CapReached    bool                `json:"capReached"`
}

ProcessOutputDeltaNotification is the standalone public streaming-output payload. It is intentionally not bound to the legacy runtime notification.

func (ProcessOutputDeltaNotification) MarshalJSON 

func (n ProcessOutputDeltaNotification) MarshalJSON() ([]byte, error)

func (*ProcessOutputDeltaNotification) UnmarshalJSON 

func (n *ProcessOutputDeltaNotification) UnmarshalJSON(data []byte) error

type ProcessOutputStream 

type ProcessOutputStream string

ProcessOutputStream identifies the source stream for a process output chunk. 

const (
	ProcessOutputStreamStdout ProcessOutputStream = "stdout"
	ProcessOutputStreamStderr ProcessOutputStream = "stderr"
)

func (ProcessOutputStream) MarshalJSON 

func (s ProcessOutputStream) MarshalJSON() ([]byte, error)

func (*ProcessOutputStream) UnmarshalJSON 

func (s *ProcessOutputStream) UnmarshalJSON(data []byte) error

type ProcessTerminalSize 

type ProcessTerminalSize struct {
	Rows uint16 `json:"rows"`
	Cols uint16 `json:"cols"`
}

ProcessTerminalSize is the exact standalone PTY size contract used by process/spawn. The process runtime remains on its existing legacy envelope.

func (ProcessTerminalSize) MarshalJSON 

func (s ProcessTerminalSize) MarshalJSON() ([]byte, error)

func (*ProcessTerminalSize) UnmarshalJSON 

func (s *ProcessTerminalSize) UnmarshalJSON(data []byte) error

type ProviderCatalogCapabilities 

type ProviderCatalogCapabilities struct {
	ProviderID               string   `json:"providerId,omitempty"`
	Configured               bool     `json:"configured"`
	NamespaceTools           bool     `json:"namespaceTools"`
	ImageGeneration          bool     `json:"imageGeneration"`
	WebSearch                bool     `json:"webSearch"`
	ToolCalls                bool     `json:"toolCalls"`
	StructuredOutput         bool     `json:"structuredOutput"`
	Vision                   bool     `json:"vision"`
	Streaming                bool     `json:"streaming"`
	PromptCache              bool     `json:"promptCache"`
	ToolSearch               bool     `json:"toolSearch"`
	Reasoning                bool     `json:"reasoning"`
	ReasoningEfforts         []string `json:"reasoningEfforts,omitempty"`
	ReasoningSummaries       bool     `json:"reasoningSummaries,omitempty"`
	AdaptiveThinking         bool     `json:"adaptiveThinking,omitempty"`
	ManualThinking           bool     `json:"manualThinking,omitempty"`
	RequiresConfigurationEnv []string `json:"requiresConfigurationEnv,omitempty"`
}

type ProviderCatalogEntry 

type ProviderCatalogEntry struct {
	ID              string                      `json:"id"`
	Name            string                      `json:"name"`
	Package         string                      `json:"package"`
	Description     string                      `json:"description"`
	Configured      bool                        `json:"configured"`
	Hidden          bool                        `json:"hidden"`
	DefaultModelID  string                      `json:"defaultModelId"`
	RequiredEnvVars []string                    `json:"requiredEnvVars,omitempty"`
	OptionalEnvVars []string                    `json:"optionalEnvVars,omitempty"`
	AuthModes       []string                    `json:"authModes,omitempty"`
	Capabilities    ProviderCatalogCapabilities `json:"capabilities"`
	Models          []ModelCatalogEntry         `json:"models,omitempty"`
}

ProviderCatalogEntry is Gollem's provider-neutral live catalog record. It remains distinct from provider implementation request payloads.

type ProviderListParams 

type ProviderListParams struct {
	IncludeHidden  *bool `json:"includeHidden,omitempty"`
	ConfiguredOnly bool  `json:"configuredOnly,omitempty"`
}

type ProviderListResponse 

type ProviderListResponse struct {
	Data      []ProviderCatalogEntry `json:"data"`
	Providers []ProviderCatalogEntry `json:"providers"`
}

type RateLimitReachedType 

type RateLimitReachedType string

RateLimitReachedType is the exact closed reason a public rate limit was hit. 

const (
	RateLimitReachedTypeRateLimitReached                 RateLimitReachedType = "rate_limit_reached"
	RateLimitReachedTypeWorkspaceOwnerCreditsDepleted    RateLimitReachedType = "workspace_owner_credits_depleted"
	RateLimitReachedTypeWorkspaceMemberCreditsDepleted   RateLimitReachedType = "workspace_member_credits_depleted"
	RateLimitReachedTypeWorkspaceOwnerUsageLimitReached  RateLimitReachedType = "workspace_owner_usage_limit_reached"
	RateLimitReachedTypeWorkspaceMemberUsageLimitReached RateLimitReachedType = "workspace_member_usage_limit_reached"
)

func (RateLimitReachedType) MarshalJSON 

func (r RateLimitReachedType) MarshalJSON() ([]byte, error)

func (*RateLimitReachedType) UnmarshalJSON 

func (r *RateLimitReachedType) UnmarshalJSON(data []byte) error

type RateLimitResetCredit 

type RateLimitResetCredit struct {
	ID          string                     `json:"id"`
	ResetType   RateLimitResetType         `json:"resetType"`
	Status      RateLimitResetCreditStatus `json:"status"`
	GrantedAt   int64                      `json:"grantedAt"`
	ExpiresAt   *int64                     `json:"expiresAt,omitempty"`
	Title       *string                    `json:"title,omitempty"`
	Description *string                    `json:"description,omitempty"`
}

RateLimitResetCredit is exact standalone reset-credit metadata.

func (RateLimitResetCredit) MarshalJSON 

func (c RateLimitResetCredit) MarshalJSON() ([]byte, error)

func (*RateLimitResetCredit) UnmarshalJSON 

func (c *RateLimitResetCredit) UnmarshalJSON(data []byte) error

type RateLimitResetCreditStatus 

type RateLimitResetCreditStatus string

RateLimitResetCreditStatus is the public reset-credit lifecycle state. 

const (
	RateLimitResetCreditStatusAvailable RateLimitResetCreditStatus = "available"
	RateLimitResetCreditStatusRedeeming RateLimitResetCreditStatus = "redeeming"
	RateLimitResetCreditStatusRedeemed  RateLimitResetCreditStatus = "redeemed"
	RateLimitResetCreditStatusUnknown   RateLimitResetCreditStatus = "unknown"
)

func (RateLimitResetCreditStatus) MarshalJSON 

func (s RateLimitResetCreditStatus) MarshalJSON() ([]byte, error)

func (*RateLimitResetCreditStatus) UnmarshalJSON 

func (s *RateLimitResetCreditStatus) UnmarshalJSON(data []byte) error

type RateLimitResetCreditsSummary 

type RateLimitResetCreditsSummary struct {
	AvailableCount int64                  `json:"availableCount"`
	Credits        []RateLimitResetCredit `json:"credits,omitempty"`
}

RateLimitResetCreditsSummary is standalone reset-credit availability data.

func (RateLimitResetCreditsSummary) MarshalJSON 

func (s RateLimitResetCreditsSummary) MarshalJSON() ([]byte, error)

func (*RateLimitResetCreditsSummary) UnmarshalJSON 

func (s *RateLimitResetCreditsSummary) UnmarshalJSON(data []byte) error

type RateLimitResetType 

type RateLimitResetType string

RateLimitResetType identifies the backend meter reset by a credit. 

const (
	RateLimitResetTypeCodexRateLimits RateLimitResetType = "codexRateLimits"
	RateLimitResetTypeUnknown         RateLimitResetType = "unknown"
)

func (RateLimitResetType) MarshalJSON 

func (r RateLimitResetType) MarshalJSON() ([]byte, error)

func (*RateLimitResetType) UnmarshalJSON 

func (r *RateLimitResetType) UnmarshalJSON(data []byte) error

type RateLimitSnapshot 

type RateLimitSnapshot struct {
	LimitID              *string                    `json:"limitId,omitempty"`
	LimitName            *string                    `json:"limitName,omitempty"`
	Primary              *RateLimitWindow           `json:"primary,omitempty"`
	Secondary            *RateLimitWindow           `json:"secondary,omitempty"`
	Credits              *CreditsSnapshot           `json:"credits,omitempty"`
	IndividualLimit      *SpendControlLimitSnapshot `json:"individualLimit,omitempty"`
	PlanType             *PlanType                  `json:"planType,omitempty"`
	RateLimitReachedType *RateLimitReachedType      `json:"rateLimitReachedType,omitempty"`
}

RateLimitSnapshot is a sparse standalone public rate-limit snapshot.

func (RateLimitSnapshot) MarshalJSON 

func (s RateLimitSnapshot) MarshalJSON() ([]byte, error)

func (*RateLimitSnapshot) UnmarshalJSON 

func (s *RateLimitSnapshot) UnmarshalJSON(data []byte) error

type RateLimitWindow 

type RateLimitWindow struct {
	UsedPercent        int32  `json:"usedPercent"`
	WindowDurationMins *int64 `json:"windowDurationMins,omitempty"`
	ResetsAt           *int64 `json:"resetsAt,omitempty"`
}

RateLimitWindow is one exact public usage window.

func (RateLimitWindow) MarshalJSON 

func (w RateLimitWindow) MarshalJSON() ([]byte, error)

func (*RateLimitWindow) UnmarshalJSON 

func (w *RateLimitWindow) UnmarshalJSON(data []byte) error

type RawResponseItemCompletedNotification 

type RawResponseItemCompletedNotification struct {
	ThreadID string       `json:"threadId"`
	TurnID   string       `json:"turnId"`
	Item     ResponseItem `json:"item"`
}

RawResponseItemCompletedNotification is the exact public raw model-response record. It remains unbound until Gollem has a truthful runtime producer.

func (RawResponseItemCompletedNotification) MarshalJSON 

func (n RawResponseItemCompletedNotification) MarshalJSON() ([]byte, error)

func (*RawResponseItemCompletedNotification) UnmarshalJSON 

func (n *RawResponseItemCompletedNotification) UnmarshalJSON(data []byte) error

type ReasoningEffort 

type ReasoningEffort string

ReasoningEffort is a non-empty provider-advertised reasoning effort value. The public TypeScript contract remains string because the value is open.

func (ReasoningEffort) MarshalJSON 

func (e ReasoningEffort) MarshalJSON() ([]byte, error)

func (*ReasoningEffort) UnmarshalJSON 

func (e *ReasoningEffort) UnmarshalJSON(data []byte) error

type ReasoningEffortOption 

type ReasoningEffortOption struct {
	ReasoningEffort ReasoningEffort `json:"reasoningEffort"`
	Description     string          `json:"description"`
}

ReasoningEffortOption is an exact public model-catalog effort choice.

func (*ReasoningEffortOption) UnmarshalJSON 

func (o *ReasoningEffortOption) UnmarshalJSON(data []byte) error

type ReasoningItemContent 

type ReasoningItemContent struct {
	// contains filtered or unexported fields
}

func (ReasoningItemContent) MarshalJSON 

func (c ReasoningItemContent) MarshalJSON() ([]byte, error)

func (*ReasoningItemContent) UnmarshalJSON 

func (c *ReasoningItemContent) UnmarshalJSON(data []byte) error

type ReasoningItemReasoningSummary 

type ReasoningItemReasoningSummary struct {
	// contains filtered or unexported fields
}

func (ReasoningItemReasoningSummary) MarshalJSON 

func (s ReasoningItemReasoningSummary) MarshalJSON() ([]byte, error)

func (*ReasoningItemReasoningSummary) UnmarshalJSON 

func (s *ReasoningItemReasoningSummary) UnmarshalJSON(data []byte) error

type ReasoningSummary 

type ReasoningSummary string
const (
	ReasoningSummaryAuto     ReasoningSummary = "auto"
	ReasoningSummaryConcise  ReasoningSummary = "concise"
	ReasoningSummaryDetailed ReasoningSummary = "detailed"
	ReasoningSummaryNone     ReasoningSummary = "none"
)

func (ReasoningSummary) MarshalJSON 

func (s ReasoningSummary) MarshalJSON() ([]byte, error)

func (*ReasoningSummary) UnmarshalJSON 

func (s *ReasoningSummary) UnmarshalJSON(data []byte) error

type ReasoningSummaryPartAddedNotification 

type ReasoningSummaryPartAddedNotification struct {
	ThreadID     string `json:"threadId"`
	TurnID       string `json:"turnId"`
	ItemID       string `json:"itemId"`
	SummaryIndex int64  `json:"summaryIndex"`
}

func (*ReasoningSummaryPartAddedNotification) UnmarshalJSON 

func (n *ReasoningSummaryPartAddedNotification) UnmarshalJSON(data []byte) error

type ReasoningSummaryTextDeltaNotification 

type ReasoningSummaryTextDeltaNotification struct {
	ThreadID     string `json:"threadId"`
	TurnID       string `json:"turnId"`
	ItemID       string `json:"itemId"`
	Delta        string `json:"delta"`
	SummaryIndex int64  `json:"summaryIndex"`
}

func (*ReasoningSummaryTextDeltaNotification) UnmarshalJSON 

func (n *ReasoningSummaryTextDeltaNotification) UnmarshalJSON(data []byte) error

type ReasoningTextDeltaNotification 

type ReasoningTextDeltaNotification struct {
	ThreadID     string `json:"threadId"`
	TurnID       string `json:"turnId"`
	ItemID       string `json:"itemId"`
	Delta        string `json:"delta"`
	ContentIndex int64  `json:"contentIndex"`
}

func (*ReasoningTextDeltaNotification) UnmarshalJSON 

func (n *ReasoningTextDeltaNotification) UnmarshalJSON(data []byte) error

type Request 

type Request struct {
	JSONRPC string          `json:"-"`
	ID      RequestID       `json:"id"`
	Method  string          `json:"method"`
	Params  json.RawMessage `json:"params,omitempty"`
}

Request is a client-to-server app-server request.

func (Request) MarshalJSON 

func (r Request) MarshalJSON() ([]byte, error)

MarshalJSON emits a Codex-style request envelope without a jsonrpc member.

func (*Request) UnmarshalJSON 

func (r *Request) UnmarshalJSON(data []byte) error

UnmarshalJSON accepts requests with or without the jsonrpc member.

type RequestID 

type RequestID struct {
	// contains filtered or unexported fields
}

RequestID is a JSON-RPC request id. Gollem preserves the original JSON representation so string and numeric ids round-trip without lossy casts.

func NewNumberID 

func NewNumberID(id int64) RequestID

NewNumberID creates a numeric request id.

func NewStringID 

func NewStringID(id string) RequestID

NewStringID creates a string request id.

func (RequestID) IsZero 

func (id RequestID) IsZero() bool

IsZero reports whether the id is unset.

func (RequestID) MarshalJSON 

func (id RequestID) MarshalJSON() ([]byte, error)

MarshalJSON writes the original string or numeric JSON id.

func (RequestID) Raw 

func (id RequestID) Raw() json.RawMessage

Raw returns a copy of the encoded JSON id.

func (*RequestID) UnmarshalJSON 

func (id *RequestID) UnmarshalJSON(data []byte) error

UnmarshalJSON accepts string and numeric request ids.

func (RequestID) Value 

func (id RequestID) Value() any

Value decodes the id to string or json.Number.

type RequestId 

type RequestId = RequestID

RequestId is the exact public app-server name for a JSON-RPC request id. RequestID remains available for Gollem v1 source compatibility.

type RequestPermissionProfile 

type RequestPermissionProfile struct {
	Network    *AdditionalNetworkPermissions    `json:"network"`
	FileSystem *AdditionalFileSystemPermissions `json:"fileSystem"`
}

func (*RequestPermissionProfile) UnmarshalJSON 

func (p *RequestPermissionProfile) UnmarshalJSON(data []byte) error

type ResidencyRequirement 

type ResidencyRequirement string

ResidencyRequirement is the exact closed public residency requirement. 

const ResidencyRequirementUS ResidencyRequirement = "us"

func (ResidencyRequirement) MarshalJSON 

func (r ResidencyRequirement) MarshalJSON() ([]byte, error)

func (*ResidencyRequirement) UnmarshalJSON 

func (r *ResidencyRequirement) UnmarshalJSON(data []byte) error

type Resource 

type Resource struct {
	Annotations *JsonValue   `json:"annotations,omitempty"`
	Description *string      `json:"description,omitempty"`
	MimeType    *string      `json:"mimeType,omitempty"`
	Name        string       `json:"name"`
	Size        *int64       `json:"size,omitempty"`
	Title       *string      `json:"title,omitempty"`
	URI         string       `json:"uri"`
	Icons       *[]JsonValue `json:"icons,omitempty"`
	Meta        *JsonValue   `json:"_meta,omitempty"`
}

Resource is one exact public MCP resource descriptor.

func (Resource) MarshalJSON 

func (r Resource) MarshalJSON() ([]byte, error)

func (*Resource) UnmarshalJSON 

func (r *Resource) UnmarshalJSON(data []byte) error

type ResourceContent 

type ResourceContent struct {
	// contains filtered or unexported fields
}

ResourceContent retains one exact public MCP resource value. It remains standalone until the public resource-read response and live adapter exist.

func (ResourceContent) MarshalJSON 

func (c ResourceContent) MarshalJSON() ([]byte, error)

func (*ResourceContent) UnmarshalJSON 

func (c *ResourceContent) UnmarshalJSON(data []byte) error

type ResourceTemplate 

type ResourceTemplate struct {
	Annotations *JsonValue `json:"annotations,omitempty"`
	URITemplate string     `json:"uriTemplate"`
	Name        string     `json:"name"`
	Title       *string    `json:"title,omitempty"`
	Description *string    `json:"description,omitempty"`
	MimeType    *string    `json:"mimeType,omitempty"`
}

ResourceTemplate is one exact public MCP resource-template descriptor.

func (*ResourceTemplate) UnmarshalJSON 

func (r *ResourceTemplate) UnmarshalJSON(data []byte) error

type Response 

type Response struct {
	JSONRPC string          `json:"-"`
	ID      RequestID       `json:"id"`
	Result  json.RawMessage `json:"result,omitempty"`
	Error   *Error          `json:"error,omitempty"`
}

Response is a server response to a request.

func UnavailableResponse 

func UnavailableResponse(id RequestID, method string) Response

UnavailableResponse builds a JSON-RPC response for a known unavailable method.

func (Response) MarshalJSON 

func (r Response) MarshalJSON() ([]byte, error)

MarshalJSON emits a Codex-style response without a jsonrpc member.

func (*Response) UnmarshalJSON 

func (r *Response) UnmarshalJSON(data []byte) error

UnmarshalJSON accepts responses with or without the jsonrpc member.

type ResponseItem 

type ResponseItem struct {
	// contains filtered or unexported fields
}

ResponseItem retains one validated public model response item. It remains independent from provider payloads and Gollem's durable timeline records.

func (ResponseItem) MarshalJSON 

func (i ResponseItem) MarshalJSON() ([]byte, error)

func (*ResponseItem) UnmarshalJSON 

func (i *ResponseItem) UnmarshalJSON(data []byte) error

type ResponsesApiWebSearchAction 

type ResponsesApiWebSearchAction struct {
	// contains filtered or unexported fields
}

ResponsesApiWebSearchAction is the provider-response action description. It remains distinct from the camel-case app-server WebSearchAction contract.

func (ResponsesApiWebSearchAction) MarshalJSON 

func (a ResponsesApiWebSearchAction) MarshalJSON() ([]byte, error)

func (*ResponsesApiWebSearchAction) UnmarshalJSON 

func (a *ResponsesApiWebSearchAction) UnmarshalJSON(data []byte) error

type ReviewDecision 

type ReviewDecision struct {
	// contains filtered or unexported fields
}

ReviewDecision is the exact legacy public approval decision. It remains separate from Gollem's live command-execution approval decision.

func (ReviewDecision) MarshalJSON 

func (d ReviewDecision) MarshalJSON() ([]byte, error)

func (*ReviewDecision) UnmarshalJSON 

func (d *ReviewDecision) UnmarshalJSON(data []byte) error

type RuntimeDeltaNotification 

type RuntimeDeltaNotification struct {
	ThreadID string    `json:"threadId"`
	TurnID   string    `json:"turnId"`
	Delta    string    `json:"delta"`
	Index    int       `json:"index,omitempty"`
	At       time.Time `json:"at"`
}

type RuntimeModelParams 

type RuntimeModelParams struct {
	ProviderID       string          `json:"providerId,omitempty"`
	Provider         string          `json:"provider,omitempty"`
	Model            string          `json:"model,omitempty"`
	MaxTokens        *int            `json:"maxTokens,omitempty"`
	Temperature      *float64        `json:"temperature,omitempty"`
	TopP             *float64        `json:"topP,omitempty"`
	ThinkingBudget   *int            `json:"thinkingBudget,omitempty"`
	AdaptiveThinking *bool           `json:"adaptiveThinking,omitempty"`
	ReasoningEffort  *string         `json:"reasoningEffort,omitempty"`
	StopSequences    []string        `json:"stopSequences,omitempty"`
	Settings         map[string]any  `json:"settings,omitempty"`
	Input            json.RawMessage `json:"input,omitempty"`
}

type RuntimeThreadNotification 

type RuntimeThreadNotification struct {
	ThreadID string                `json:"threadId"`
	Status   ThreadLifecycleStatus `json:"status,omitempty"`
	Thread   *ThreadRecord         `json:"thread,omitempty"`
	At       time.Time             `json:"at"`
}

type RuntimeTurnNotification 

type RuntimeTurnNotification struct {
	ThreadID string              `json:"threadId"`
	TurnID   string              `json:"turnId"`
	Status   TurnLifecycleStatus `json:"status,omitempty"`
	Turn     *TurnRecord         `json:"turn,omitempty"`
	At       time.Time           `json:"at"`
}

type SandboxMode 

type SandboxMode string

SandboxMode is the exact public request-side mode. The tagged response-side SandboxPolicy and Gollem runtime permission policies remain separate types. 

const (
	SandboxModeReadOnly         SandboxMode = "read-only"
	SandboxModeWorkspaceWrite   SandboxMode = "workspace-write"
	SandboxModeDangerFullAccess SandboxMode = "danger-full-access"
)

func (SandboxMode) MarshalJSON 

func (m SandboxMode) MarshalJSON() ([]byte, error)

func (*SandboxMode) UnmarshalJSON 

func (m *SandboxMode) UnmarshalJSON(data []byte) error

type SandboxPolicy 

type SandboxPolicy struct {
	// contains filtered or unexported fields
}

SandboxPolicy is the exact public sandbox-policy union used by thread responses. It does not replace Gollem's runtime workspace policy.

func (SandboxPolicy) MarshalJSON 

func (p SandboxPolicy) MarshalJSON() ([]byte, error)

func (SandboxPolicy) Type 

func (p SandboxPolicy) Type() string

func (*SandboxPolicy) UnmarshalJSON 

func (p *SandboxPolicy) UnmarshalJSON(data []byte) error

type SandboxWorkspaceWrite 

type SandboxWorkspaceWrite struct {
	WritableRoots       []string `json:"writable_roots"`
	NetworkAccess       bool     `json:"network_access"`
	ExcludeTmpdirEnvVar bool     `json:"exclude_tmpdir_env_var"`
	ExcludeSlashTmp     bool     `json:"exclude_slash_tmp"`
}

SandboxWorkspaceWrite is the exact public writable-workspace sandbox configuration. Unknown fields are accepted for Rust-compatible evolution.

func (SandboxWorkspaceWrite) MarshalJSON 

func (w SandboxWorkspaceWrite) MarshalJSON() ([]byte, error)

func (*SandboxWorkspaceWrite) UnmarshalJSON 

func (w *SandboxWorkspaceWrite) UnmarshalJSON(data []byte) error

type Schema 

type Schema map[string]any

Schema is a JSON Schema document fragment.

func JSONSchema 

func JSONSchema() Schema

JSONSchema returns the foundational app-server envelope, method inventory, exported wire definitions, and their method and durable-item bindings.

type SelectedCapabilityRoot 

type SelectedCapabilityRoot struct {
	ID       string                 `json:"id"`
	Location CapabilityRootLocation `json:"location"`
}

SelectedCapabilityRoot is standalone capability-selection data.

func (*SelectedCapabilityRoot) UnmarshalJSON 

func (r *SelectedCapabilityRoot) UnmarshalJSON(data []byte) error

type SendAddCreditsNudgeEmailParams 

type SendAddCreditsNudgeEmailParams struct {
	CreditType AddCreditsNudgeCreditType `json:"creditType"`
}

SendAddCreditsNudgeEmailParams is exact standalone nudge request data.

func (*SendAddCreditsNudgeEmailParams) UnmarshalJSON 

func (p *SendAddCreditsNudgeEmailParams) UnmarshalJSON(data []byte) error

type SendAddCreditsNudgeEmailResponse 

type SendAddCreditsNudgeEmailResponse struct {
	Status AddCreditsNudgeEmailStatus `json:"status"`
}

SendAddCreditsNudgeEmailResponse is exact standalone nudge outcome data.

func (*SendAddCreditsNudgeEmailResponse) UnmarshalJSON 

func (r *SendAddCreditsNudgeEmailResponse) UnmarshalJSON(data []byte) error

type ServerCapabilities 

type ServerCapabilities struct {
	ProtocolSchema bool     `json:"protocolSchema"`
	Unavailable    bool     `json:"unavailable"`
	Experimental   []string `json:"experimental,omitempty"`
}

ServerCapabilities advertises app-server features available on the current build.

type ServerRequestResolvedNotification 

type ServerRequestResolvedNotification struct {
	ThreadID  string    `json:"threadId"`
	RequestID RequestId `json:"requestId"`
}

type ServerRequestResolvedNotificationParams 

type ServerRequestResolvedNotificationParams = ServerRequestResolvedNotification

type SessionMigration 

type SessionMigration struct {
	Path  string  `json:"path"`
	CWD   string  `json:"cwd"`
	Title *string `json:"title"`
}

SessionMigration describes one external session file and its working path. It remains standalone until the external-agent migration contracts land.

func (*SessionMigration) UnmarshalJSON 

func (m *SessionMigration) UnmarshalJSON(data []byte) error

type SessionSource 

type SessionSource struct {
	// contains filtered or unexported fields
}

func (SessionSource) MarshalJSON 

func (s SessionSource) MarshalJSON() ([]byte, error)

func (*SessionSource) UnmarshalJSON 

func (s *SessionSource) UnmarshalJSON(data []byte) error

type Settings 

type Settings struct {
	Model                 string           `json:"model"`
	ReasoningEffort       *ReasoningEffort `json:"reasoning_effort"`
	DeveloperInstructions *string          `json:"developer_instructions"`
}

Settings is the exact public settings record used by a collaboration mode. Optional serde inputs remain explicit nulls in canonical output.

func (*Settings) UnmarshalJSON 

func (s *Settings) UnmarshalJSON(data []byte) error

type SkillMigration 

type SkillMigration struct {
	Name string `json:"name"`
}

SkillMigration identifies one skill configuration migration. It remains standalone until the external-agent migration contracts land.

func (*SkillMigration) UnmarshalJSON 

func (m *SkillMigration) UnmarshalJSON(data []byte) error

type SortDirection 

type SortDirection string
const (
	SortDirectionAsc  SortDirection = "asc"
	SortDirectionDesc SortDirection = "desc"
)

type SpendControlLimitSnapshot 

type SpendControlLimitSnapshot struct {
	Limit            string `json:"limit"`
	Used             string `json:"used"`
	RemainingPercent int32  `json:"remainingPercent"`
	ResetsAt         int64  `json:"resetsAt"`
}

SpendControlLimitSnapshot is exact public individual spend-control data.

func (SpendControlLimitSnapshot) MarshalJSON 

func (s SpendControlLimitSnapshot) MarshalJSON() ([]byte, error)

func (*SpendControlLimitSnapshot) UnmarshalJSON 

func (s *SpendControlLimitSnapshot) UnmarshalJSON(data []byte) error

type SubAgentActivityKind 

type SubAgentActivityKind string
const (
	SubAgentActivityStarted     SubAgentActivityKind = "started"
	SubAgentActivityInteracted  SubAgentActivityKind = "interacted"
	SubAgentActivityInterrupted SubAgentActivityKind = "interrupted"
)

func (SubAgentActivityKind) MarshalJSON 

func (k SubAgentActivityKind) MarshalJSON() ([]byte, error)

func (*SubAgentActivityKind) UnmarshalJSON 

func (k *SubAgentActivityKind) UnmarshalJSON(data []byte) error

type SubAgentSource 

type SubAgentSource struct {
	// contains filtered or unexported fields
}

func (SubAgentSource) MarshalJSON 

func (s SubAgentSource) MarshalJSON() ([]byte, error)

func (*SubAgentSource) UnmarshalJSON 

func (s *SubAgentSource) UnmarshalJSON(data []byte) error

type SubagentMigration 

type SubagentMigration struct {
	Name string `json:"name"`
}

SubagentMigration identifies one subagent configuration migration. It remains standalone until the external-agent migration contracts land.

func (*SubagentMigration) UnmarshalJSON 

func (m *SubagentMigration) UnmarshalJSON(data []byte) error

type Surface 

type Surface string

Surface is the JSON-RPC direction or Gollem extension source for a method. 

const (
	SurfaceClientRequest      Surface = "client-request"
	SurfaceServerNotification Surface = "server-notification"
	SurfaceServerRequest      Surface = "server-request"
	SurfaceClientNotification Surface = "client-notification"
	SurfaceGollemExtension    Surface = "gollem-extension"
)

type TextElement 

type TextElement struct {
	ByteRange   ByteRange `json:"byteRange"`
	Placeholder *string   `json:"placeholder"`
}

func (*TextElement) UnmarshalJSON 

func (e *TextElement) UnmarshalJSON(data []byte) error

type TextPosition 

type TextPosition struct {
	Line   uint64 `json:"line"`
	Column uint64 `json:"column"`
}

TextPosition is the exact fixed public config-diagnostic position value. Coordinates are documented as 1-based, but zero remains valid on the wire.

func (*TextPosition) UnmarshalJSON 

func (p *TextPosition) UnmarshalJSON(data []byte) error

type TextRange 

type TextRange struct {
	Start TextPosition `json:"start"`
	End   TextPosition `json:"end"`
}

TextRange is the exact fixed public config-diagnostic range value.

func (*TextRange) UnmarshalJSON 

func (r *TextRange) UnmarshalJSON(data []byte) error

type Thread 

type Thread struct {
	ID             string          `json:"id"`
	SessionID      string          `json:"sessionId"`
	ForkedFromID   *string         `json:"forkedFromId"`
	ParentThreadID *string         `json:"parentThreadId"`
	Preview        string          `json:"preview"`
	Ephemeral      bool            `json:"ephemeral"`
	ModelProvider  string          `json:"modelProvider"`
	CreatedAt      int64           `json:"createdAt"`
	UpdatedAt      int64           `json:"updatedAt"`
	RecencyAt      *int64          `json:"recencyAt"`
	Status         ThreadStatus    `json:"status"`
	Path           *string         `json:"path"`
	CWD            AbsolutePathBuf `json:"cwd"`
	CLIVersion     string          `json:"cliVersion"`
	Source         SessionSource   `json:"source"`
	ThreadSource   *ThreadSource   `json:"threadSource"`
	AgentNickname  *string         `json:"agentNickname"`
	AgentRole      *string         `json:"agentRole"`
	GitInfo        *GitInfo        `json:"gitInfo"`
	Name           *string         `json:"name"`
	Turns          []Turn          `json:"turns" jsonschema:"nonnullable=true"`
}

Thread is the exact public v2 thread projection. It remains separate from Gollem's durable ThreadRecord and is not yet bound to thread methods.

func (Thread) MarshalJSON 

func (t Thread) MarshalJSON() ([]byte, error)

func (*Thread) UnmarshalJSON 

func (t *Thread) UnmarshalJSON(data []byte) error

type ThreadActiveFlag 

type ThreadActiveFlag string
const (
	ThreadActiveFlagWaitingOnApproval  ThreadActiveFlag = "waitingOnApproval"
	ThreadActiveFlagWaitingOnUserInput ThreadActiveFlag = "waitingOnUserInput"
)

func (ThreadActiveFlag) MarshalJSON 

func (f ThreadActiveFlag) MarshalJSON() ([]byte, error)

func (*ThreadActiveFlag) UnmarshalJSON 

func (f *ThreadActiveFlag) UnmarshalJSON(data []byte) error

type ThreadArchiveParams 

type ThreadArchiveParams struct {
	ThreadID string `json:"threadId"`
	ID       string `json:"id,omitempty"`
}

func (ThreadArchiveParams) EffectiveThreadID 

func (p ThreadArchiveParams) EffectiveThreadID() string

type ThreadArchiveResponse 

type ThreadArchiveResponse struct {
	Thread *ThreadRecord `json:"thread,omitempty"`
}

type ThreadArchivedNotification 

type ThreadArchivedNotification struct {
	ThreadID string                `json:"threadId"`
	Status   ThreadLifecycleStatus `json:"status,omitempty"`
	Thread   *ThreadRecord         `json:"thread,omitempty"`
	At       *time.Time            `json:"at,omitempty"`
}

type ThreadClosedNotification 

type ThreadClosedNotification struct {
	ThreadID string `json:"threadId"`
}

type ThreadCompactStartParams 

type ThreadCompactStartParams struct {
	ID       string `json:"id,omitempty"`
	ThreadID string `json:"threadId,omitempty"`
}

type ThreadCompactStartResponse 

type ThreadCompactStartResponse struct{}

type ThreadCompactedNotificationParams 

type ThreadCompactedNotificationParams = ContextCompactedNotification

Gollem v1 compatibility aliases. New bindings use the exact public names.

type ThreadDeleteParams 

type ThreadDeleteParams struct {
	ThreadID string `json:"threadId"`
	ID       string `json:"id,omitempty"`
}

func (ThreadDeleteParams) EffectiveThreadID 

func (p ThreadDeleteParams) EffectiveThreadID() string

type ThreadDeleteResponse 

type ThreadDeleteResponse struct {
	Thread *ThreadRecord `json:"thread,omitempty"`
}

type ThreadDeletedNotification 

type ThreadDeletedNotification struct {
	ThreadID string                `json:"threadId"`
	Status   ThreadLifecycleStatus `json:"status,omitempty"`
	Thread   *ThreadRecord         `json:"thread,omitempty"`
	At       *time.Time            `json:"at,omitempty"`
}

type ThreadForkParams 

type ThreadForkParams struct {
	ThreadID              string                `json:"threadId"`
	LastTurnID            *string               `json:"lastTurnId,omitempty"`
	Model                 *string               `json:"model,omitempty"`
	ModelProvider         *string               `json:"modelProvider,omitempty"`
	ServiceTier           *string               `json:"serviceTier,omitempty"`
	CWD                   *string               `json:"cwd,omitempty"`
	ApprovalPolicy        *AskForApproval       `json:"approvalPolicy,omitempty"`
	ApprovalsReviewer     *ApprovalsReviewer    `json:"approvalsReviewer,omitempty"`
	Sandbox               *SandboxMode          `json:"sandbox,omitempty"`
	Config                *map[string]JsonValue `json:"config,omitempty"`
	BaseInstructions      *string               `json:"baseInstructions,omitempty"`
	DeveloperInstructions *string               `json:"developerInstructions,omitempty"`
	Ephemeral             *bool                 `json:"ephemeral,omitempty"`
	ThreadSource          *ThreadSource         `json:"threadSource,omitempty"`
}

func (*ThreadForkParams) UnmarshalJSON 

func (p *ThreadForkParams) UnmarshalJSON(data []byte) error

type ThreadForkResponse 

type ThreadForkResponse threadSessionResponse

func (ThreadForkResponse) MarshalJSON 

func (r ThreadForkResponse) MarshalJSON() ([]byte, error)

func (*ThreadForkResponse) UnmarshalJSON 

func (r *ThreadForkResponse) UnmarshalJSON(data []byte) error

type ThreadGoal 

type ThreadGoal struct {
	ThreadID        string           `json:"threadId"`
	Objective       string           `json:"objective"`
	Status          ThreadGoalStatus `json:"status"`
	TokenBudget     *int64           `json:"tokenBudget"`
	TokensUsed      int64            `json:"tokensUsed"`
	TimeUsedSeconds int64            `json:"timeUsedSeconds"`
	CreatedAt       int64            `json:"createdAt"`
	UpdatedAt       int64            `json:"updatedAt"`
}

type ThreadGoalClearParams 

type ThreadGoalClearParams struct {
	ThreadID string `json:"threadId,omitempty"`
	ID       string `json:"id,omitempty"`
}

func (ThreadGoalClearParams) EffectiveThreadID 

func (p ThreadGoalClearParams) EffectiveThreadID() string

type ThreadGoalClearResponse 

type ThreadGoalClearResponse struct {
	Cleared  bool          `json:"cleared"`
	ThreadID string        `json:"threadId,omitempty"`
	Thread   *ThreadRecord `json:"thread,omitempty"`
}

type ThreadGoalClearedNotification 

type ThreadGoalClearedNotification struct {
	ThreadID string        `json:"threadId"`
	Thread   *ThreadRecord `json:"thread,omitempty"`
	At       *time.Time    `json:"at,omitempty"`
}

type ThreadGoalGetParams 

type ThreadGoalGetParams struct {
	ThreadID string `json:"threadId,omitempty"`
	ID       string `json:"id,omitempty"`
}

func (ThreadGoalGetParams) EffectiveThreadID 

func (p ThreadGoalGetParams) EffectiveThreadID() string

type ThreadGoalGetResponse 

type ThreadGoalGetResponse struct {
	Goal     *ThreadGoal   `json:"goal"`
	ThreadID string        `json:"threadId,omitempty"`
	Set      *bool         `json:"set,omitempty"`
	Thread   *ThreadRecord `json:"thread,omitempty"`
}

type ThreadGoalSetParams 

type ThreadGoalSetParams struct {
	ThreadID    string            `json:"threadId,omitempty"`
	Objective   *string           `json:"objective,omitempty"`
	Status      *ThreadGoalStatus `json:"status,omitempty"`
	TokenBudget *int64            `json:"tokenBudget,omitempty"`
	ID          string            `json:"id,omitempty"`
	Goal        json.RawMessage   `json:"goal,omitempty"`
	Text        json.RawMessage   `json:"text,omitempty"`
	Value       json.RawMessage   `json:"value,omitempty"`
	// contains filtered or unexported fields
}

func (ThreadGoalSetParams) EffectiveThreadID 

func (p ThreadGoalSetParams) EffectiveThreadID() string

func (ThreadGoalSetParams) HasTokenBudget 

func (p ThreadGoalSetParams) HasTokenBudget() bool

func (ThreadGoalSetParams) LegacyGoal 

func (p ThreadGoalSetParams) LegacyGoal() (json.RawMessage, bool)

func (ThreadGoalSetParams) MarshalJSON 

func (p ThreadGoalSetParams) MarshalJSON() ([]byte, error)

func (*ThreadGoalSetParams) SetTokenBudget 

func (p *ThreadGoalSetParams) SetTokenBudget(value *int64)

func (*ThreadGoalSetParams) UnmarshalJSON 

func (p *ThreadGoalSetParams) UnmarshalJSON(data []byte) error

type ThreadGoalSetResponse 

type ThreadGoalSetResponse struct {
	Goal     ThreadGoal    `json:"goal"`
	ThreadID string        `json:"threadId,omitempty"`
	Set      *bool         `json:"set,omitempty"`
	Thread   *ThreadRecord `json:"thread,omitempty"`
}

type ThreadGoalStatus 

type ThreadGoalStatus string
const (
	ThreadGoalActive        ThreadGoalStatus = "active"
	ThreadGoalPaused        ThreadGoalStatus = "paused"
	ThreadGoalBlocked       ThreadGoalStatus = "blocked"
	ThreadGoalUsageLimited  ThreadGoalStatus = "usageLimited"
	ThreadGoalBudgetLimited ThreadGoalStatus = "budgetLimited"
	ThreadGoalComplete      ThreadGoalStatus = "complete"
)

func (ThreadGoalStatus) Valid 

func (s ThreadGoalStatus) Valid() bool

type ThreadGoalUpdatedNotification 

type ThreadGoalUpdatedNotification struct {
	ThreadID string        `json:"threadId"`
	TurnID   *string       `json:"turnId"`
	Goal     ThreadGoal    `json:"goal"`
	Thread   *ThreadRecord `json:"thread,omitempty"`
	At       *time.Time    `json:"at,omitempty"`
}

type ThreadHistoryForkParams added in v0.8.0 

type ThreadHistoryForkParams struct {
	ThreadID       string `json:"threadId"`
	IdempotencyKey string `json:"idempotencyKey"`
}

ThreadHistoryForkParams is Gollem's response-loss-safe full-history fork request. It is distinct from the broader standalone public session contract.

func (*ThreadHistoryForkParams) UnmarshalJSON added in v0.8.0 

func (p *ThreadHistoryForkParams) UnmarshalJSON(data []byte) error

type ThreadHistoryForkResult added in v0.8.0 

type ThreadHistoryForkResult struct {
	Thread                        ThreadRecord `json:"thread"`
	SourceThreadID                string       `json:"sourceThreadId"`
	IdempotencyKey                string       `json:"idempotencyKey"`
	Reused                        bool         `json:"reused"`
	HistoryCopied                 bool         `json:"historyCopied"`
	FileChangeRecoveryTransferred bool         `json:"fileChangeRecoveryTransferred"`
}

type ThreadHistoryRollbackParams 

type ThreadHistoryRollbackParams struct {
	ThreadID string `json:"threadId"`
	NumTurns int    `json:"numTurns"`
	ID       string `json:"id,omitempty"`
}

ThreadHistoryRollbackParams is Gollem's typed history-only rollback request. The legacy id alias remains available for protocol-v1 clients, while typed clients use the required threadId field.

func (ThreadHistoryRollbackParams) EffectiveThreadID 

func (p ThreadHistoryRollbackParams) EffectiveThreadID() string

type ThreadHistoryRollbackRecord 

type ThreadHistoryRollbackRecord struct {
	ID                 string                `json:"id"`
	Title              string                `json:"title,omitempty"`
	Workspace          string                `json:"workspace,omitempty"`
	Status             ThreadLifecycleStatus `json:"status"`
	ForkedFromThreadID string                `json:"forkedFromThreadId,omitempty"`
	Settings           map[string]any        `json:"settings,omitempty"`
	Metadata           map[string]any        `json:"metadata,omitempty"`
	CreatedAt          time.Time             `json:"createdAt"`
	UpdatedAt          time.Time             `json:"updatedAt"`
	ArchivedAt         time.Time             `json:"archivedAt,omitempty"`
	DeletedAt          time.Time             `json:"deletedAt,omitempty"`
	Name               *string               `json:"name"`
	Turns              []TurnRecord          `json:"turns" jsonschema:"nonnullable=true"`
}

ThreadHistoryRollbackRecord preserves the existing rollback response shape, including the legacy nullable name alias and fully loaded remaining turns.

type ThreadHistoryRollbackResult 

type ThreadHistoryRollbackResult struct {
	Thread                   ThreadHistoryRollbackRecord `json:"thread"`
	RemovedTurnIDs           []string                    `json:"removedTurnIds" jsonschema:"nonnullable=true"`
	Marker                   TimelineItem                `json:"marker"`
	WorkspaceEffectsReverted bool                        `json:"workspaceEffectsReverted"`
}

ThreadHistoryRollbackResult is explicit that this operation prunes durable history only. It never claims to undo workspace, process, Git, or provider side effects.

type ThreadId 

type ThreadId string

ThreadId matches the generated public identifier contract. Generation uses UUIDv7 values, but the standalone wire type is intentionally any string.

func (ThreadId) MarshalJSON 

func (id ThreadId) MarshalJSON() ([]byte, error)

func (*ThreadId) UnmarshalJSON 

func (id *ThreadId) UnmarshalJSON(data []byte) error

type ThreadItem 

type ThreadItem struct {
	// contains filtered or unexported fields
}

ThreadItem retains one validated public v2 thread item. It remains separate from Gollem's live item notifications and durable timeline records.

func (ThreadItem) MarshalJSON 

func (i ThreadItem) MarshalJSON() ([]byte, error)

func (*ThreadItem) UnmarshalJSON 

func (i *ThreadItem) UnmarshalJSON(data []byte) error

type ThreadLifecycleStatus 

type ThreadLifecycleStatus string

ThreadLifecycleStatus is Gollem's durable persistence lifecycle. It is intentionally distinct from Codex's runtime-oriented ThreadStatus. 

const (
	ThreadLifecycleActive   ThreadLifecycleStatus = "active"
	ThreadLifecycleArchived ThreadLifecycleStatus = "archived"
	ThreadLifecycleDeleted  ThreadLifecycleStatus = "deleted"
)

type ThreadListCwdFilter 

type ThreadListCwdFilter struct {
	// contains filtered or unexported fields
}

ThreadListCwdFilter preserves the public string-or-array wire union.

func NewThreadListCwdFilter 

func NewThreadListCwdFilter(path string) ThreadListCwdFilter

func NewThreadListCwdFilters 

func NewThreadListCwdFilters(paths []string) ThreadListCwdFilter

func (ThreadListCwdFilter) MarshalJSON 

func (f ThreadListCwdFilter) MarshalJSON() ([]byte, error)

func (ThreadListCwdFilter) Paths 

func (f ThreadListCwdFilter) Paths() []string

func (*ThreadListCwdFilter) UnmarshalJSON 

func (f *ThreadListCwdFilter) UnmarshalJSON(data []byte) error

type ThreadListParams 

type ThreadListParams struct {
	Cursor         *string                 `json:"cursor,omitempty"`
	Limit          *uint32                 `json:"limit,omitempty"`
	SortKey        *ThreadSortKey          `json:"sortKey,omitempty"`
	SortDirection  *SortDirection          `json:"sortDirection,omitempty"`
	ModelProviders []string                `json:"modelProviders,omitempty"`
	SourceKinds    []ThreadSourceKind      `json:"sourceKinds,omitempty"`
	Archived       *bool                   `json:"archived,omitempty"`
	CWD            *ThreadListCwdFilter    `json:"cwd,omitempty"`
	UseStateDBOnly bool                    `json:"useStateDbOnly,omitempty"`
	SearchTerm     *string                 `json:"searchTerm,omitempty"`
	Statuses       []ThreadLifecycleStatus `json:"statuses,omitempty"`
	IncludeDeleted bool                    `json:"includeDeleted,omitempty"`
}

ThreadListParams accepts the public Codex discovery filters plus Gollem's explicit durable-lifecycle compatibility filters.

type ThreadListResponse 

type ThreadListResponse struct {
	Data            []Thread `json:"data" jsonschema:"nonnullable=true"`
	NextCursor      *string  `json:"nextCursor"`
	BackwardsCursor *string  `json:"backwardsCursor"`
}

func (ThreadListResponse) MarshalJSON 

func (r ThreadListResponse) MarshalJSON() ([]byte, error)

func (*ThreadListResponse) UnmarshalJSON 

func (r *ThreadListResponse) UnmarshalJSON(data []byte) error

type ThreadListResult 

type ThreadListResult struct {
	Data            []ThreadRecord `json:"data" jsonschema:"nonnullable=true"`
	NextCursor      *string        `json:"nextCursor,omitempty"`
	BackwardsCursor *string        `json:"backwardsCursor,omitempty"`
	Threads         []ThreadRecord `json:"threads" jsonschema:"nonnullable=true,optional=true"`
}

ThreadListResult adds Codex-compatible data/cursor fields while retaining the legacy Gollem threads field for protocol-v1 compatibility.

type ThreadLoadedListParams 

type ThreadLoadedListParams struct {
	Cursor *string `json:"cursor,omitempty"`
	Limit  *uint32 `json:"limit,omitempty"`
}

type ThreadLoadedListResponse 

type ThreadLoadedListResponse struct {
	Data       []string `json:"data" jsonschema:"nonnullable=true"`
	NextCursor *string  `json:"nextCursor" jsonschema:"optional=true"`
}

type ThreadMemoryMode 

type ThreadMemoryMode string
const (
	ThreadMemoryModeEnabled  ThreadMemoryMode = "enabled"
	ThreadMemoryModeDisabled ThreadMemoryMode = "disabled"
)

func (ThreadMemoryMode) Valid 

func (m ThreadMemoryMode) Valid() bool

type ThreadMemoryModeSetParams 

type ThreadMemoryModeSetParams struct {
	ThreadID   string           `json:"threadId,omitempty"`
	Mode       ThreadMemoryMode `json:"mode,omitempty"`
	ID         string           `json:"id,omitempty"`
	MemoryMode ThreadMemoryMode `json:"memoryMode,omitempty"`
}

func (ThreadMemoryModeSetParams) EffectiveMode 

func (p ThreadMemoryModeSetParams) EffectiveMode() ThreadMemoryMode

func (ThreadMemoryModeSetParams) EffectiveThreadID 

func (p ThreadMemoryModeSetParams) EffectiveThreadID() string

type ThreadMemoryModeSetResponse 

type ThreadMemoryModeSetResponse struct {
	ThreadID   string           `json:"threadId,omitempty"`
	MemoryMode ThreadMemoryMode `json:"memoryMode,omitempty"`
	Thread     *ThreadRecord    `json:"thread,omitempty"`
}

type ThreadMetadataGitInfoUpdateParams 

type ThreadMetadataGitInfoUpdateParams struct {
	SHA       *string `json:"sha,omitempty"`
	Branch    *string `json:"branch,omitempty"`
	OriginURL *string `json:"originUrl,omitempty"`
	// contains filtered or unexported fields
}

func (ThreadMetadataGitInfoUpdateParams) HasBranch 

func (p ThreadMetadataGitInfoUpdateParams) HasBranch() bool

func (ThreadMetadataGitInfoUpdateParams) HasOriginURL 

func (p ThreadMetadataGitInfoUpdateParams) HasOriginURL() bool

func (ThreadMetadataGitInfoUpdateParams) HasPatch 

func (p ThreadMetadataGitInfoUpdateParams) HasPatch() bool

func (ThreadMetadataGitInfoUpdateParams) HasSHA 

func (p ThreadMetadataGitInfoUpdateParams) HasSHA() bool

func (ThreadMetadataGitInfoUpdateParams) MarshalJSON 

func (p ThreadMetadataGitInfoUpdateParams) MarshalJSON() ([]byte, error)

func (*ThreadMetadataGitInfoUpdateParams) SetBranch 

func (p *ThreadMetadataGitInfoUpdateParams) SetBranch(value *string)

func (*ThreadMetadataGitInfoUpdateParams) SetOriginURL 

func (p *ThreadMetadataGitInfoUpdateParams) SetOriginURL(value *string)

func (*ThreadMetadataGitInfoUpdateParams) SetSHA 

func (p *ThreadMetadataGitInfoUpdateParams) SetSHA(value *string)

func (*ThreadMetadataGitInfoUpdateParams) UnmarshalJSON 

func (p *ThreadMetadataGitInfoUpdateParams) UnmarshalJSON(data []byte) error

type ThreadMetadataUpdateParams 

type ThreadMetadataUpdateParams struct {
	ThreadID string                             `json:"threadId,omitempty"`
	GitInfo  *ThreadMetadataGitInfoUpdateParams `json:"gitInfo,omitempty"`
	ID       string                             `json:"id,omitempty"`
	Metadata map[string]any                     `json:"metadata,omitempty"`
	Replace  bool                               `json:"replace,omitempty"`
	// contains filtered or unexported fields
}

func (ThreadMetadataUpdateParams) EffectiveThreadID 

func (p ThreadMetadataUpdateParams) EffectiveThreadID() string

func (ThreadMetadataUpdateParams) HasGitInfo 

func (p ThreadMetadataUpdateParams) HasGitInfo() bool

func (ThreadMetadataUpdateParams) MarshalJSON 

func (p ThreadMetadataUpdateParams) MarshalJSON() ([]byte, error)

func (*ThreadMetadataUpdateParams) SetGitInfo 

func (p *ThreadMetadataUpdateParams) SetGitInfo(value *ThreadMetadataGitInfoUpdateParams)

func (*ThreadMetadataUpdateParams) UnmarshalJSON 

func (p *ThreadMetadataUpdateParams) UnmarshalJSON(data []byte) error

type ThreadMetadataUpdateResponse 

type ThreadMetadataUpdateResponse struct {
	Thread Thread `json:"thread"`
}

func (*ThreadMetadataUpdateResponse) UnmarshalJSON 

func (r *ThreadMetadataUpdateResponse) UnmarshalJSON(data []byte) error

type ThreadMetadataUpdateResult 

type ThreadMetadataUpdateResult struct {
	Thread   ThreadRecord   `json:"thread"`
	Metadata map[string]any `json:"metadata,omitempty"`
}

type ThreadNameUpdatedNotification 

type ThreadNameUpdatedNotification struct {
	ThreadID   string        `json:"threadId"`
	ThreadName *string       `json:"threadName,omitempty" jsonschema:"nonnullable=true"`
	Name       string        `json:"name,omitempty"`
	Thread     *ThreadRecord `json:"thread,omitempty"`
	At         *time.Time    `json:"at,omitempty"`
}

type ThreadReadParams 

type ThreadReadParams struct {
	ThreadID     string `json:"threadId"`
	IncludeTurns *bool  `json:"includeTurns,omitempty" jsonschema:"nonnullable=true"`
	ID           string `json:"id,omitempty"`
	IncludeItems *bool  `json:"includeItems,omitempty"`
	AfterSeq     int64  `json:"afterSeq,omitempty"`
	Limit        int    `json:"limit,omitempty"`
}

ThreadReadParams keeps only threadId/includeTurns in the public contract; the remaining fields are named Gollem protocol-v1 extensions.

func (ThreadReadParams) EffectiveThreadID 

func (p ThreadReadParams) EffectiveThreadID() string

type ThreadReadResponse 

type ThreadReadResponse struct {
	Thread Thread `json:"thread"`
}

func (*ThreadReadResponse) UnmarshalJSON 

func (r *ThreadReadResponse) UnmarshalJSON(data []byte) error

type ThreadReadResult 

type ThreadReadResult struct {
	Thread ThreadRecord   `json:"thread"`
	Turns  []TurnRecord   `json:"turns,omitempty" jsonschema:"nonnullable=true"`
	Items  []TimelineItem `json:"items,omitempty" jsonschema:"nonnullable=true"`
}

ThreadReadResult retains protocol-v1 top-level turns/items while also nesting loaded turns/items in Thread for forward client consumption.

type ThreadRecord 

type ThreadRecord struct {
	ID                 string                `json:"id"`
	Title              string                `json:"title,omitempty"`
	Workspace          string                `json:"workspace,omitempty"`
	Status             ThreadLifecycleStatus `json:"status"`
	ForkedFromThreadID string                `json:"forkedFromThreadId,omitempty"`
	Settings           map[string]any        `json:"settings,omitempty"`
	Metadata           map[string]any        `json:"metadata,omitempty"`
	CreatedAt          time.Time             `json:"createdAt"`
	UpdatedAt          time.Time             `json:"updatedAt"`
	ArchivedAt         time.Time             `json:"archivedAt,omitempty"`
	DeletedAt          time.Time             `json:"deletedAt,omitempty"`
	Turns              []TurnRecord          `json:"turns,omitempty" jsonschema:"nonnullable=true"`
}

ThreadRecord is Gollem's exported durable thread record. The status field is persistence lifecycle, not Codex runtime ThreadStatus.

type ThreadResumeInitialTurnsPageParams 

type ThreadResumeInitialTurnsPageParams struct {
	Limit         *uint32        `json:"limit,omitempty"`
	SortDirection *SortDirection `json:"sortDirection,omitempty"`
	ItemsView     *TurnItemsView `json:"itemsView,omitempty"`
}

ThreadResumeInitialTurnsPageParams is the exact experimental initial-turn page selector. It remains standalone from the fixed thread/resume contract.

func (ThreadResumeInitialTurnsPageParams) MarshalJSON 

func (p ThreadResumeInitialTurnsPageParams) MarshalJSON() ([]byte, error)

func (*ThreadResumeInitialTurnsPageParams) UnmarshalJSON 

func (p *ThreadResumeInitialTurnsPageParams) UnmarshalJSON(data []byte) error

type ThreadResumeParams 

type ThreadResumeParams struct {
	ThreadID              string                `json:"threadId"`
	Model                 *string               `json:"model,omitempty"`
	ModelProvider         *string               `json:"modelProvider,omitempty"`
	ServiceTier           *string               `json:"serviceTier,omitempty"`
	CWD                   *string               `json:"cwd,omitempty"`
	ApprovalPolicy        *AskForApproval       `json:"approvalPolicy,omitempty"`
	ApprovalsReviewer     *ApprovalsReviewer    `json:"approvalsReviewer,omitempty"`
	Sandbox               *SandboxMode          `json:"sandbox,omitempty"`
	Config                *map[string]JsonValue `json:"config,omitempty"`
	BaseInstructions      *string               `json:"baseInstructions,omitempty"`
	DeveloperInstructions *string               `json:"developerInstructions,omitempty"`
	Personality           *Personality          `json:"personality,omitempty"`
}

func (*ThreadResumeParams) UnmarshalJSON 

func (p *ThreadResumeParams) UnmarshalJSON(data []byte) error

type ThreadResumeResponse 

type ThreadResumeResponse threadSessionResponse

func (ThreadResumeResponse) MarshalJSON 

func (r ThreadResumeResponse) MarshalJSON() ([]byte, error)

func (*ThreadResumeResponse) UnmarshalJSON 

func (r *ThreadResumeResponse) UnmarshalJSON(data []byte) error

type ThreadRunStartParams 

type ThreadRunStartParams struct {
	Title     string         `json:"title,omitempty"`
	Workspace string         `json:"workspace,omitempty"`
	Prompt    string         `json:"prompt,omitempty"`
	Message   string         `json:"message,omitempty"`
	Text      string         `json:"text,omitempty"`
	Metadata  map[string]any `json:"metadata,omitempty"`
	RuntimeModelParams
}

type ThreadRunStartResult 

type ThreadRunStartResult struct {
	Thread ThreadRecord `json:"thread"`
	Turn   TurnRecord   `json:"turn"`
}

type ThreadSetNameParams 

type ThreadSetNameParams struct {
	ThreadID string `json:"threadId"`
	Name     string `json:"name"`
	ID       string `json:"id,omitempty"`
	Title    string `json:"title,omitempty"`
}

func (ThreadSetNameParams) EffectiveName 

func (p ThreadSetNameParams) EffectiveName() string

func (ThreadSetNameParams) EffectiveThreadID 

func (p ThreadSetNameParams) EffectiveThreadID() string

type ThreadSetNameResponse 

type ThreadSetNameResponse struct {
	ThreadID string        `json:"threadId,omitempty"`
	Name     string        `json:"name,omitempty"`
	Thread   *ThreadRecord `json:"thread,omitempty"`
}

type ThreadSortKey 

type ThreadSortKey string
const (
	ThreadSortCreatedAt ThreadSortKey = "created_at"
	ThreadSortUpdatedAt ThreadSortKey = "updated_at"
	ThreadSortRecencyAt ThreadSortKey = "recency_at"
)

type ThreadSource 

type ThreadSource string

ThreadSource is the public thread-provenance string. Gollem's filter-facing ThreadSourceKind remains a separate closed enum.

func (ThreadSource) MarshalJSON 

func (s ThreadSource) MarshalJSON() ([]byte, error)

func (*ThreadSource) UnmarshalJSON 

func (s *ThreadSource) UnmarshalJSON(data []byte) error

type ThreadSourceKind 

type ThreadSourceKind string
const (
	ThreadSourceCLI             ThreadSourceKind = "cli"
	ThreadSourceVSCode          ThreadSourceKind = "vscode"
	ThreadSourceExec            ThreadSourceKind = "exec"
	ThreadSourceAppServer       ThreadSourceKind = "appServer"
	ThreadSourceSubAgent        ThreadSourceKind = "subAgent"
	ThreadSourceSubAgentReview  ThreadSourceKind = "subAgentReview"
	ThreadSourceSubAgentCompact ThreadSourceKind = "subAgentCompact"
	ThreadSourceSubAgentSpawn   ThreadSourceKind = "subAgentThreadSpawn"
	ThreadSourceSubAgentOther   ThreadSourceKind = "subAgentOther"
	ThreadSourceUnknown         ThreadSourceKind = "unknown"
)

type ThreadStartParams 

type ThreadStartParams struct {
	Model                 *string               `json:"model,omitempty"`
	ModelProvider         *string               `json:"modelProvider,omitempty"`
	ServiceTier           *string               `json:"serviceTier,omitempty"`
	CWD                   *string               `json:"cwd,omitempty"`
	ApprovalPolicy        *AskForApproval       `json:"approvalPolicy,omitempty"`
	ApprovalsReviewer     *ApprovalsReviewer    `json:"approvalsReviewer,omitempty"`
	Sandbox               *SandboxMode          `json:"sandbox,omitempty"`
	Config                *map[string]JsonValue `json:"config,omitempty"`
	ServiceName           *string               `json:"serviceName,omitempty"`
	BaseInstructions      *string               `json:"baseInstructions,omitempty"`
	DeveloperInstructions *string               `json:"developerInstructions,omitempty"`
	Personality           *Personality          `json:"personality,omitempty"`
	Ephemeral             *bool                 `json:"ephemeral,omitempty"`
	SessionStartSource    *ThreadStartSource    `json:"sessionStartSource,omitempty"`
	ThreadSource          *ThreadSource         `json:"threadSource,omitempty"`
}

func (*ThreadStartParams) UnmarshalJSON 

func (p *ThreadStartParams) UnmarshalJSON(data []byte) error

type ThreadStartResponse 

type ThreadStartResponse threadSessionResponse

func (ThreadStartResponse) MarshalJSON 

func (r ThreadStartResponse) MarshalJSON() ([]byte, error)

func (*ThreadStartResponse) UnmarshalJSON 

func (r *ThreadStartResponse) UnmarshalJSON(data []byte) error

type ThreadStartSource 

type ThreadStartSource string

ThreadStartSource is the exact start-request source enum. It is distinct from public provenance, list-filter source kinds, and session provenance. 

const (
	ThreadStartSourceStartup ThreadStartSource = "startup"
	ThreadStartSourceClear   ThreadStartSource = "clear"
)

func (ThreadStartSource) MarshalJSON 

func (s ThreadStartSource) MarshalJSON() ([]byte, error)

func (*ThreadStartSource) UnmarshalJSON 

func (s *ThreadStartSource) UnmarshalJSON(data []byte) error

type ThreadStartedNotification 

type ThreadStartedNotification struct {
	Thread Thread `json:"thread"`
}

func (*ThreadStartedNotification) UnmarshalJSON 

func (n *ThreadStartedNotification) UnmarshalJSON(data []byte) error

type ThreadStatus 

type ThreadStatus struct {
	// contains filtered or unexported fields
}

func (ThreadStatus) MarshalJSON 

func (s ThreadStatus) MarshalJSON() ([]byte, error)

func (*ThreadStatus) UnmarshalJSON 

func (s *ThreadStatus) UnmarshalJSON(data []byte) error

type ThreadStatusChangedNotification 

type ThreadStatusChangedNotification struct {
	ThreadID string       `json:"threadId"`
	Status   ThreadStatus `json:"status"`
}

func (*ThreadStatusChangedNotification) UnmarshalJSON 

func (n *ThreadStatusChangedNotification) UnmarshalJSON(data []byte) error

type ThreadTokenUsage 

type ThreadTokenUsage struct {
	Total              TokenUsageBreakdown `json:"total"`
	Last               TokenUsageBreakdown `json:"last"`
	ModelContextWindow *int64              `json:"modelContextWindow"`
}

type ThreadTokenUsageUpdatedNotification 

type ThreadTokenUsageUpdatedNotification struct {
	ThreadID   string           `json:"threadId"`
	TurnID     string           `json:"turnId"`
	TokenUsage ThreadTokenUsage `json:"tokenUsage"`
}

type ThreadTokenUsageUpdatedNotificationParams 

type ThreadTokenUsageUpdatedNotificationParams = ThreadTokenUsageUpdatedNotification

type ThreadUnarchiveParams 

type ThreadUnarchiveParams struct {
	ThreadID string `json:"threadId"`
	ID       string `json:"id,omitempty"`
}

func (ThreadUnarchiveParams) EffectiveThreadID 

func (p ThreadUnarchiveParams) EffectiveThreadID() string

type ThreadUnarchiveResponse 

type ThreadUnarchiveResponse struct {
	Thread Thread `json:"thread"`
}

func (*ThreadUnarchiveResponse) UnmarshalJSON 

func (r *ThreadUnarchiveResponse) UnmarshalJSON(data []byte) error

type ThreadUnarchiveResult 

type ThreadUnarchiveResult struct {
	Thread ThreadRecord `json:"thread"`
}

type ThreadUnarchivedNotification 

type ThreadUnarchivedNotification struct {
	ThreadID string                `json:"threadId"`
	Status   ThreadLifecycleStatus `json:"status,omitempty"`
	Thread   *ThreadRecord         `json:"thread,omitempty"`
	At       *time.Time            `json:"at,omitempty"`
}

type ThreadUnsubscribeParams 

type ThreadUnsubscribeParams struct {
	ThreadID string `json:"threadId"`
	ID       string `json:"id,omitempty"`
}

func (ThreadUnsubscribeParams) EffectiveThreadID 

func (p ThreadUnsubscribeParams) EffectiveThreadID() string

type ThreadUnsubscribeResponse 

type ThreadUnsubscribeResponse struct {
	Status ThreadUnsubscribeStatus `json:"status"`
}

type ThreadUnsubscribeStatus 

type ThreadUnsubscribeStatus string
const (
	ThreadUnsubscribeNotLoaded     ThreadUnsubscribeStatus = "notLoaded"
	ThreadUnsubscribeNotSubscribed ThreadUnsubscribeStatus = "notSubscribed"
	ThreadUnsubscribeUnsubscribed  ThreadUnsubscribeStatus = "unsubscribed"
)

type TimelineItem 

type TimelineItem struct {
	ID           string          `json:"id"`
	ThreadID     string          `json:"threadId"`
	TurnID       string          `json:"turnId,omitempty"`
	ParentItemID string          `json:"parentItemId,omitempty"`
	Seq          int64           `json:"seq"`
	Kind         string          `json:"kind"`
	Status       string          `json:"status,omitempty"`
	Payload      json.RawMessage `json:"payload,omitempty"`
	CreatedAt    time.Time       `json:"createdAt"`
	UpdatedAt    time.Time       `json:"updatedAt"`
}

TimelineItem is the durable item envelope returned by thread item APIs. Payload contains one of the concrete item types below when Kind is known.

type TokenUsage 

type TokenUsage = ThreadTokenUsage

type TokenUsageBreakdown 

type TokenUsageBreakdown struct {
	TotalTokens           int64 `json:"totalTokens"`
	InputTokens           int64 `json:"inputTokens"`
	CachedInputTokens     int64 `json:"cachedInputTokens"`
	OutputTokens          int64 `json:"outputTokens"`
	ReasoningOutputTokens int64 `json:"reasoningOutputTokens"`
}

type Tool 

type Tool struct {
	Name         string       `json:"name"`
	Title        *string      `json:"title,omitempty"`
	Description  *string      `json:"description,omitempty"`
	InputSchema  JsonValue    `json:"inputSchema"`
	OutputSchema *JsonValue   `json:"outputSchema,omitempty"`
	Annotations  *JsonValue   `json:"annotations,omitempty"`
	Icons        *[]JsonValue `json:"icons,omitempty"`
	Meta         *JsonValue   `json:"_meta,omitempty"`
}

Tool is one exact public MCP tool definition.

func (Tool) MarshalJSON 

func (t Tool) MarshalJSON() ([]byte, error)

func (*Tool) UnmarshalJSON 

func (t *Tool) UnmarshalJSON(data []byte) error

type ToolPayloadSummary 

type ToolPayloadSummary struct {
	Omitted bool   `json:"omitted"`
	Reason  string `json:"reason"`
	Bytes   int    `json:"bytes"`
	SHA256  string `json:"sha256"`
}

type ToolRequestUserInputAnswer 

type ToolRequestUserInputAnswer struct {
	Answers []string `json:"answers" jsonschema:"nonnullable=true"`
}

func (ToolRequestUserInputAnswer) MarshalJSON 

func (a ToolRequestUserInputAnswer) MarshalJSON() ([]byte, error)

func (*ToolRequestUserInputAnswer) UnmarshalJSON 

func (a *ToolRequestUserInputAnswer) UnmarshalJSON(data []byte) error

type ToolRequestUserInputOption 

type ToolRequestUserInputOption struct {
	Label       string `json:"label"`
	Description string `json:"description"`
}

type ToolRequestUserInputParams 

type ToolRequestUserInputParams struct {
	ThreadID         string                         `json:"threadId"`
	TurnID           string                         `json:"turnId"`
	ItemID           string                         `json:"itemId"`
	Questions        []ToolRequestUserInputQuestion `json:"questions" jsonschema:"nonnullable=true"`
	AutoResolutionMS *uint64                        `json:"autoResolutionMs"`
	RequestID        string                         `json:"requestId,omitempty"`
	StartedAtMS      int64                          `json:"startedAtMs,omitempty"`
	Prompt           string                         `json:"prompt,omitempty"`
	Placeholder      string                         `json:"placeholder,omitempty"`
	Required         bool                           `json:"required,omitempty"`
	Options          []string                       `json:"options,omitempty"`
	Metadata         map[string]any                 `json:"metadata,omitempty"`
	Reason           string                         `json:"reason,omitempty"`
}

ToolRequestUserInputParams is the public structured request. The trailing fields preserve Gollem's v1 single-prompt request for existing clients.

type ToolRequestUserInputQuestion 

type ToolRequestUserInputQuestion struct {
	ID       string                       `json:"id"`
	Header   string                       `json:"header"`
	Question string                       `json:"question"`
	IsOther  bool                         `json:"isOther"`
	IsSecret bool                         `json:"isSecret"`
	Options  []ToolRequestUserInputOption `json:"options"`
}

type ToolRequestUserInputResponse 

type ToolRequestUserInputResponse struct {
	Answers map[string]ToolRequestUserInputAnswer `json:"answers" jsonschema:"nonnullable=true"`
}

func (ToolRequestUserInputResponse) MarshalJSON 

func (r ToolRequestUserInputResponse) MarshalJSON() ([]byte, error)

func (*ToolRequestUserInputResponse) UnmarshalJSON 

func (r *ToolRequestUserInputResponse) UnmarshalJSON(data []byte) error

type ToolsV2 

type ToolsV2 struct {
	WebSearch *WebSearchToolConfig `json:"web_search"`
}

ToolsV2 is the public v2 tool configuration. Unknown top-level fields are accepted for Rust-compatible evolution; known nested configs stay strict.

func (*ToolsV2) UnmarshalJSON 

func (t *ToolsV2) UnmarshalJSON(data []byte) error

type Turn 

type Turn struct {
	ID          string        `json:"id"`
	Items       []ThreadItem  `json:"items" jsonschema:"nonnullable=true"`
	ItemsView   TurnItemsView `json:"itemsView"`
	Status      TurnStatus    `json:"status"`
	Error       *TurnError    `json:"error"`
	StartedAt   *int64        `json:"startedAt"`
	CompletedAt *int64        `json:"completedAt"`
	DurationMS  *int64        `json:"durationMs"`
}

Turn is the exact public v2 turn projection. It remains separate from Gollem's durable TurnRecord and is not bound to methods until its public parent contracts are exported.

func (Turn) MarshalJSON 

func (t Turn) MarshalJSON() ([]byte, error)

func (*Turn) UnmarshalJSON 

func (t *Turn) UnmarshalJSON(data []byte) error

type TurnCompletedNotification 

type TurnCompletedNotification struct {
	ThreadID string `json:"threadId"`
	Turn     Turn   `json:"turn"`
}

func (*TurnCompletedNotification) UnmarshalJSON 

func (n *TurnCompletedNotification) UnmarshalJSON(data []byte) error

type TurnDiffUpdatedNotification 

type TurnDiffUpdatedNotification struct {
	ThreadID string `json:"threadId"`
	TurnID   string `json:"turnId"`
	Diff     string `json:"diff"`
}

type TurnDiffUpdatedNotificationParams 

type TurnDiffUpdatedNotificationParams = TurnDiffUpdatedNotification

type TurnError 

type TurnError struct {
	Message           string          `json:"message"`
	CodexErrorInfo    *CodexErrorInfo `json:"codexErrorInfo"`
	AdditionalDetails *string         `json:"additionalDetails"`
}

func (TurnError) MarshalJSON 

func (e TurnError) MarshalJSON() ([]byte, error)

func (*TurnError) UnmarshalJSON 

func (e *TurnError) UnmarshalJSON(data []byte) error

type TurnInterruptParams 

type TurnInterruptParams struct {
	ThreadID string `json:"threadId"`
	TurnID   string `json:"turnId"`
}

TurnInterruptParams is the exact fixed public turn-interrupt request. It remains standalone from Gollem's alias-compatible live handler contract.

func (*TurnInterruptParams) UnmarshalJSON 

func (p *TurnInterruptParams) UnmarshalJSON(data []byte) error

type TurnInterruptResponse 

type TurnInterruptResponse struct{}

TurnInterruptResponse is the exact fixed empty public response. Gollem's live handler continues to return its richer durable interrupt result.

func (*TurnInterruptResponse) UnmarshalJSON 

func (r *TurnInterruptResponse) UnmarshalJSON(data []byte) error

type TurnItemsView 

type TurnItemsView string
const (
	TurnItemsViewNotLoaded TurnItemsView = "notLoaded"
	TurnItemsViewSummary   TurnItemsView = "summary"
	TurnItemsViewFull      TurnItemsView = "full"
)

func (TurnItemsView) MarshalJSON 

func (v TurnItemsView) MarshalJSON() ([]byte, error)

func (*TurnItemsView) UnmarshalJSON 

func (v *TurnItemsView) UnmarshalJSON(data []byte) error

type TurnLifecycleStatus 

type TurnLifecycleStatus string

TurnLifecycleStatus is Gollem's durable turn execution lifecycle. 

const (
	TurnLifecycleQueued      TurnLifecycleStatus = "queued"
	TurnLifecycleRunning     TurnLifecycleStatus = "running"
	TurnLifecycleCompleted   TurnLifecycleStatus = "completed"
	TurnLifecycleFailed      TurnLifecycleStatus = "failed"
	TurnLifecycleInterrupted TurnLifecycleStatus = "interrupted"
)

type TurnModerationMetadataNotification 

type TurnModerationMetadataNotification struct {
	ThreadID string    `json:"threadId"`
	TurnID   string    `json:"turnId"`
	Metadata JsonValue `json:"metadata"`
}

TurnModerationMetadataNotification is the exact fixed public moderation metadata value. It remains standalone until Gollem has a producer.

func (*TurnModerationMetadataNotification) UnmarshalJSON 

func (n *TurnModerationMetadataNotification) UnmarshalJSON(data []byte) error

type TurnPlanStep 

type TurnPlanStep struct {
	Step   string             `json:"step"`
	Status TurnPlanStepStatus `json:"status"`
}

func (*TurnPlanStep) UnmarshalJSON 

func (s *TurnPlanStep) UnmarshalJSON(data []byte) error

type TurnPlanStepStatus 

type TurnPlanStepStatus string
const (
	TurnPlanStepStatusPending    TurnPlanStepStatus = "pending"
	TurnPlanStepStatusInProgress TurnPlanStepStatus = "inProgress"
	TurnPlanStepStatusCompleted  TurnPlanStepStatus = "completed"
)

func (TurnPlanStepStatus) MarshalJSON 

func (s TurnPlanStepStatus) MarshalJSON() ([]byte, error)

func (*TurnPlanStepStatus) UnmarshalJSON 

func (s *TurnPlanStepStatus) UnmarshalJSON(data []byte) error

type TurnPlanUpdatedNotification 

type TurnPlanUpdatedNotification struct {
	ThreadID    string         `json:"threadId"`
	TurnID      string         `json:"turnId"`
	Explanation *string        `json:"explanation"`
	Plan        []TurnPlanStep `json:"plan" jsonschema:"nonnullable=true"`
}

TurnPlanUpdatedNotification is the exact fixed public turn-plan snapshot. It remains standalone until Gollem has an exact live producer.

func (TurnPlanUpdatedNotification) MarshalJSON 

func (n TurnPlanUpdatedNotification) MarshalJSON() ([]byte, error)

func (*TurnPlanUpdatedNotification) UnmarshalJSON 

func (n *TurnPlanUpdatedNotification) UnmarshalJSON(data []byte) error

type TurnRecord 

type TurnRecord struct {
	ID                  string              `json:"id"`
	ThreadID            string              `json:"threadId"`
	Status              TurnLifecycleStatus `json:"status"`
	Input               json.RawMessage     `json:"input,omitempty"`
	Result              json.RawMessage     `json:"result,omitempty"`
	Error               string              `json:"error,omitempty"`
	Usage               map[string]any      `json:"usage,omitempty"`
	Metadata            map[string]any      `json:"metadata,omitempty"`
	CreatedAt           time.Time           `json:"createdAt"`
	UpdatedAt           time.Time           `json:"updatedAt"`
	StartedAt           time.Time           `json:"startedAt,omitempty"`
	CompletedAt         time.Time           `json:"completedAt,omitempty"`
	RetryOfTurnID       string              `json:"retryOfTurnId,omitempty"`
	RetryIdempotencyKey string              `json:"retryIdempotencyKey,omitempty"`
	Items               []TimelineItem      `json:"items,omitempty" jsonschema:"nonnullable=true"`
}

type TurnRunInterruptParams 

type TurnRunInterruptParams struct {
	ID       string `json:"id,omitempty"`
	TurnID   string `json:"turnId,omitempty"`
	ThreadID string `json:"threadId,omitempty"`
}

type TurnRunInterruptResult 

type TurnRunInterruptResult struct {
	OK     bool        `json:"ok"`
	TurnID string      `json:"turnId"`
	Turn   *TurnRecord `json:"turn,omitempty"`
}

type TurnRunRetryParams 

type TurnRunRetryParams struct {
	TurnID         string         `json:"turnId"`
	IdempotencyKey string         `json:"idempotencyKey"`
	Prompt         string         `json:"prompt,omitempty"`
	Metadata       map[string]any `json:"metadata,omitempty"`
	RuntimeModelParams
}

TurnRunRetryParams is Gollem's exact idempotent retry request. Legacy untyped clients may omit idempotencyKey at the handler boundary, but typed clients must supply one so a lost response cannot duplicate model work.

type TurnRunRetryResult 

type TurnRunRetryResult struct {
	Turn           TurnRecord `json:"turn"`
	SourceTurnID   string     `json:"sourceTurnId"`
	IdempotencyKey string     `json:"idempotencyKey"`
	Reused         bool       `json:"reused"`
}

type TurnRunStartParams 

type TurnRunStartParams struct {
	ID       string         `json:"id,omitempty"`
	ThreadID string         `json:"threadId,omitempty"`
	Prompt   string         `json:"prompt,omitempty"`
	Message  string         `json:"message,omitempty"`
	Text     string         `json:"text,omitempty"`
	Metadata map[string]any `json:"metadata,omitempty"`
	RuntimeModelParams
}

type TurnRunStartResult 

type TurnRunStartResult struct {
	Thread ThreadRecord `json:"thread"`
	Turn   TurnRecord   `json:"turn"`
}

type TurnStartParams 

type TurnStartParams struct {
	ThreadID            string             `json:"threadId"`
	ClientUserMessageID *string            `json:"clientUserMessageId,omitempty"`
	Input               []UserInput        `json:"input" jsonschema:"nonnullable=true"`
	CWD                 *string            `json:"cwd,omitempty"`
	ApprovalPolicy      *AskForApproval    `json:"approvalPolicy,omitempty"`
	ApprovalsReviewer   *ApprovalsReviewer `json:"approvalsReviewer,omitempty"`
	SandboxPolicy       *SandboxPolicy     `json:"sandboxPolicy,omitempty"`
	Model               *string            `json:"model,omitempty"`
	ServiceTier         *string            `json:"serviceTier,omitempty"`
	Effort              *ReasoningEffort   `json:"effort,omitempty"`
	Summary             *ReasoningSummary  `json:"summary,omitempty"`
	Personality         *Personality       `json:"personality,omitempty"`
	OutputSchema        *JsonValue         `json:"outputSchema,omitempty"`
}

TurnStartParams is the exact fixed public turn-start request. It remains standalone from Gollem's broader prompt-driven live handler contract.

func (TurnStartParams) MarshalJSON 

func (p TurnStartParams) MarshalJSON() ([]byte, error)

func (*TurnStartParams) UnmarshalJSON 

func (p *TurnStartParams) UnmarshalJSON(data []byte) error

type TurnStartResponse 

type TurnStartResponse struct {
	Turn Turn `json:"turn"`
}

func (TurnStartResponse) MarshalJSON 

func (r TurnStartResponse) MarshalJSON() ([]byte, error)

func (*TurnStartResponse) UnmarshalJSON 

func (r *TurnStartResponse) UnmarshalJSON(data []byte) error

type TurnStartedNotification 

type TurnStartedNotification struct {
	ThreadID string `json:"threadId"`
	Turn     Turn   `json:"turn"`
}

func (*TurnStartedNotification) UnmarshalJSON 

func (n *TurnStartedNotification) UnmarshalJSON(data []byte) error

type TurnStatus 

type TurnStatus string
const (
	TurnStatusCompleted   TurnStatus = "completed"
	TurnStatusInterrupted TurnStatus = "interrupted"
	TurnStatusFailed      TurnStatus = "failed"
	TurnStatusInProgress  TurnStatus = "inProgress"
)

func (TurnStatus) MarshalJSON 

func (s TurnStatus) MarshalJSON() ([]byte, error)

func (*TurnStatus) UnmarshalJSON 

func (s *TurnStatus) UnmarshalJSON(data []byte) error

type TurnSteerParams 

type TurnSteerParams struct {
	ThreadID            string      `json:"threadId"`
	ClientUserMessageID *string     `json:"clientUserMessageId,omitempty"`
	Input               []UserInput `json:"input" jsonschema:"nonnullable=true"`
	ExpectedTurnID      string      `json:"expectedTurnId"`
}

TurnSteerParams is the exact fixed public turn-steer request accepted by the live runtime.

func (TurnSteerParams) MarshalJSON 

func (p TurnSteerParams) MarshalJSON() ([]byte, error)

func (*TurnSteerParams) UnmarshalJSON 

func (p *TurnSteerParams) UnmarshalJSON(data []byte) error

type TurnSteerResponse 

type TurnSteerResponse struct {
	TurnID string `json:"turnId"`
}

func (*TurnSteerResponse) UnmarshalJSON 

func (r *TurnSteerResponse) UnmarshalJSON(data []byte) error

type TurnsPage 

type TurnsPage struct {
	Data            []Turn  `json:"data" jsonschema:"nonnullable=true"`
	NextCursor      *string `json:"nextCursor"`
	BackwardsCursor *string `json:"backwardsCursor"`
}

TurnsPage is the exact public page of strict Turn projections. It remains standalone until Gollem implements the experimental resume pagination path.

func (TurnsPage) MarshalJSON 

func (p TurnsPage) MarshalJSON() ([]byte, error)

func (*TurnsPage) UnmarshalJSON 

func (p *TurnsPage) UnmarshalJSON(data []byte) error

type UnavailableData 

type UnavailableData struct {
	Method  string      `json:"method"`
	Surface Surface     `json:"surface,omitempty"`
	Status  MethodState `json:"status,omitempty"`
	Reason  string      `json:"reason"`
}

UnavailableData describes a known method that is not available yet.

type UserInput 

type UserInput struct {
	Type         string        `json:"type"`
	Text         string        `json:"text,omitempty"`
	TextElements []TextElement `json:"text_elements,omitempty"`
	Detail       *ImageDetail  `json:"detail,omitempty"`
	URL          string        `json:"url,omitempty"`
	Name         string        `json:"name,omitempty"`
	Path         string        `json:"path,omitempty"`
}

UserInput is the closed public turn-input union. TextElements intentionally retains the public snake_case wire name.

func (UserInput) MarshalJSON 

func (i UserInput) MarshalJSON() ([]byte, error)

func (*UserInput) UnmarshalJSON 

func (i *UserInput) UnmarshalJSON(data []byte) error

type Verbosity 

type Verbosity string

Verbosity is the exact closed public model verbosity. 

const (
	VerbosityLow    Verbosity = "low"
	VerbosityMedium Verbosity = "medium"
	VerbosityHigh   Verbosity = "high"
)

func (Verbosity) MarshalJSON 

func (v Verbosity) MarshalJSON() ([]byte, error)

func (*Verbosity) UnmarshalJSON 

func (v *Verbosity) UnmarshalJSON(data []byte) error

type WarningNotification 

type WarningNotification struct {
	ThreadID *string `json:"threadId"`
	Message  string  `json:"message"`
}

WarningNotification is the exact fixed public warning value. It remains standalone until Gollem has an exact live producer.

func (*WarningNotification) UnmarshalJSON 

func (n *WarningNotification) UnmarshalJSON(data []byte) error

type WebSearchAction 

type WebSearchAction struct {
	// contains filtered or unexported fields
}

WebSearchAction retains one validated public web-search action without binding it to Gollem runtime items or provider-specific search payloads.

func (WebSearchAction) MarshalJSON 

func (a WebSearchAction) MarshalJSON() ([]byte, error)

func (*WebSearchAction) UnmarshalJSON 

func (a *WebSearchAction) UnmarshalJSON(data []byte) error

type WebSearchContextSize 

type WebSearchContextSize string

WebSearchContextSize is the exact closed public web-search context size. 

const (
	WebSearchContextSizeLow    WebSearchContextSize = "low"
	WebSearchContextSizeMedium WebSearchContextSize = "medium"
	WebSearchContextSizeHigh   WebSearchContextSize = "high"
)

func (WebSearchContextSize) MarshalJSON 

func (s WebSearchContextSize) MarshalJSON() ([]byte, error)

func (*WebSearchContextSize) UnmarshalJSON 

func (s *WebSearchContextSize) UnmarshalJSON(data []byte) error

type WebSearchItem 

type WebSearchItem struct {
	ID     string           `json:"id"`
	Query  string           `json:"query"`
	Action *WebSearchAction `json:"action"`
}

WebSearchItem is the exact standalone public web-search record. It remains unbound from Gollem runtime items until the full public ThreadItem path exists.

func (WebSearchItem) MarshalJSON 

func (i WebSearchItem) MarshalJSON() ([]byte, error)

func (*WebSearchItem) UnmarshalJSON 

func (i *WebSearchItem) UnmarshalJSON(data []byte) error

type WebSearchLocation 

type WebSearchLocation struct {
	Country  *string `json:"country"`
	Region   *string `json:"region"`
	City     *string `json:"city"`
	Timezone *string `json:"timezone"`
}

WebSearchLocation is the exact closed public web-search location.

func (*WebSearchLocation) UnmarshalJSON 

func (l *WebSearchLocation) UnmarshalJSON(data []byte) error

type WebSearchMode 

type WebSearchMode string

WebSearchMode is the exact closed public web-search requirement mode. 

const (
	WebSearchModeDisabled WebSearchMode = "disabled"
	WebSearchModeCached   WebSearchMode = "cached"
	WebSearchModeIndexed  WebSearchMode = "indexed"
	WebSearchModeLive     WebSearchMode = "live"
)

func (WebSearchMode) MarshalJSON 

func (m WebSearchMode) MarshalJSON() ([]byte, error)

func (*WebSearchMode) UnmarshalJSON 

func (m *WebSearchMode) UnmarshalJSON(data []byte) error

type WebSearchToolConfig 

type WebSearchToolConfig struct {
	ContextSize    *WebSearchContextSize `json:"context_size"`
	AllowedDomains []string              `json:"allowed_domains"`
	Location       *WebSearchLocation    `json:"location"`
}

WebSearchToolConfig is the exact closed public web-search tool config.

func (*WebSearchToolConfig) UnmarshalJSON 

func (c *WebSearchToolConfig) UnmarshalJSON(data []byte) error

type WindowsSandboxSetupMode 

type WindowsSandboxSetupMode string

WindowsSandboxSetupMode is the exact closed public Windows setup mode. It does not add a Windows sandbox implementation to Gollem. 

const (
	WindowsSandboxSetupModeElevated   WindowsSandboxSetupMode = "elevated"
	WindowsSandboxSetupModeUnelevated WindowsSandboxSetupMode = "unelevated"
)

func (WindowsSandboxSetupMode) MarshalJSON 

func (m WindowsSandboxSetupMode) MarshalJSON() ([]byte, error)

func (*WindowsSandboxSetupMode) UnmarshalJSON 

func (m *WindowsSandboxSetupMode) UnmarshalJSON(data []byte) error

type WireTypeBinding 

type WireTypeBinding struct {
	Method  string   `json:"method"`
	Surface Surface  `json:"surface"`
	Params  []string `json:"params,omitempty"`
	Result  []string `json:"result,omitempty"`
}

WireTypeBinding maps one method to concrete exported parameter and result definitions. Multiple Params entries represent polymorphic payloads.

func WireTypeBindings 

func WireTypeBindings() []WireTypeBinding

type WorkspaceMessage 

type WorkspaceMessage struct {
	MessageID   string               `json:"messageId"`
	MessageType WorkspaceMessageType `json:"messageType"`
	MessageBody string               `json:"messageBody"`
	CreatedAt   *int64               `json:"createdAt,omitempty"`
	ArchivedAt  *int64               `json:"archivedAt,omitempty"`
}

WorkspaceMessage is exact standalone backend message data.

func (WorkspaceMessage) MarshalJSON 

func (m WorkspaceMessage) MarshalJSON() ([]byte, error)

func (*WorkspaceMessage) UnmarshalJSON 

func (m *WorkspaceMessage) UnmarshalJSON(data []byte) error

type WorkspaceMessageType 

type WorkspaceMessageType string

WorkspaceMessageType is the public workspace-message category. Unknown backend strings collapse to the serde fallback literal. 

const (
	WorkspaceMessageTypeHeadline     WorkspaceMessageType = "headline"
	WorkspaceMessageTypeAnnouncement WorkspaceMessageType = "announcement"
	WorkspaceMessageTypeUnknown      WorkspaceMessageType = "unknown"
)

func (WorkspaceMessageType) MarshalJSON 

func (t WorkspaceMessageType) MarshalJSON() ([]byte, error)

func (*WorkspaceMessageType) UnmarshalJSON 

func (t *WorkspaceMessageType) UnmarshalJSON(data []byte) error

type WriteStatus 

type WriteStatus string

WriteStatus is the exact closed public config-write result status. 

const (
	WriteStatusOK           WriteStatus = "ok"
	WriteStatusOKOverridden WriteStatus = "okOverridden"
)

func (WriteStatus) MarshalJSON 

func (s WriteStatus) MarshalJSON() ([]byte, error)

func (*WriteStatus) UnmarshalJSON 

func (s *WriteStatus) UnmarshalJSON(data []byte) error

Source Files

View all Source files

Directories

Path Synopsis
internal
cmd/schema command

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.