🥮 mooncakes.io

    lody

    1:1 MoonBit mirror of the LodyAI acp-extension-core contract (tool vocabulary, _meta.lody DTOs, _lody/ methods, capabilities)

    lody
    acp
    agent
    json
    sdk
    Download zip
    Author
    Version
    0.1.0
    License
    MIT
    Last updated
    13 days ago
    Downloads
    165

    #colmugx/lody-extension

    1:1 MoonBit mirror of the LodyAI/acp-extension-core contract — the lody host vocabulary for ACP extensions: canonical tool identities, _meta.lody feature DTOs, _lody/ method names and their request/response DTOs, capability advertisement, elicitation and usage/rate-limit payloads.

    Pure functions only: typed structs plus JSON to_json/from_json codecs. No IO, no async, no runtime, no posoco dependency.

    #Upstream tracking

    项值
    Mirrored upstreamLodyAI/acp-extension-core (default branch main)
    Upstream commit23c792b910a903b74601e346473827106f991715 (merge of PR #1, 2026-08-21)
    Upstream package versionacp-extension-core@0.1.0 → this module versions 0.1.0
    Local spec translationdocs/acp/lody-contracts.md (authoritative for every field)

    #Upgrade strategy

    Lody upstream does not ship a MoonBit SDK; this module maintains the mirror:

    1. Diff upstream src/*.ts against the previously mirrored commit.
    2. Port every change 1:1: type names, wire field names, and wire string vocabulary are mirrored verbatim — no invention, no renaming.
    3. Bump this module's version to the upstream package.json version.
    4. Re-run the test suite; snapshots lock the wire shapes.

    #Conventions

    • TS camelCase wire keys stay camelCase on the wire; MoonBit struct fields use the snake_case transliteration (e.g. taskId ↔ task_id).
    • Upstream string-literal unions become MoonBit enums with to_wire / of_wire : String -> Result[T, String].
    • Optional contract fields decode leniently: absent key and explicit JSON null both yield None; required fields error when missing; mistyped fields always error with the contract scope and wire field name; unknown fields are ignored.
    • Capability JSON keys are emitted in camelCase exactly as the TS keys. The upstream repo gives no wire-serialization evidence, so this is an inference — marked "awaiting on-wire verification" at capabilities.mbt.
    • Contract items the upstream repo leaves undefined (steer prompt element shape, history/read response body, canonical tool parameter schemas) are annotated "awaiting on-wire verification" where they surface.

    LodyActivityKind

    source
    pub(all) enum LodyActivityKind {
      ContextCompaction
      Retry
    } derive(Eq, 
    Debug    )

    Wire vocabulary of LodyActivityMeta.kind (src/session.ts).

    LodyActivityKind::of_wire

    source
    fn LodyActivityKind::of_wire(wire : String) -> Result[LodyActivityKind, String]

    LodyActivityKind::to_wire

    source
    fn LodyActivityKind::to_wire(self : LodyActivityKind) -> String

    LodyActivityMeta

    source
    pub(all) struct LodyActivityMeta {
      version : Int
      kind : LodyActivityKind
      automatic : Bool?
      used_tokens_before : Int?
      used_tokens_after : Int?
      duration_ms : Int64?
      failure_reason : String?
    } derive(Eq, 
    Debug    )

    LodyActivityMeta — compaction/retry lifecycle on tool_call envelopes.

    LodyActivityMeta::from_json

    source
    fn LodyActivityMeta::from_json(raw : Json) -> Result[LodyActivityMeta, String]

    LodyActivityMeta::to_json

    source
    fn LodyActivityMeta::to_json(self : LodyActivityMeta) -> Json

    LodyElicitationAnswer

    source
    pub(all) enum LodyElicitationAnswer {
      Single(String)
      Multi(Array[String])
    } derive(Eq, 
    Debug    )

    LodyElicitationAnswer — string | string[]: a single choice or a multi-select choice set.

    LodyElicitationAnswer::from_json

    source
    fn LodyElicitationAnswer::from_json(raw : Json) -> Result[LodyElicitationAnswer, String]

    LodyElicitationAnswer::to_json

    source

    LodyElicitationMeta

    source
    pub(all) struct LodyElicitationMeta {
      version : Int
      auto_resolve_after_seconds : Int64?
      auto_resolve_at_epoch_seconds : Int64?
      custom_answer_for : String?
      secret : Bool?
      preview : String?
      questions : Array[LodyElicitationQuestion]?
      answers : Map[String, LodyElicitationAnswer]?
    } derive(Eq, 
    Debug    )

    LodyElicitationMeta — the _meta.lody.elicitation value. Mounts at request, property, and enum-option scope alike.

    LodyElicitationMeta::from_json

    source
    fn LodyElicitationMeta::from_json(raw : Json) -> Result[LodyElicitationMeta, String]

    LodyElicitationMeta::to_json

    source

    LodyElicitationOption

    source
    pub(all) struct LodyElicitationOption {
      label : String
      description : String?
      preview : String?
    } derive(Eq, 
    Debug    )

    LodyElicitationOption — one enum option (label required).

    LodyElicitationOption::from_json

    source
    fn LodyElicitationOption::from_json(raw : Json) -> Result[LodyElicitationOption, String]

    LodyElicitationOption::to_json

    source

    LodyElicitationQuestion

    source
    pub(all) struct LodyElicitationQuestion {
      id : String?
      question : String
      header : String
      options : Array[LodyElicitationOption]
      multi_select : Bool
      allow_custom_answer : Bool?
      is_secret : Bool?
    } derive(Eq, 
    Debug    )

    LodyElicitationQuestion — one question with its option set.

    LodyElicitationQuestion::from_json

    source
    fn LodyElicitationQuestion::from_json(raw : Json) -> Result[LodyElicitationQuestion, String]

    LodyElicitationQuestion::to_json

    source

    LodyExtensionCapabilities

    source
    pub(all) struct LodyExtensionCapabilities {
      usage : LodyVersionOneCapability?
      rate_limits : LodyRateLimitsCapability?
      fork_at_turn : LodyVersionOneCapability?
      steering : LodySteeringCapability?
      tasks : LodyTaskCapability?
      subagents : LodySubagentCapability?
      goal : LodyGoalCapability?
      compaction : LodyVersionOneCapability?
      session_history : LodyVersionOneCapability?
    } derive(Eq, 
    Debug    )

    LodyExtensionCapabilities — the _meta.lody value under agentCapabilities. Absent features are simply not advertised; to_json emits only the present feature keys, in upstream declaration order.

    LodyExtensionCapabilities::empty

    source

    LodyExtensionCapabilities::from_json

    source
    fn LodyExtensionCapabilities::from_json(raw : Json) -> Result[LodyExtensionCapabilities, String]

    LodyExtensionCapabilities::to_json

    source

    LodyForkAtTurn

    source
    pub(all) struct LodyForkAtTurn {
      version : Int
      turn_id : String?
    } derive(Eq, 
    Debug    )

    LodyForkAtTurn — source-turn pointer carried by session/fork.

    LodyForkAtTurn::from_json

    source
    fn LodyForkAtTurn::from_json(raw : Json) -> Result[LodyForkAtTurn, String]

    LodyForkAtTurn::to_json

    source
    fn LodyForkAtTurn::to_json(self : LodyForkAtTurn) -> Json

    LodyGoalAction

    source
    pub(all) enum LodyGoalAction {
      Set
      Pause
      Resume
      Clear
    } derive(Eq, 
    Debug    )

    Wire vocabulary of LodyGoalCapability.actions (goal control verbs).

    LodyGoalAction::of_wire

    source
    fn LodyGoalAction::of_wire(wire : String) -> Result[LodyGoalAction, String]

    LodyGoalAction::to_wire

    source
    fn LodyGoalAction::to_wire(self : LodyGoalAction) -> String

    LodyGoalCapability

    source
    pub(all) struct LodyGoalCapability {
      version : Int
      actions : Array[LodyGoalAction]
    } derive(Eq, 
    Debug    )

    LodyGoalCapability — supports goal management and _lody/session/goal; actions declares the supported verb set.

    LodyGoalCapability::from_json

    source
    fn LodyGoalCapability::from_json(raw : Json) -> Result[LodyGoalCapability, String]

    LodyGoalCapability::to_json

    source

    LodyGoalControlRequest

    source
    pub(all) enum LodyGoalControlRequest {
      Set(session_id~ : String, objective~ : String)
      Pause(session_id~ : String)
      Resume(session_id~ : String)
      Clear(session_id~ : String)
    } derive(Eq, 
    Debug    )

    LodyGoalControlRequest — _lody/session/goal params, discriminated on action: set carries an objective; pause/resume/clear do not.

    LodyGoalControlRequest::from_json

    source
    fn LodyGoalControlRequest::from_json(raw : Json) -> Result[LodyGoalControlRequest, String]

    LodyGoalControlRequest::to_json

    source

    LodyGoalControlResponse

    source
    pub(all) struct LodyGoalControlResponse {
      goal : LodyGoalSnapshot?
    } derive(Eq, 
    Debug    )

    LodyGoalControlResponse — _lody/session/goal result; goal is a required key that is nullable upstream: null when no goal is currently set (a missing key is a decode error).

    LodyGoalControlResponse::from_json

    source
    fn LodyGoalControlResponse::from_json(raw : Json) -> Result[LodyGoalControlResponse, String]

    LodyGoalControlResponse::to_json

    source

    LodyGoalPresence

    source
    pub(all) enum LodyGoalPresence {
      GoalAbsent
      GoalCleared
      GoalSet(LodyGoalSnapshot)
    } derive(Eq, 
    Debug    )

    Tri-state for LodySessionMeta.goal (LodyGoalSnapshot | null, or the field absent): absent means "no goal information", explicit null means "the goal was cleared".

    LodyGoalPresence::from_json

    source
    fn LodyGoalPresence::from_json(raw : Json?) -> Result[LodyGoalPresence, String]

    LodyGoalPresence::to_json

    source
    fn LodyGoalPresence::to_json(self : LodyGoalPresence) -> (String, Json)?

    LodyGoalSnapshot

    source
    pub(all) struct LodyGoalSnapshot {
      objective : String
      status : LodyGoalStatus
      iterations : Int?
      last_reason : String?
      created_at_epoch_seconds : Int64?
      updated_at_epoch_seconds : Int64?
      token_budget : Int?
      tokens_used : Int?
      time_used_seconds : Int64?
    } derive(Eq, 
    Debug    )

    LodyGoalSnapshot — one goal-management snapshot on session updates. lastReason / tokenBudget are string | null / number | null upstream without a distinct absent meaning, so both null and absent decode to None.

    LodyGoalSnapshot::from_json

    source
    fn LodyGoalSnapshot::from_json(raw : Json) -> Result[LodyGoalSnapshot, String]

    LodyGoalSnapshot::to_json

    source
    fn LodyGoalSnapshot::to_json(self : LodyGoalSnapshot) -> Json

    LodyGoalStatus

    source
    pub(all) enum LodyGoalStatus {
      Active
      Paused
      Blocked
      Limited
      Complete
    } derive(Eq, 
    Debug    )

    Wire vocabulary of LodyGoalSnapshot.status.

    LodyGoalStatus::of_wire

    source
    fn LodyGoalStatus::of_wire(wire : String) -> Result[LodyGoalStatus, String]

    LodyGoalStatus::to_wire

    source
    fn LodyGoalStatus::to_wire(self : LodyGoalStatus) -> String

    LodyMessagePhase

    source
    pub(all) enum LodyMessagePhase {
      Commentary
      FinalAnswer
    } derive(Eq, 
    Debug    )

    Wire vocabulary of LodySessionMeta.messagePhase (commentary vs final answer).

    LodyMessagePhase::of_wire

    source
    fn LodyMessagePhase::of_wire(wire : String) -> Result[LodyMessagePhase, String]

    LodyMessagePhase::to_wire

    source
    fn LodyMessagePhase::to_wire(self : LodyMessagePhase) -> String

    LodyNotice

    source
    pub(all) struct LodyNotice {
      level : LodyNoticeLevel
      message : String
      source : String?
    } derive(Eq, 
    Debug    )

    LodyNotice — one notification on session updates.

    LodyNotice::from_json

    source
    fn LodyNotice::from_json(raw : Json) -> Result[LodyNotice, String]

    LodyNotice::to_json

    source
    fn LodyNotice::to_json(self : LodyNotice) -> Json

    LodyNoticeLevel

    source
    pub(all) enum LodyNoticeLevel {
      Info
      Warning
      Error
    } derive(Eq, 
    Debug    )

    Wire vocabulary of LodyNotice.level.

    LodyNoticeLevel::of_wire

    source
    fn LodyNoticeLevel::of_wire(wire : String) -> Result[LodyNoticeLevel, String]

    LodyNoticeLevel::to_wire

    source
    fn LodyNoticeLevel::to_wire(self : LodyNoticeLevel) -> String

    LodyRateLimitsCapability

    source
    pub(all) struct LodyRateLimitsCapability {
      version : Int
      query : Bool?
    } derive(Eq, 
    Debug    )

    LodyRateLimitsCapability — supports rate-limit notifications; query: true additionally advertises that _lody/rate_limits/get is answerable.

    LodyRateLimitsCapability::from_json

    source
    fn LodyRateLimitsCapability::from_json(raw : Json) -> Result[LodyRateLimitsCapability, String]

    LodyRateLimitsCapability::to_json

    source

    LodySessionHistoryReadRequest

    source
    pub(all) struct LodySessionHistoryReadRequest {
      session_id : String
    } derive(Eq, 
    Debug    )

    LodySessionHistoryReadRequest — _lody/session/history/read params.

    LodySessionHistoryReadRequest::from_json

    source
    fn LodySessionHistoryReadRequest::from_json(raw : Json) -> Result[LodySessionHistoryReadRequest, String]

    LodySessionHistoryReadRequest::to_json

    source

    LodySessionHistoryReadResponse

    source
    pub(all) struct LodySessionHistoryReadResponse {
    } derive(Eq, 
    Debug    )

    LodySessionHistoryReadResponse — an empty object upstream. How the actual history content is carried is missing from the contract (likely a placeholder) — awaiting on-wire verification. Decoding tolerates and ignores any extra fields.

    LodySessionHistoryReadResponse::from_json

    source

    LodySessionHistoryReadResponse::to_json

    source

    LodySessionMeta

    source
    pub(all) struct LodySessionMeta {
      turn_id : String?
      fork_at_turn : LodyForkAtTurn?
      steer : LodySteerPromptMeta?
      tool_name : String?
      activity : LodyActivityMeta?
      task : LodyTaskMeta?
      goal : LodyGoalPresence
      notice : LodyNotice?
      title_source : LodyTitleSource?
      message_phase : LodyMessagePhase?
    } derive(Eq, 
    Debug    )

    LodySessionMeta — the full _meta.lody envelope value on standard ACP session updates and tool_call/tool_call_update messages. No version field: versions live inside forkAtTurn / activity / task.

    LodySessionMeta::from_json

    source
    fn LodySessionMeta::from_json(raw : Json) -> Result[LodySessionMeta, String]

    LodySessionMeta::to_json

    source
    fn LodySessionMeta::to_json(self : LodySessionMeta) -> Json

    LodySteerApplied

    source
    pub(all) struct LodySteerApplied {
      session_id : String
      steer_id : String
    } derive(Eq, 
    Debug    )

    LodySteerApplied — _lody/session/steer_applied notification payload.

    LodySteerApplied::from_json

    source
    fn LodySteerApplied::from_json(raw : Json) -> Result[LodySteerApplied, String]

    LodySteerApplied::to_json

    source
    fn LodySteerApplied::to_json(self : LodySteerApplied) -> Json

    LodySteerOutcome

    source
    pub(all) enum LodySteerOutcome {
      Injected
      Failed
    } derive(Eq, 
    Debug    )

    Wire vocabulary of LodySteerResponse.outcome.

    LodySteerOutcome::of_wire

    source
    fn LodySteerOutcome::of_wire(wire : String) -> Result[LodySteerOutcome, String]

    LodySteerOutcome::to_wire

    source
    fn LodySteerOutcome::to_wire(self : LodySteerOutcome) -> String

    LodySteerPromptMeta

    source
    pub(all) struct LodySteerPromptMeta {
      id : String
    } derive(Eq, 
    Debug    )

    LodySteerPromptMeta — { id: string }, no version. Associates a message chunk with the _lody/session/steer request that produced it.

    LodySteerPromptMeta::from_json

    source
    fn LodySteerPromptMeta::from_json(raw : Json) -> Result[LodySteerPromptMeta, String]

    LodySteerPromptMeta::to_json

    source

    LodySteerRequest

    source
    pub(all) struct LodySteerRequest {
      session_id : String
      prompt : Array[Json]
      steer_id : String
    } derive(
    Debug    )

    LodySteerRequest — _lody/session/steer params. The prompt element content shape is unconstrained upstream (generic TPrompt); it passes through as opaque JSON — awaiting on-wire verification.

    LodySteerRequest::from_json

    source
    fn LodySteerRequest::from_json(raw : Json) -> Result[LodySteerRequest, String]

    LodySteerRequest::to_json

    source
    fn LodySteerRequest::to_json(self : LodySteerRequest) -> Json

    LodySteerResponse

    source
    pub(all) struct LodySteerResponse {
      outcome : LodySteerOutcome
    } derive(Eq, 
    Debug    )

    LodySteerResponse — _lody/session/steer result.

    LodySteerResponse::from_json

    source
    fn LodySteerResponse::from_json(raw : Json) -> Result[LodySteerResponse, String]

    LodySteerResponse::to_json

    source

    LodySteeringCapability

    source
    pub(all) struct LodySteeringCapability {
      version : Int
      transport : LodySteeringTransport
      upstream_turn : LodySteeringUpstreamTurn
      config_policy : LodySteeringConfigPolicy
    } derive(Eq, 
    Debug    )

    LodySteeringCapability — supports _lody/session/steer; declares the transport, upstream-turn policy, and config-effectiveness policy.

    LodySteeringCapability::from_json

    source
    fn LodySteeringCapability::from_json(raw : Json) -> Result[LodySteeringCapability, String]

    LodySteeringCapability::to_json

    source

    LodySteeringConfigPolicy

    source
    pub(all) enum LodySteeringConfigPolicy {
      Active
      Apply
    } derive(Eq, 
    Debug    )

    Wire vocabulary of LodySteeringCapability.configPolicy.

    LodySteeringConfigPolicy::of_wire

    source
    fn LodySteeringConfigPolicy::of_wire(wire : String) -> Result[LodySteeringConfigPolicy, String]

    LodySteeringConfigPolicy::to_wire

    source

    LodySteeringTransport

    source
    pub(all) enum LodySteeringTransport {
      Request
      Prompt
    } derive(Eq, 
    Debug    )

    Wire vocabulary of LodySteeringCapability.transport.

    LodySteeringTransport::of_wire

    source
    fn LodySteeringTransport::of_wire(wire : String) -> Result[LodySteeringTransport, String]

    LodySteeringTransport::to_wire

    source
    fn LodySteeringTransport::to_wire(self : LodySteeringTransport) -> String

    LodySteeringUpstreamTurn

    source
    pub(all) enum LodySteeringUpstreamTurn {
      Same
      Handoff
    } derive(Eq, 
    Debug    )

    Wire vocabulary of LodySteeringCapability.upstreamTurn.

    LodySteeringUpstreamTurn::of_wire

    source
    fn LodySteeringUpstreamTurn::of_wire(wire : String) -> Result[LodySteeringUpstreamTurn, String]

    LodySteeringUpstreamTurn::to_wire

    source

    LodySubagentCancelRequest

    source
    pub(all) struct LodySubagentCancelRequest {
      session_id : String
      task_id : String
      reason : String?
    } derive(Eq, 
    Debug    )

    LodySubagentCancelRequest — _lody/subagents/cancel params.

    LodySubagentCancelRequest::from_json

    source
    fn LodySubagentCancelRequest::from_json(raw : Json) -> Result[LodySubagentCancelRequest, String]

    LodySubagentCancelRequest::to_json

    source

    LodySubagentCancelResponse

    source
    pub(all) struct LodySubagentCancelResponse {
    } derive(Eq, 
    Debug    )

    LodySubagentCancelResponse — an empty object upstream. Decoding tolerates and ignores any extra fields.

    LodySubagentCancelResponse::from_json

    source
    fn LodySubagentCancelResponse::from_json(raw : Json) -> Result[LodySubagentCancelResponse, String]

    LodySubagentCancelResponse::to_json

    source

    LodySubagentCapability

    source
    pub(all) struct LodySubagentCapability {
      version : Int
      lifecycle : Bool
      list : Bool?
      cancel : Bool?
      output : Bool?
    } derive(Eq, 
    Debug    )

    LodySubagentCapability — supports subagent lifecycle (lifecycle is required); list / cancel / output declare the three query methods.

    LodySubagentCapability::from_json

    source
    fn LodySubagentCapability::from_json(raw : Json) -> Result[LodySubagentCapability, String]

    LodySubagentCapability::to_json

    source

    LodySubagentOutputRequest

    source
    pub(all) struct LodySubagentOutputRequest {
      session_id : String
      task_id : String
      tail : Int?
    } derive(Eq, 
    Debug    )

    LodySubagentOutputRequest — _lody/subagents/output params.

    LodySubagentOutputRequest::from_json

    source
    fn LodySubagentOutputRequest::from_json(raw : Json) -> Result[LodySubagentOutputRequest, String]

    LodySubagentOutputRequest::to_json

    source

    LodySubagentOutputResponse

    source
    pub(all) struct LodySubagentOutputResponse {
      output : String
    } derive(Eq, 
    Debug    )

    LodySubagentOutputResponse — _lody/subagents/output result.

    LodySubagentOutputResponse::from_json

    source
    fn LodySubagentOutputResponse::from_json(raw : Json) -> Result[LodySubagentOutputResponse, String]

    LodySubagentOutputResponse::to_json

    source

    LodySubagentStatus

    source
    pub(all) enum LodySubagentStatus {
      Running
      Completed
      Failed
      TimedOut
      Killed
      Lost
    } derive(Eq, 
    Debug    )

    Wire vocabulary of LodySubagentTask.status (_lody/subagents/list track: running / completed / failed / timed_out / killed / lost). Deliberately NOT shared with LodyTaskStatus — upstream keeps the two status vocabularies disjoint.

    LodySubagentStatus::of_wire

    source
    fn LodySubagentStatus::of_wire(wire : String) -> Result[LodySubagentStatus, String]

    LodySubagentStatus::to_wire

    source
    fn LodySubagentStatus::to_wire(self : LodySubagentStatus) -> String

    LodySubagentTask

    source
    pub(all) struct LodySubagentTask {
      task_id : String
      description : String
      status : LodySubagentStatus
      agent_id : String?
      subagent_type : String?
      model_id : String?
      thinking_effort : String?
      started_at_epoch_seconds : Int64
      ended_at_epoch_seconds : Int64?
      stop_reason : String?
    } derive(Eq, 
    Debug    )

    LodySubagentTask — one row of _lody/subagents/list. Status vocabulary (running/completed/failed/timed_out/killed/lost) is disjoint from LodyTaskStatus. endedAtEpochSeconds is required but nullable upstream, so to_json always emits the key (null until the task ends).

    LodySubagentTask::from_json

    source
    fn LodySubagentTask::from_json(raw : Json) -> Result[LodySubagentTask, String]

    LodySubagentTask::to_json

    source
    fn LodySubagentTask::to_json(self : LodySubagentTask) -> Json

    LodySubagentsListRequest

    source
    pub(all) struct LodySubagentsListRequest {
      session_id : String
      active_only : Bool?
    } derive(Eq, 
    Debug    )

    LodySubagentsListRequest — _lody/subagents/list params.

    LodySubagentsListRequest::from_json

    source
    fn LodySubagentsListRequest::from_json(raw : Json) -> Result[LodySubagentsListRequest, String]

    LodySubagentsListRequest::to_json

    source

    LodySubagentsListResponse

    source
    pub(all) struct LodySubagentsListResponse {
      tasks : Array[LodySubagentTask]
    } derive(Eq, 
    Debug    )

    LodySubagentsListResponse — _lody/subagents/list result.

    LodySubagentsListResponse::from_json

    source
    fn LodySubagentsListResponse::from_json(raw : Json) -> Result[LodySubagentsListResponse, String]

    LodySubagentsListResponse::to_json

    source

    LodyTaskCapability

    source
    pub(all) struct LodyTaskCapability {
      version : Int
      background : Bool?
      scheduled : Bool?
    } derive(Eq, 
    Debug    )

    LodyTaskCapability — tool_call envelopes may carry _meta.lody.task; background / scheduled declare the supported task subclasses.

    LodyTaskCapability::from_json

    source
    fn LodyTaskCapability::from_json(raw : Json) -> Result[LodyTaskCapability, String]

    LodyTaskCapability::to_json

    source

    LodyTaskKind

    source
    pub(all) enum LodyTaskKind {
      Subagent
      Background
      Scheduled
    } derive(Eq, 
    Debug    )

    Wire vocabulary of LodyTaskMeta.kind (subagent / background / scheduled task lifecycles).

    LodyTaskKind::of_wire

    source
    fn LodyTaskKind::of_wire(wire : String) -> Result[LodyTaskKind, String]

    LodyTaskKind::to_wire

    source
    fn LodyTaskKind::to_wire(self : LodyTaskKind) -> String

    LodyTaskMeta

    source
    pub(all) struct LodyTaskMeta {
      version : Int
      task_id : String
      kind : LodyTaskKind
      status : LodyTaskStatus
      description : String?
      actor : String?
      parent_task_id : String?
      parent_tool_call_id : String?
      model_id : String?
      started_at_epoch_seconds : Int64?
      ended_at_epoch_seconds : Int64?
      summary : String?
      error : String?
      last_tool_name : String?
      usage : LodyTaskUsage?
      skip_transcript : Bool?
    } derive(Eq, 
    Debug    )

    LodyTaskMeta — subagent / background / scheduled task lifecycle on tool_call envelopes. The task track: status vocabulary is pending/in_progress/completed/failed (disjoint from the subagent-list vocabulary; see LodySubagentStatus).

    LodyTaskMeta::from_json

    source
    fn LodyTaskMeta::from_json(raw : Json) -> Result[LodyTaskMeta, String]

    LodyTaskMeta::to_json

    source
    fn LodyTaskMeta::to_json(self : LodyTaskMeta) -> Json

    LodyTaskStatus

    source
    pub(all) enum LodyTaskStatus {
      Pending
      InProgress
      Completed
      Failed
    } derive(Eq, 
    Debug    )

    Wire vocabulary of LodyTaskMeta.status (task track: pending / in_progress / completed / failed). Deliberately NOT shared with the subagent-list status vocabulary — upstream keeps the two disjoint.

    LodyTaskStatus::of_wire

    source
    fn LodyTaskStatus::of_wire(wire : String) -> Result[LodyTaskStatus, String]

    LodyTaskStatus::to_wire

    source
    fn LodyTaskStatus::to_wire(self : LodyTaskStatus) -> String

    LodyTaskUsage

    source
    pub(all) struct LodyTaskUsage {
      total_tokens : Int?
      tool_uses : Int?
      duration_ms : Int64?
    } derive(Eq, 
    Debug    )

    LodyTaskMeta.usage — totals for one delegated task.

    LodyTaskUsage::from_json

    source
    fn LodyTaskUsage::from_json(raw : Json) -> Result[LodyTaskUsage, String]

    LodyTaskUsage::to_json

    source
    fn LodyTaskUsage::to_json(self : LodyTaskUsage) -> Json

    LodyTitleSource

    source
    pub(all) enum LodyTitleSource {
      Explicit
      Generated
      Fallback
      Unset
    } derive(Eq, 
    Debug    )

    Wire vocabulary of LodySessionMeta.titleSource.

    LodyTitleSource::of_wire

    source
    fn LodyTitleSource::of_wire(wire : String) -> Result[LodyTitleSource, String]

    LodyTitleSource::to_wire

    source
    fn LodyTitleSource::to_wire(self : LodyTitleSource) -> String

    LodyVersionOneCapability

    source
    pub(all) struct LodyVersionOneCapability {
      version : Int
    } derive(Eq, 
    Debug    )

    LodyVersionOneCapability — the { version: 1 } base shared by every feature key.

    LodyVersionOneCapability::from_json

    source
    fn LodyVersionOneCapability::from_json(raw : Json) -> Result[LodyVersionOneCapability, String]

    LodyVersionOneCapability::to_json

    source

    LodyVersionOneCapability::version_one

    source

    ModelUsage

    source
    pub(all) struct ModelUsage {
      input_tokens : Int
      output_tokens : Int
      cache_read_input_tokens : Int
      cache_creation_input_tokens : Int?
      reasoning_output_tokens : Int?
      web_search_requests : Int?
      cost_usd : Double?
      context_window : Int64?
    } derive(Eq, 
    Debug    )

    ModelUsage — token/cost totals for one model bucket.

    ModelUsage::from_json

    source
    fn ModelUsage::from_json(raw : Json) -> Result[ModelUsage, String]

    ModelUsage::to_json

    source
    fn ModelUsage::to_json(self : ModelUsage) -> Json

    RateLimit

    source
    pub(all) struct RateLimit {
      limit_id : String
      scope : RateLimitScope
      limit_name : String?
      plan_name : String?
      windows : Array[RateLimitWindow]
      wallet : RateLimitWallet?
    } derive(Eq, 
    Debug    )

    RateLimit — one limit with its windows and optional wallet. limitName, planName, and wallet are nullable-but-optional upstream without a distinct absent meaning, so null and absent both decode to None.

    RateLimit::from_json

    source
    fn RateLimit::from_json(raw : Json) -> Result[RateLimit, String]

    RateLimit::to_json

    source
    fn RateLimit::to_json(self : RateLimit) -> Json

    RateLimitScope

    source
    pub(all) struct RateLimitScope {
      provider_id : String
      account_id : String?
      model_id : String?
    } derive(Eq, 
    Debug    )

    RateLimitScope — which provider/account/model a limit applies to.

    RateLimitScope::from_json

    source
    fn RateLimitScope::from_json(raw : Json) -> Result[RateLimitScope, String]

    RateLimitScope::to_json

    source
    fn RateLimitScope::to_json(self : RateLimitScope) -> Json

    RateLimitWallet

    source
    pub(all) struct RateLimitWallet {
      balance_cents : Int64
      total_cents : Int64
      monthly_charge_limit_enabled : Bool
      monthly_charge_limit_cents : Int64
      monthly_used_cents : Int64
      currency : String
    } derive(Eq, 
    Debug    )

    RateLimitWallet — credit-balance state; money in cents, ISO currency string (upstream constrains the format no further).

    RateLimitWallet::from_json

    source
    fn RateLimitWallet::from_json(raw : Json) -> Result[RateLimitWallet, String]

    RateLimitWallet::to_json

    source
    fn RateLimitWallet::to_json(self : RateLimitWallet) -> Json

    RateLimitWindow

    source
    pub(all) struct RateLimitWindow {
      used_percent : Double
      window_duration_seconds : Int64?
      resets_at_epoch_seconds : Int64?
    } derive(Eq, 
    Debug    )

    RateLimitWindow — one usage window; usedPercent is 0..100 inclusive.

    RateLimitWindow::from_json

    source
    fn RateLimitWindow::from_json(raw : Json) -> Result[RateLimitWindow, String]

    RateLimitWindow::to_json

    source
    fn RateLimitWindow::to_json(self : RateLimitWindow) -> Json

    RateLimitsGetRequest

    source
    pub(all) struct RateLimitsGetRequest {
      session_id : String?
      account_id : String?
      model_id : String?
    } derive(Eq, 
    Debug    )

    RateLimitsGetRequest — _lody/rate_limits/get params. Not session bound: every field is an optional filter.

    RateLimitsGetRequest::from_json

    source
    fn RateLimitsGetRequest::from_json(raw : Json) -> Result[RateLimitsGetRequest, String]

    RateLimitsGetRequest::to_json

    source

    RateLimitsSnapshot

    source
    pub(all) struct RateLimitsSnapshot {
      rate_limits : Array[RateLimit]
      fetched_at_epoch_seconds : Int64?
    } derive(Eq, 
    Debug    )

    RateLimitsSnapshot — the shape of _lody/rate_limits/get's result and of the _lody/rate_limits/update notification payload.

    RateLimitsSnapshot::from_json

    source
    fn RateLimitsSnapshot::from_json(raw : Json) -> Result[RateLimitsSnapshot, String]

    RateLimitsSnapshot::to_json

    source

    SessionUsageUpdate

    source
    pub(all) struct SessionUsageUpdate {
      session_id : String
      usage : ModelUsage
      model_usage : Map[String, ModelUsage]?
    } derive(Eq, 
    Debug    )

    SessionUsageUpdate — _lody/session/usage_update notification payload: whole-session usage plus optional per-model buckets.

    SessionUsageUpdate::from_json

    source
    fn SessionUsageUpdate::from_json(raw : Json) -> Result[SessionUsageUpdate, String]

    SessionUsageUpdate::to_json

    source

    LODY_RATE_LIMITS_GET

    source
    let LODY_RATE_LIMITS_GET : String

    LODY_RATE_LIMITS_UPDATE

    source
    let LODY_RATE_LIMITS_UPDATE : String

    LODY_SESSION_GOAL

    source
    let LODY_SESSION_GOAL : String

    LODY_SESSION_HISTORY_READ

    source
    let LODY_SESSION_HISTORY_READ : String

    LODY_SESSION_STEER

    source
    let LODY_SESSION_STEER : String

    LODY_SESSION_STEER_APPLIED

    source
    let LODY_SESSION_STEER_APPLIED : String

    LODY_SESSION_USAGE_UPDATE

    source
    let LODY_SESSION_USAGE_UPDATE : String

    LODY_SUBAGENTS_CANCEL

    source
    let LODY_SUBAGENTS_CANCEL : String

    LODY_SUBAGENTS_LIST

    source
    let LODY_SUBAGENTS_LIST : String

    LODY_SUBAGENTS_OUTPUT

    source
    let LODY_SUBAGENTS_OUTPUT : String

    LODY_TOOL_CRON_CREATE

    source
    let LODY_TOOL_CRON_CREATE : String

    Canonical wire identity of the cron-task creation tool flow.

    LODY_TOOL_CRON_DELETE

    source
    let LODY_TOOL_CRON_DELETE : String

    Canonical wire identity of the cron-task deletion tool flow.

    LODY_TOOL_CRON_LIST

    source
    let LODY_TOOL_CRON_LIST : String

    Canonical wire identity of the cron-task listing tool flow.

    LODY_TOOL_IMAGE_GENERATION

    source
    let LODY_TOOL_IMAGE_GENERATION : String

    Canonical wire identity of the image generation tool flow.

    LODY_TOOL_SCHEDULE_WAKEUP

    source
    let LODY_TOOL_SCHEDULE_WAKEUP : String

    Canonical wire identity of the wakeup scheduling tool flow.

    is_lody_tool_name

    source
    fn is_lody_tool_name(name : String) -> Bool

    True when name is one of the five canonical lody tool identities.

    lody_extension_methods

    source
    fn lody_extension_methods() -> Array[String]

    All ten LODY_EXTENSION_METHODS wire names, upstream declaration order (7 requests then 3 notifications).

    lody_tool_names

    source
    fn lody_tool_names() -> Array[String]

    All five canonical lody tool wire names, upstream declaration order.

    normalize_lody_extension_method

    source
    fn normalize_lody_extension_method(method_name : String) -> String

    normalizeLodyExtensionMethod: prepend the _ namespace prefix when the method does not already start with one.

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io