Skip to content

Runtime commands

octomate.schemas.commands

Runtime command catalogs and explicit invocations, separate from chat text.

CommandOutcome module-attribute 

CommandOutcome = Annotated[
    CommandResult | CommandError,
    Field(discriminator="status"),
]

CommandContext dataclass

Server-resolved context shared by discovery and execution.

The caller authorizes the user and resolves the selected conversation and effective workspace before calling an adapter. A native transcript's session handle alone does not grant permission to drive that runtime.

Source code in octomate/schemas/commands.py 
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
@dataclass(frozen=True)
class CommandContext:
    """Server-resolved context shared by discovery and execution.

    The caller authorizes the user and resolves the selected conversation and
    effective workspace before calling an adapter. A native transcript's session
    handle alone does not grant permission to drive that runtime.
    """

    agent_id: Annotated[
        str,
        Field(min_length=1, description="The configured agent owning this context."),
    ]
    user_id: Annotated[
        uuid.UUID,
        Field(description="The authenticated Octomate user, not a platform sender id."),
    ]
    address: Annotated[
        ChannelAddress,
        Field(description="The originating surface and its platform user."),
    ]
    cwd: Annotated[
        Path | None,
        Field(
            description="The effective runtime workspace, never a client-supplied path; "
            "null before a thread exists. Discovery must not prepare this directory.",
        ),
    ]
    conversation: Annotated[
        Conversation | None,
        Field(description="None while composing a new conversation."),
    ]
    model: Annotated[
        str | None,
        Field(description="The selected runtime model, resolved by the host."),
    ] = None
    permission_mode: Annotated[
        str | None, Field(description="The effective runtime approval posture.")
    ] = None

    def matches(self, other: "CommandContext") -> bool:
        """Whether a resolved context can reuse this context's catalog."""
        conversation = self.conversation
        other_conversation = other.conversation
        return (
            self.agent_id == other.agent_id
            and self.user_id == other.user_id
            and self.address == other.address
            and self.cwd == other.cwd
            and self.model == other.model
            and self.permission_mode == other.permission_mode
            and (
                (conversation is None and other_conversation is None)
                or (
                    conversation is not None
                    and other_conversation is not None
                    and conversation.id == other_conversation.id
                    and conversation.external_id == other_conversation.external_id
                )
            )
        )

agent_id instance-attribute 

agent_id: Annotated[
    str,
    Field(
        min_length=1,
        description="The configured agent owning this context.",
    ),
]

user_id instance-attribute 

user_id: Annotated[
    UUID,
    Field(
        description="The authenticated Octomate user, not a platform sender id."
    ),
]

address instance-attribute 

address: Annotated[
    ChannelAddress,
    Field(
        description="The originating surface and its platform user."
    ),
]

cwd instance-attribute 

cwd: Annotated[
    Path | None,
    Field(
        description="The effective runtime workspace, never a client-supplied path; null before a thread exists. Discovery must not prepare this directory."
    ),
]

conversation instance-attribute 

conversation: Annotated[
    Conversation | None,
    Field(
        description="None while composing a new conversation."
    ),
]

model class-attribute instance-attribute 

model: Annotated[
    str | None,
    Field(
        description="The selected runtime model, resolved by the host."
    ),
] = None

permission_mode class-attribute instance-attribute 

permission_mode: Annotated[
    str | None,
    Field(
        description="The effective runtime approval posture."
    ),
] = None

matches 

matches(other: CommandContext) -> bool

Whether a resolved context can reuse this context's catalog.

Source code in octomate/schemas/commands.py 
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
def matches(self, other: "CommandContext") -> bool:
    """Whether a resolved context can reuse this context's catalog."""
    conversation = self.conversation
    other_conversation = other.conversation
    return (
        self.agent_id == other.agent_id
        and self.user_id == other.user_id
        and self.address == other.address
        and self.cwd == other.cwd
        and self.model == other.model
        and self.permission_mode == other.permission_mode
        and (
            (conversation is None and other_conversation is None)
            or (
                conversation is not None
                and other_conversation is not None
                and conversation.id == other_conversation.id
                and conversation.external_id == other_conversation.external_id
            )
        )
    )

CommandDescriptor pydantic-model

Bases: BaseModel

The fields channels consume for runtime commands and skills.

Tentacles subclass this model for typed runtime metadata. Catalog serialization preserves those fields, but channels depend only on this base. Rehydrate an extended descriptor with its tentacle's concrete model, not this base model. Descriptors are frozen; runtime extensions must use hashable field values.

Fields:

Source code in octomate/schemas/commands.py 
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
class CommandDescriptor(BaseModel, frozen=True):
    """The fields channels consume for runtime commands and skills.

    Tentacles subclass this model for typed runtime metadata. Catalog serialization
    preserves those fields, but channels depend only on this base. Rehydrate an
    extended descriptor with its tentacle's concrete model, not this base model.
    Descriptors are frozen; runtime extensions must use hashable field values.
    """

    id: str = Field(
        min_length=1,
        description="Opaque identity, stable and unique within the agent's scoped "
        "catalog. The tentacle maps it to the upstream invocation.",
    )
    name: str = Field(min_length=1, description="Upstream command or skill name.")
    description: str = Field(description="Upstream description, preserved verbatim.")
    argument_hint: str | None = Field(
        default=None, description="Upstream free-form input hint, when provided."
    )
    requires_conversation: bool = Field(
        default=True,
        description="Whether execution needs an existing conversation. False permits "
        "a direct outcome before a conversation exists, without creating a thread, "
        "run or delivery receipt. An adapter must not start an agent run in that context.",
    )
    unavailable_reason: str | None = Field(
        default=None,
        min_length=1,
        description="Why a known command cannot execute through this adapter. "
        "Null means available, subject to context requirements. Channels display "
        "disabled entries with this reason; the host refuses their execution.",
    )
    unavailable_kind: Literal["context", "unsupported"] = Field(
        default="context",
        description="Classifies unavailable_reason: context means a supported command "
        "is blocked by the current session or configuration; unsupported means this "
        "adapter does not implement it. Ignored when unavailable_reason is null. "
        "Channels decide whether they provide their own handling.",
    )
    accepts_attachments: bool | None = Field(
        default=None,
        description="Whether attached input is supported; null means unspecified. "
        "Channels offer attachments only when this is explicitly true.",
    )

id pydantic-field 

id: str

Opaque identity, stable and unique within the agent's scoped catalog. The tentacle maps it to the upstream invocation.

name pydantic-field 

name: str

Upstream command or skill name.

description pydantic-field 

description: str

Upstream description, preserved verbatim.

argument_hint pydantic-field 

argument_hint: str | None = None

Upstream free-form input hint, when provided.

requires_conversation pydantic-field 

requires_conversation: bool = True

Whether execution needs an existing conversation. False permits a direct outcome before a conversation exists, without creating a thread, run or delivery receipt. An adapter must not start an agent run in that context.

unavailable_reason pydantic-field 

unavailable_reason: str | None = None

Why a known command cannot execute through this adapter. Null means available, subject to context requirements. Channels display disabled entries with this reason; the host refuses their execution.

unavailable_kind pydantic-field 

unavailable_kind: Literal["context", "unsupported"] = (
    "context"
)

Classifies unavailable_reason: context means a supported command is blocked by the current session or configuration; unsupported means this adapter does not implement it. Ignored when unavailable_reason is null. Channels decide whether they provide their own handling.

accepts_attachments pydantic-field 

accepts_attachments: bool | None = None

Whether attached input is supported; null means unspecified. Channels offer attachments only when this is explicitly true.

CommandCatalog pydantic-model

Bases: BaseModel

Runtime descriptors and their discovery state in one resolved context.

Fields:

Validators:

Source code in octomate/schemas/commands.py 
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
class CommandCatalog(BaseModel):
    """Runtime descriptors and their discovery state in one resolved context."""

    context: CommandContext = Field(
        description="The context this catalog was discovered in."
    )
    descriptors: set[SerializeAsAny[CommandDescriptor]] = Field(
        default_factory=set,
        description="Unique known runtime entries, with no ordering guarantee. Runtime-specific "
        "descriptor subclasses retain their additional fields; empty unless ready.",
    )
    status: Literal["ready", "loading", "unsupported", "unavailable", "failed"] = Field(
        description="Discovery state; ready with no descriptors is a successful empty catalog."
    )
    message: str | None = Field(
        default=None,
        min_length=1,
        description="Required explanation when discovery cannot supply a catalog.",
    )
    limitations: list[str] = Field(
        default_factory=list,
        description="User-visible discovery gaps, such as skills without native slash commands.",
    )

    @model_validator(mode="after")
    def valid_discovery_state(self) -> Self:
        """Only ready catalogs contain descriptors; failed discovery explains why."""
        if self.status != "ready" and self.descriptors:
            raise ValueError("only ready catalogs may contain descriptors")
        if self.status in {"unsupported", "unavailable", "failed"} and not self.message:
            raise ValueError("unavailable catalogs require a message")
        ids = [descriptor.id for descriptor in self.descriptors]
        if len(ids) != len(set(ids)):
            raise ValueError("command catalog descriptor ids must be unique")
        return self

    def snapshot(self) -> Self:
        """Copy catalog data without deep-copying the conversation's database state."""
        conversation = self.context.conversation
        return self.model_copy(
            update={
                "context": replace(
                    self.context,
                    conversation=conversation.model_copy()
                    if conversation is not None
                    else None,
                ),
                "descriptors": {
                    descriptor.model_copy(deep=True) for descriptor in self.descriptors
                },
                "limitations": list(self.limitations),
            }
        )

context pydantic-field 

context: CommandContext

The context this catalog was discovered in.

descriptors pydantic-field 

descriptors: set[SerializeAsAny[CommandDescriptor]]

Unique known runtime entries, with no ordering guarantee. Runtime-specific descriptor subclasses retain their additional fields; empty unless ready.

status pydantic-field 

status: Literal[
    "ready",
    "loading",
    "unsupported",
    "unavailable",
    "failed",
]

Discovery state; ready with no descriptors is a successful empty catalog.

message pydantic-field 

message: str | None = None

Required explanation when discovery cannot supply a catalog.

limitations pydantic-field 

limitations: list[str]

User-visible discovery gaps, such as skills without native slash commands.

valid_discovery_state pydantic-validator 

valid_discovery_state() -> Self

Only ready catalogs contain descriptors; failed discovery explains why.

Source code in octomate/schemas/commands.py 
147
148
149
150
151
152
153
154
155
156
157
@model_validator(mode="after")
def valid_discovery_state(self) -> Self:
    """Only ready catalogs contain descriptors; failed discovery explains why."""
    if self.status != "ready" and self.descriptors:
        raise ValueError("only ready catalogs may contain descriptors")
    if self.status in {"unsupported", "unavailable", "failed"} and not self.message:
        raise ValueError("unavailable catalogs require a message")
    ids = [descriptor.id for descriptor in self.descriptors]
    if len(ids) != len(set(ids)):
        raise ValueError("command catalog descriptor ids must be unique")
    return self

snapshot 

snapshot() -> Self

Copy catalog data without deep-copying the conversation's database state.

Source code in octomate/schemas/commands.py 
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
def snapshot(self) -> Self:
    """Copy catalog data without deep-copying the conversation's database state."""
    conversation = self.context.conversation
    return self.model_copy(
        update={
            "context": replace(
                self.context,
                conversation=conversation.model_copy()
                if conversation is not None
                else None,
            ),
            "descriptors": {
                descriptor.model_copy(deep=True) for descriptor in self.descriptors
            },
            "limitations": list(self.limitations),
        }
    )

CommandInvocation pydantic-model

Bases: BaseModel

Explicit command intent; ordinary chat text does not use this contract.

The caller must revalidate catalog membership and attachment support before dispatch. Attachments here are already resolved by the host, not arbitrary client paths.

Fields:

Source code in octomate/schemas/commands.py 
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
class CommandInvocation(BaseModel):
    """Explicit command intent; ordinary chat text does not use this contract.

    The caller must revalidate catalog membership and attachment support before dispatch.
    Attachments here are already resolved by the host, not arbitrary client paths.
    """

    command_id: str = Field(
        min_length=1, description="The selected descriptor's opaque id."
    )
    arguments: str = Field(
        default="",
        description="Raw argument text, without trimming or prompt decoration.",
    )
    attachments: list[
        Annotated[ImageSegment | FileSegment, Field(discriminator="type")]
    ] = Field(default_factory=list, description="Resolved runtime input attachments.")

command_id pydantic-field 

command_id: str

The selected descriptor's opaque id.

arguments pydantic-field 

arguments: str = ''

Raw argument text, without trimming or prompt decoration.

attachments pydantic-field 

attachments: list[
    Annotated[
        ImageSegment | FileSegment,
        Field(discriminator=type),
    ]
]

Resolved runtime input attachments.

CommandResult pydantic-model

Bases: BaseModel

A direct command's user-visible output, without a fabricated model turn.

Fields:

Source code in octomate/schemas/commands.py 
197
198
199
200
201
202
203
204
class CommandResult(BaseModel):
    """A direct command's user-visible output, without a fabricated model turn."""

    status: Literal["completed"] = "completed"
    segments: list[MessageSegment] = Field(
        default_factory=list,
        description="Output to present on the originating surface.",
    )

status pydantic-field 

status: Literal['completed'] = 'completed'

segments pydantic-field 

segments: list[MessageSegment]

Output to present on the originating surface.

CommandError pydantic-model

Bases: BaseModel

An explicit refusal or failure; none of these outcomes falls back to chat.

Fields:

  • status (Literal['unsupported', 'unknown', 'stale', 'busy', 'unavailable', 'failed'])
  • message (str)
Source code in octomate/schemas/commands.py 
207
208
209
210
211
212
213
214
215
class CommandError(BaseModel):
    """An explicit refusal or failure; none of these outcomes falls back to chat."""

    status: Literal[
        "unsupported", "unknown", "stale", "busy", "unavailable", "failed"
    ] = Field(description="The reason this invocation did not complete successfully.")
    message: str = Field(
        min_length=1, description="An actionable explanation for the user."
    )

status pydantic-field 

status: Literal[
    "unsupported",
    "unknown",
    "stale",
    "busy",
    "unavailable",
    "failed",
]

The reason this invocation did not complete successfully.

message pydantic-field 

message: str

An actionable explanation for the user.

CommandOutcomeEvent pydantic-model

Bases: BaseModel

The terminal command result, refusal or saved delivery outcome.

Fields:

Source code in octomate/schemas/commands.py 
221
222
223
224
225
226
227
228
229
class CommandOutcomeEvent(BaseModel):
    """The terminal command result, refusal or saved delivery outcome."""

    event_kind: Literal["command_outcome"] = Field(
        default="command_outcome", description="Identifies a terminal command outcome."
    )
    outcome: CommandOutcome = Field(
        description="Direct or replayed outcome, or completion after stream cleanup and persistence."
    )

event_kind pydantic-field 

event_kind: Literal['command_outcome'] = 'command_outcome'

Identifies a terminal command outcome.

outcome pydantic-field 

outcome: CommandOutcome

Direct or replayed outcome, or completion after stream cleanup and persistence.

octomate.tentacles.codex.schemas

Codex model and command metadata and native protocol extensions.

CodexModelCatalog

Bases: NamedTuple

Visible native models and the configured provider and defaults.

Source code in octomate/tentacles/codex/schemas.py 
12
13
14
15
16
17
18
class CodexModelCatalog(NamedTuple):
    """Visible native models and the configured provider and defaults."""

    provider: str
    models: list[Model]
    default_model: str | None
    configured_effort: ReasoningEffort | None

provider instance-attribute 

provider: str

models instance-attribute 

models: list[Model]

default_model instance-attribute 

default_model: str | None

configured_effort instance-attribute 

configured_effort: ReasoningEffort | None

ThreadSettingsUpdateResponse pydantic-model

Bases: BaseModel

Native acknowledgement that a thread settings update was queued.

The SDK omits this experimental endpoint. Codex emits thread/settings/updated when the settings have been applied for future turns.

Source code in octomate/tentacles/codex/schemas.py 
21
22
23
24
25
26
class ThreadSettingsUpdateResponse(BaseModel):
    """Native acknowledgement that a thread settings update was queued.

    The SDK omits this experimental endpoint. Codex emits
    thread/settings/updated when the settings have been applied for future turns.
    """

CodexCommandDescriptor pydantic-model

Bases: CommandDescriptor

An enabled Codex skill, identified by its native invocation path.

Fields:

Source code in octomate/tentacles/codex/schemas.py 
29
30
31
32
33
34
35
36
class CodexCommandDescriptor(CommandDescriptor, frozen=True):
    """An enabled Codex skill, identified by its native invocation path."""

    path: Path = Field(description="The native skill path used for invocation.")
    scope: SkillScope = Field(description="The skill's native discovery scope.")
    plugin_id: str | None = Field(
        default=None, description="The owning Codex plugin ID, when supplied."
    )

path pydantic-field 

path: Path

The native skill path used for invocation.

scope pydantic-field 

scope: SkillScope

The skill's native discovery scope.

plugin_id pydantic-field 

plugin_id: str | None = None

The owning Codex plugin ID, when supplied.

octomate.tentacles.codex.catalog

Known app/IDE commands, separate from dynamically discovered skills.

Codex implements these composer actions in its clients, not a commands/list RPC. Sources: https://learn.chatgpt.com/docs/reference/slash-commands and https://developers.openai.com/codex/ide/slash-commands.

APP_COMMANDS module-attribute 

APP_COMMANDS: frozenset[CommandDescriptor] = frozenset(
    (
        CommandDescriptor(
            id=f"builtin:{name}",
            name=name,
            description=description,
            unavailable_reason=reason,
            unavailable_kind="unsupported",
        )
    )
    for name, description, reason in (
        (
            "cloud",
            "Run in the cloud.",
            "Cloud execution is not supported here.",
        ),
        (
            "cloud-environment",
            "Choose a cloud environment.",
            "Cloud environments are managed in Codex.",
        ),
        (
            "fast",
            "Toggle fast execution.",
            "Codex service-tier changes are not supported here yet.",
        ),
        (
            "feedback",
            "Send feedback to OpenAI.",
            "Use the feedback dialog in Codex.",
        ),
        (
            "ide-context",
            "Toggle automatic editor context.",
            "Editor context is managed in the Codex IDE extension.",
        ),
        (
            "local",
            "Run in a local workspace.",
            "Driven Codex runs already use the thread's workspace.",
        ),
        (
            "memories",
            "Configure memory use and generation.",
            "Codex memory settings are not supported here yet.",
        ),
        (
            "pet",
            "Show or hide the desktop pet.",
            "Desktop pets are managed in the Codex app.",
        ),
        (
            "personality",
            "Choose a response style.",
            "Codex personality changes are not supported here yet.",
        ),
        (
            "side",
            "Open a temporary side conversation.",
            "Side conversations are not supported here yet.",
        ),
    )
) | frozenset(
    {
        CommandDescriptor(
            id="builtin:model",
            name="model",
            description="Choose the conversation model.",
            unavailable_reason="Codex's app-server does not expose a model selection command.",
            unavailable_kind="unsupported",
            requires_conversation=False,
        ),
        CommandDescriptor(
            id="builtin:project",
            name="project",
            description="Choose a project for a new conversation.",
            unavailable_reason="Codex's app-server does not expose a project selection command.",
            unavailable_kind="unsupported",
            requires_conversation=False,
        ),
        CommandDescriptor(
            id="builtin:task",
            name="task",
            description="Start a conversation without a project.",
            unavailable_reason="Codex's app-server does not expose a task command.",
            unavailable_kind="unsupported",
            requires_conversation=False,
        ),
        CommandDescriptor(
            id="builtin:worktree",
            name="worktree",
            description="Run in a new Git worktree.",
            unavailable_reason="Codex's app-server does not expose a worktree command.",
            unavailable_kind="unsupported",
            requires_conversation=False,
        ),
        CommandDescriptor(
            id="builtin:approve",
            name="approve",
            description="Approve a denial from the latest run and retry it.",
            argument_hint="[review-id]",
        ),
        CommandDescriptor(
            id="builtin:fork",
            name="fork",
            description="Copy this conversation into an independent thread.",
        ),
        CommandDescriptor(
            id="builtin:compact",
            name="compact",
            description="Compact the conversation context.",
        ),
        CommandDescriptor(
            id="builtin:review",
            name="review",
            description="Review uncommitted changes, or changes against a branch.",
            argument_hint="[branch]",
        ),
        CommandDescriptor(
            id="builtin:init",
            name="init",
            description="Create project instructions in AGENTS.md.",
        ),
        CommandDescriptor(
            id="builtin:mcp",
            name="mcp",
            description="Inspect connected MCP servers.",
        ),
        CommandDescriptor(
            id="builtin:plan",
            name="plan",
            description="Enter or leave planning mode.",
            argument_hint="[on|off]",
        ),
        CommandDescriptor(
            id="builtin:reasoning",
            name="reasoning",
            description="Choose the reasoning effort.",
            argument_hint="[level]",
        ),
        CommandDescriptor(
            id="builtin:status",
            name="status",
            description="Inspect the conversation and its current settings.",
            requires_conversation=False,
        ),
    }
)

octomate.tentacles.claude.catalog.ClaudeCommandDescriptor pydantic-model

Bases: CommandDescriptor

A native initialize command normalized for the shared catalog.

Fields:

Source code in octomate/tentacles/claude/catalog.py 
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
class ClaudeCommandDescriptor(CommandDescriptor, frozen=True):
    """A native initialize command normalized for the shared catalog."""

    id: str = Field(
        min_length=1,
        validation_alias=AliasChoices("id", "name"),
        description="Claude's canonical command name, used for invocation.",
    )
    argument_hint: str | None = Field(
        default=None,
        validation_alias=AliasChoices("argument_hint", "argumentHint"),
        description="The runtime's argument hint, including an empty hint.",
    )
    aliases: tuple[str, ...] = Field(
        default=(), description="Additional command names advertised by Claude."
    )

id pydantic-field 

id: str

Claude's canonical command name, used for invocation.

argument_hint pydantic-field 

argument_hint: str | None = None

The runtime's argument hint, including an empty hint.

aliases pydantic-field 

aliases: tuple[str, ...] = ()

Additional command names advertised by Claude.

octomate.tentacles.deepseek.catalog.DeepseekCommandDescriptor pydantic-model

Bases: CommandDescriptor

Native command metadata normalized for channel discovery.

Fields:

Source code in octomate/tentacles/deepseek/catalog.py 
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
class DeepseekCommandDescriptor(CommandDescriptor, frozen=True):
    """Native command metadata normalized for channel discovery."""

    id: str = Field(
        min_length=1,
        validation_alias=AliasChoices("id", "name"),
        description="The command name, unique in the receiving agent's registry.",
    )
    argument_hint: str | None = Field(
        default=None,
        validation_alias=AliasChoices("argument_hint", AliasPath("input", "hint")),
        description="The native free-form input hint, when input is declared.",
    )
    accepts_attachments: bool = Field(
        default=False,
        validation_alias=AliasChoices(
            "accepts_attachments", AliasPath("input", "attachments")
        ),
        description="DSH rejects attachments unless the definition opts in.",
    )
    definition_id: str | None = Field(
        default=None,
        validation_alias=AliasChoices("definition_id", "definitionId"),
        description="Plugin-owned identity of the effective definition, when provided.",
    )

id pydantic-field 

id: str

The command name, unique in the receiving agent's registry.

argument_hint pydantic-field 

argument_hint: str | None = None

The native free-form input hint, when input is declared.

accepts_attachments pydantic-field 

accepts_attachments: bool = False

DSH rejects attachments unless the definition opts in.

definition_id pydantic-field 

definition_id: str | None = None

Plugin-owned identity of the effective definition, when provided.

octomate.tentacles.deepseek.wire.CommandSuccess pydantic-model

Bases: BaseModel

A command settled successfully, optionally referencing richer presentation.

Config:

  • default: PERMISSIVE

Fields:

Source code in octomate/tentacles/deepseek/wire.py 
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
class CommandSuccess(BaseModel):
    """A command settled successfully, optionally referencing richer presentation."""

    model_config = PERMISSIVE

    kind: Literal["success"] = Field(description="The handler's successful outcome.")
    text: str | None = Field(
        default=None, description="Optional direct output, preserved verbatim."
    )
    source_event_seq: int | None = Field(
        default=None,
        ge=0,
        strict=True,
        description="Earlier session event that owns a richer presentation of this result.",
    )

model_config class-attribute instance-attribute 

model_config = PERMISSIVE

kind pydantic-field 

kind: Literal['success']

The handler's successful outcome.

text pydantic-field 

text: str | None = None

Optional direct output, preserved verbatim.

source_event_seq pydantic-field 

source_event_seq: int | None = None

Earlier session event that owns a richer presentation of this result.

octomate.tentacles.deepseek.wire.CommandError pydantic-model

Bases: BaseModel

A command-level refusal inside a successful Remote response.

Config:

  • default: PERMISSIVE

Fields:

Source code in octomate/tentacles/deepseek/wire.py 
693
694
695
696
697
698
699
700
701
class CommandError(BaseModel):
    """A command-level refusal inside a successful Remote response."""

    model_config = PERMISSIVE

    kind: Literal["error"] = Field(description="The handler's rejected outcome.")
    text: str = Field(
        min_length=1, description="The native error text, preserved verbatim."
    )

model_config class-attribute instance-attribute 

model_config = PERMISSIVE

kind pydantic-field 

kind: Literal['error']

The handler's rejected outcome.

text pydantic-field 

text: str

The native error text, preserved verbatim.

octomate.tentacles.deepseek.wire.CommandExecutionValue pydantic-model

Bases: BaseModel

A matched commands/execute result; Ink maps a null wire value to no match.

Config:

  • default: PERMISSIVE

Fields:

Source code in octomate/tentacles/deepseek/wire.py 
709
710
711
712
713
714
715
716
717
718
class CommandExecutionValue(BaseModel):
    """A matched `commands/execute` result; Ink maps a null wire value to no match."""

    model_config = PERMISSIVE

    command_id: str = Field(
        min_length=1,
        description="Identity pairing the command/run and command/done events.",
    )
    result: CommandResult = Field(description="The settled native command outcome.")

model_config class-attribute instance-attribute 

model_config = PERMISSIVE

command_id pydantic-field 

command_id: str

Identity pairing the command/run and command/done events.

result pydantic-field 

result: CommandResult

The settled native command outcome.