🥮 mooncakes.io

    colmugx/posoco/port does not have a README file

    CommandPort

    source
    pub(open) trait CommandPort {
      fn commands(Self) -> Array[CommandDef]
      async fn invoke(Self, id : String, args : Json) -> CommandOutcome raise 
    CommandError
    }

    User-initiated, enumerable, side-effecting commands. Distinct from ToolProvider (LLM-initiated, results re-enter session). Both panel TUIs and slash command lines consume this without knowing command semantics. pub(open) so any ext can declare commands.

    DecisionPort

    source
    pub(open) trait DecisionPort {
      async fn evaluate(Self, request : DecisionRequest) -> DecisionResult raise 
    DecisionError
    }

    A low-cost semantic judgement capability. The port does not decide final business policy: consumers map the returned probabilities into their own deterministic policy and authority flow.

    Extension

    source
    pub(open) trait Extension {
      fn extension_id(Self) -> String
      fn manifest(Self) -> ExtensionManifest
    }

    Lifecycle

    source
    pub(open) trait Lifecycle {
      fn on_compose(Self, ctx : CompositionView) -> Unit raise 
    CompositionError     = _
      async fn on_start(Self) -> Unit = _
      async fn on_shutdown(Self) -> Unit
    }

    Lifecycle: the extension-facing agent lifecycle, three phases.

    • on_compose: called once, synchronously, after every composition gate has passed (catalog atomic snapshot, model cardinality, collision checks) and before the Agent is ready. This is where the composed capabilities declared in the manifest's requires are delivered via CompositionView. Sync on purpose: ModelPort::chat and UiPort::request are async, so a sync composition point cannot use what it wires — the type system enforces "wire, don't act". Raise CompositionError::ExtensionComposeFailed to fail the composition loudly; no partial Agent is produced.
    • on_start: called once per Agent lifetime, inside the first run_turn (an async context), before the first TurnStarted is projected. This is the legitimate birth point for loading persisted state or spawning background loops — construction time has no async root. Not re-fired after Suspended resumes. Like other async slots the body may raise; the Agent wraps a raised error loudly and the first turn fails before any terminal event is emitted.
    • on_shutdown: resource cleanup hook, called once on agent shutdown in reverse registration order; cleanup failure propagates (loud).

    All methods have defaults: an extension overrides only the phases it cares about, and adding a phase is non-breaking (same pattern as PipelineHook).

    LogPort

    source
    pub(open) trait LogPort {
      async fn write(Self, record : LogRecord, durability : LogDurability) -> Unit raise 
    LogError
      async fn flush(Self) -> Unit raise 
    LogError
    }

    Structured logging port.

    Implementations must preserve call order for writes observed through the same LogPort instance and honour the requested durability before returning. flush commits any buffered records according to the sink's normal durable flush semantics. Implementations should validate records with LogRecord::validate before accepting them.

    MemoryPort

    source
    pub(open) trait MemoryPort {
      async fn inbound(Self, session_id~ : String, request~ : String) -> String? raise 
    MemoryError
      async fn store(Self, content~ : String, metadata~ : Map[String, Json]) -> String raise 
    MemoryError
      async fn search(Self, query~ : String, top_k? : Int) -> String? raise 
    MemoryError
      async fn delete(Self, id : String) -> Unit raise 
    MemoryError
    }

    MemoryPort: session memory — the port a memory system plugs into (nowledge-mem today, OpenViking and any other scheme tomorrow). Four slots: inbound for session-opening recall, store/search/delete for the durable record. Core never labels or re-renders provider output — providers own their text format (community convention e.g. devkit envelopes); core owns only timing, placement, and stability.

    ModelPort

    source
    pub(open) trait ModelPort {
      async fn chat(Self, scope : 
    InvocationScope    , messages : ArrayView[
    Message    ], tools : Array[
    ToolDef    ], options : 
    ChatOptions    , stream : 
    StreamMode    ) -> 
    ModelCallResult     raise 
    ModelError
      async fn compact(Self, scope : 
    InvocationScope    , messages : ArrayView[
    Message    ], options : 
    ChatOptions    , trigger : 
    CompactTrigger    ) -> 
    CompactResult     raise 
    ModelError
      fn provider_config(Self) -> ProviderConfig
    }

    ModelPort: LLM calling interface. Decides HOW to compact; posoco decides WHEN. chat returns ModelCallResult with processed_messages.

    Both model-side entry points receive an InvocationScope identifying the session/run the call serves (chat additionally carries the reducer- allocated effect id). Adapters that key behaviour on session identity — continuity, telemetry, cost attribution, per-session policy — read it from scope; scope-agnostic adapters ignore it. Treat it as read-only.

    Observer

    source
    pub(open) trait Observer {
      fn on_event(Self, event : 
    TurnEvent    ) -> Unit = _
      fn on_event_at(Self, scope : 
    EventScope    ?, event : 
    TurnEvent    ) -> Unit = _
    }

    Observer: read-only event listener. One event channel:

    • Agent-level (on_event / on_event_at): TurnStarted / model response / tool pending and result / TurnCompleted / TurnFailed. Agent projects these directly from committed runtime events; it never reconstructs them by scanning a terminal transcript. on_event_at additionally carries the EventScope attribution (session/run/turn); the core dispatches only the scoped variant and its default delegates here.

    The channel is read-only — never blocks or mutates. For interception or abortion, implement PipelineHook::before_model / PipelineHook::before_tool (they carry block capability via HookAbort / ToolDecision); for real-time per-effect telemetry implement PipelineHook::on_post_event — the former effect-level observer channel was folded into PipelineHook (D5/BR-7).

    PipelineHook

    source
    pub(open) trait PipelineHook {
      async fn before_model(Self, messages : Array[
    Message    ]) -> Array[
    Message    ] raise HookAbort = _
      async fn before_tool(Self, call : 
    ToolCall    ) -> ToolDecision = _
      async fn on_post_event(Self, stage : HookStage) -> Unit noraise = _
      async fn on_post_event_at(Self, scope : 
    EventScope    ?, stage : HookStage) -> Unit noraise = _
      async fn on_turn_begin(Self) -> Unit = _
      async fn on_turn_end(Self) -> Unit = _
    }

    Pipeline interception points covering nearly the whole agent lifecycle: turn begin/end, before/after the model, before/after tools. Registration is unified: an extension puts self (or any implementor) into the manifest's single hooks array and overrides the methods for the points it cares about.

    • on_turn_begin: async turn-start slot. Dispatched once per run_single_turn, after the TurnStarted observer projection and before the pump's first before_model. Symmetric with on_turn_end: pre-turn failures (agent-shutdown guard, lifecycle on_start raises) dispatch nothing — the turn never began. A raise is a secondary failure — reported to observers, never failing the turn — and later hooks still run; cancellation is not a defect.
    • before_model: invoked before the model is called. Can rewrite messages or raise HookAbort. Multiple hooks form a chained rewrite pipeline — each hook sees the previous hook's output.
    • before_tool: invoked before every tool execution. Every hook is evaluated; merge precedence on ToolDecision (consent beats Reject; Defer still aborts the run until M5).
    • on_post_event: invoked after every effect completes. Read-only and non-raising — all registered hooks run in registration order; a handler cannot fail in a typed way, and a contract violation aborts loudly by design. For interception or abortion use before_model / before_tool.
    • on_post_event_at: scoped variant of on_post_event, additionally carrying the EventScope attribution of the run that committed the effect. The core dispatches ONLY this variant; its default delegates to on_post_event, so pre-scope hooks keep working unchanged.
    • on_turn_end: async turn-end slot, no payload. The terminal outcome already lives on the Observer channel — TurnCompleted / TurnFailed(String) — and an extension typically implements Observer and PipelineHook as two views over one shared struct, so a hook that needs the outcome reads its own observer-side state instead of a second payload type. Dispatched once per run_turn, after the terminal observer projection (TurnCompleted / TurnFailed) and before the call returns — on both the completed and the failed path. This is the slot for side effects that must finish by turn end, such as committing buffered writes to an external system. Implementations must carry their own timeout budget and may not block the turn's return indefinitely. Division of labor with Observer::on_event_at(TurnCompleted): the observer slot is sync, read-only and fires first; on_turn_end may await. A raise from on_turn_end is a secondary failure — reported to observers, never replacing the turn's primary outcome — and cancellation is not a defect.

    Async spread: the slots are async, so IO in an implementation body propagates through async. The pipeline dispatches hooks sequentially — each hook is awaited before the next runs — and never opens a thread or worker, so registration order is preserved at every point.

    SessionStore

    source
    pub(open) trait SessionStore {
      async fn load(Self, id : String) -> 
    Session     raise 
    SessionError
      async fn save(Self, id : String, session : 
    Session    ) -> Unit raise 
    SessionError
      async fn append_messages(Self, id : String, from_index : Int, messages : ArrayView[
    Message    ]) -> Unit raise 
    SessionError     = _
      async fn checkpoint(Self, id : String, checkpoint : SessionCheckpoint) -> Unit raise 
    SessionError     = _
      async fn truncate(Self, id : String, from_index : Int) -> Unit raise 
    SessionError     = _
    }

    SystemPromptContributor

    source
    pub(open) trait SystemPromptContributor {
      fn system_prompt(Self) -> String
    }

    Returns a section of the system prompt. Empty strings are skipped.

    Stability contract: the returned text MUST be byte-for-byte identical for the entire lifetime of one Agent. Posoco reads each contributor exactly once — during the first turn's first before_model call — and caches the assembled result. Dynamic signals (e.g. plan-mode toggles) MUST NOT be implemented as contributors; inject them through PipelineHook::before_model as ephemeral User messages instead.

    ToolProvider

    source
    pub(open) trait ToolProvider {
      fn list_tools(Self) -> Array[
    ToolDef    ]
      async fn execute(Self, name : String, call : 
    ToolCall    ) -> 
    ToolOutcome     raise 
    RuntimeError
    }

    ToolProvider: declare tools via list_tools(), execute via execute().

    R3 M3.7: signatures use canonical kernel types directly. ToolDef carries owner + policy at the catalog level; list_tools returns the kernel ToolDef minus those (they are filled in by the catalog builder, since they depend on the agent's tool-routing configuration, not on the tool itself). execute returns ToolOutcome so business errors, runtime errors, and not-executed cases are all distinguishable without a boolean.

    UiPort

    source
    pub(open) trait UiPort {
      fn ui_descriptor(Self) -> UiDescriptor
      fn render(Self, intent : UiRender) -> Unit
      async fn request(Self, req : UiRequest) -> UiResponse raise 
    UiError
    }

    The UI extension contract. Implemented by host packages (cetas-js, cetas-native) or testkit.

    HookAbort

    source
    pub(all) suberror HookAbort {
      Aborted(reason~ : String)
    }

    Raised by PipelineHook::before_model to stop the run before the model is called.
    impl Show for HookAbort

    HookAbort::output

    source
    fn HookAbort::output(self : HookAbort, logger : &Logger) -> Unit

    HookAbort::to_string

    source
    fn HookAbort::to_string(self : HookAbort) -> String

    AutocompleteItem

    source
    pub(all) struct AutocompleteItem {
      label : String
      insert_text : String
      detail : String?
      kind : String
    } derive(
    Debug    )

    AutocompleteSource

    source
    pub(all) struct AutocompleteSource {
      trigger : String
      kind : String
      fetch : (String) -> Array[AutocompleteItem]
    } derive(
    Debug    )

    A source of autocomplete suggestions tied to a trigger character.

    AutocompleteSource::to_repr

    source

    Capability

    source
    pub(all) enum Capability {
      Model
      Decision
      Log
      Ui
      Tasks
    } derive(Eq, 
    Debug    )

    A composed capability an extension declares it consumes. Declaring is what populates the CompositionView delivered at Lifecycle::on_compose — the view gates on this declaration, so an undeclared capability reads as None. Extensible by adding variants; existing manifests are unaffected.

    Capability::equal

    source
    fn Capability::equal(Capability, Capability) -> Bool

    Capability::not_equal

    source
    fn Capability::not_equal(x : Capability, y : Capability) -> Bool

    Capability::to_repr

    source

    CommandDef

    source
    pub(all) struct CommandDef {
      id : String
      label : String
      description : String
      category : String
      ctype : CommandType
      params : Array[CommandParam]
      aliases : Array[String]
      shortcut : String?
      icon : String?
      visible : Bool
      metadata : Json?
    } derive(Eq, 
    Debug    )

    Command declaration. params is the source of truth for argument rendering (panel form) and parsing (slash). Redundant fields (aliases/shortcut/icon/ visible/metadata) are deliberate "escape hatches" for ext authors to use without changing the trait — meta does not define their semantics.

    CommandDef::equal

    source
    fn CommandDef::equal(CommandDef, CommandDef) -> Bool

    CommandDef::not_equal

    source
    fn CommandDef::not_equal(x : CommandDef, y : CommandDef) -> Bool

    CommandDef::to_repr

    source

    CommandOutcome

    source
    pub(all) enum CommandOutcome {
      Success(feedback~ : String, structured~ : Json?, ui_hint~ : UiHint?)
      Failure(reason~ : String)
      NeedsInput(prompt~ : String)
    } derive(Eq, 
    Debug    )

    Outcome of invoking a command. feedback is for slash (print directly); structured + ui_hint are for panel (deep render + UI action). NeedsInput supports multi-step commands.

    CommandOutcome::equal

    source

    CommandOutcome::not_equal

    source
    fn CommandOutcome::not_equal(x : CommandOutcome, y : CommandOutcome) -> Bool

    CommandOutcome::to_repr

    source

    CommandParam

    source
    pub(all) struct CommandParam {
      name : String
      label : String
      description : String
      ptype : ParamType
      required : Bool
      default : Json?
      choices : Array[String]?
      positional : Bool
    } derive(Eq, 
    Debug    )

    A single command parameter. Explicit and human-facing, in contrast to ToolDef.input_schema (which is JSON Schema for LLM consumption).

    CommandParam::equal

    source

    CommandParam::not_equal

    source
    fn CommandParam::not_equal(x : CommandParam, y : CommandParam) -> Bool

    CommandParam::to_repr

    source

    CommandType

    source
    pub(all) enum CommandType {
      Action
      Toggle
      Select
      Input
      MultiStep
    } derive(Eq, 
    Debug    )

    Semantic command type. Determines how a panel renders the control (button / toggle / dropdown / input / multi-step form) and how a slash parser expects arguments.

    CommandType::equal

    source
    fn CommandType::equal(CommandType, CommandType) -> Bool

    CommandType::not_equal

    source
    fn CommandType::not_equal(x : CommandType, y : CommandType) -> Bool

    CommandType::to_repr

    source

    CompositionView

    source
    pub struct CompositionView {
      // private fields
    }

    CompositionView: the curated read-only view of composed capabilities delivered to Lifecycle::on_compose after every composition gate has passed. This is the consumption direction of the manifest contract — an extension declares requires and the corresponding getter reads Some; undeclared capabilities read None.

    Curation discipline: the view only ever carries capabilities whose use cannot bypass governance. model calls still carry InvocationScope attribution; ui has no governance surface. The view NEVER exposes tool invocation (would bypass PipelineHook::before_tool), session stores (state ownership), or observer-event emission (core-owned). Fields are private with getters so new capabilities can be added without breaking extensions that destructure or construct views in tests.

    CompositionView::decision

    source
    fn CompositionView::decision(self : CompositionView) -> &DecisionPort?

    The single optional composed DecisionPort — visible only when the extension declared Capability::Decision. Absence is legal: consumers that treat decision support as an enhancement should keep their deterministic fallback; consumers that require it may fail explicitly in on_compose.

    CompositionView::log

    source

    The single optional composed LogPort — visible only when the extension declared Capability::Log. Absence is legal: logging is optional infrastructure, and consumers decide whether a missing sink is acceptable.

    CompositionView::model

    source

    The single composed ModelPort — present only when the extension declared Capability::Model in its manifest's requires. This is the unique outlet that passed the composition cardinality gate, source-agnostic (the extension cannot tell a plain provider from a routing meta-extension, and must not).

    CompositionView::resolve

    source
    fn CompositionView::resolve(requires~ : Array[Capability], model~ : &ModelPort, decision? : &DecisionPort?, log? : &LogPort?, ui~ : &UiPort, tasks? : Tasks?) -> CompositionView

    Gate a view on a manifest's declared requires: a declared capability is populated from the composed ports, an undeclared one reads None. Called by the composition after every gate has passed, so model and ui are guaranteed to be the final composed values.

    CompositionView::tasks

    source
    fn CompositionView::tasks(self : CompositionView) -> Tasks?

    The Agent-owned structured task capability, present only when the extension declares Capability::Tasks.

    CompositionView::ui

    source

    The composed UiPort (single contributor, CompositeUiPort, or NoopUiPort) — present only when the extension declared Capability::Ui. Human-interaction requests (UiRequest::Confirm / Select / Input) go here; do not occupy the ui manifest slot just to consume the composed UI.

    DecisionAnswer

    source
    pub(all) enum DecisionAnswer {
      BooleanAnswer(id~ : String, probability_true~ : Double)
      ChoiceAnswer(id~ : String, selected~ : String, probabilities~ : Array[DecisionNamedProbability], confidence~ : Double?)
      ScoreAnswer(id~ : String, score~ : Double, probabilities~ : Array[Double], confidence~ : Double?)
    } derive(Eq, 
    Debug    )

    Provider-neutral typed answer. The question id is repeated so adapters can be validated without relying on response ordering.

    DecisionAnswer::equal

    source

    DecisionAnswer::not_equal

    source
    fn DecisionAnswer::not_equal(x : DecisionAnswer, y : DecisionAnswer) -> Bool

    DecisionAnswer::to_repr

    source

    DecisionNamedProbability

    source
    pub(all) struct DecisionNamedProbability {
      id : String
      probability : Double
    } derive(Eq, 
    Debug    )

    One named probability in a choice distribution.

    DecisionNamedProbability::equal

    source

    DecisionNamedProbability::not_equal

    source

    DecisionNamedProbability::to_repr

    source

    DecisionOption

    source
    pub(all) struct DecisionOption {
      id : String
      description : Json?
    } derive(Eq, 
    Debug    )

    One named alternative for a Choice question.

    DecisionOption::equal

    source

    DecisionOption::not_equal

    source
    fn DecisionOption::not_equal(x : DecisionOption, y : DecisionOption) -> Bool

    DecisionOption::to_repr

    source

    DecisionQuestion

    source
    pub(all) enum DecisionQuestion {
      Boolean(id~ : String, instructions~ : Json, true_criteria~ : Json?, false_criteria~ : Json?)
      Choice(id~ : String, instructions~ : Json, options~ : Array[DecisionOption])
      Score(id~ : String, instructions~ : Json, levels~ : Array[Json])
    } derive(Eq, 
    Debug    )

    Typed question understood by a DecisionPort.

    DecisionQuestion::equal

    source

    DecisionQuestion::not_equal

    source
    fn DecisionQuestion::not_equal(x : DecisionQuestion, y : DecisionQuestion) -> Bool

    DecisionQuestion::to_repr

    source

    DecisionRequest

    source
    pub(all) struct DecisionRequest {
      state : Json
      questions : Array[DecisionQuestion]
    } derive(Eq, 
    Debug    )

    Structured state plus a non-empty set of independent semantic questions.

    DecisionRequest::equal

    source

    DecisionRequest::not_equal

    source
    fn DecisionRequest::not_equal(x : DecisionRequest, y : DecisionRequest) -> Bool

    DecisionRequest::to_repr

    source

    DecisionRequest::validate

    source

    Validate provider-neutral request invariants before an adapter builds its wire request. Providers may impose additional limits, but must not accept requests that violate these base invariants.

    DecisionResult

    source
    pub(all) struct DecisionResult {
      answers : Array[DecisionAnswer]
      model : String?
      usage : DecisionUsage?
    } derive(Eq, 
    Debug    )

    Typed answers plus provider-reported model/usage metadata. model is descriptive observability only; consumers must not branch policy on a provider identity hidden behind this port.

    DecisionResult::equal

    source

    DecisionResult::not_equal

    source
    fn DecisionResult::not_equal(x : DecisionResult, y : DecisionResult) -> Bool

    DecisionResult::to_repr

    source

    DecisionResult::validate_for

    source

    Validate a provider result against the request that produced it. Adapters should call this before returning so malformed or semantically mismatched provider payloads fail loudly as DecisionError::ResponseParse.

    DecisionUsage

    source
    pub(all) struct DecisionUsage {
      input_tokens : Int?
      output_tokens : Int?
    } derive(Eq, 
    Debug    )

    Optional token accounting supplied by decision providers.

    DecisionUsage::equal

    source

    DecisionUsage::not_equal

    source
    fn DecisionUsage::not_equal(x : DecisionUsage, y : DecisionUsage) -> Bool

    DecisionUsage::to_repr

    source

    ExtensionManifest

    source
    pub(all) struct ExtensionManifest {
      id : String
      models : Array[&ModelPort]
      decisions : Array[&DecisionPort]
      logs : Array[&LogPort]
      tools : Array[&ToolProvider]
      sessions : Array[&SessionStore]
      observers : Array[&Observer]
      hooks : Array[&PipelineHook]
      memory : Array[&MemoryPort]
      lifecycle : Array[&Lifecycle]
      commands : Array[&CommandPort]
      ui : Array[&UiPort]
      prompt_contributors : Array[&SystemPromptContributor]
      requires : Array[Capability]
    }

    Self-reported port contributions. Build one with ExtensionManifest::make, which defaults every omitted field to an empty array; multi-trait extensions put self under each applicable field.

    requires is the consumption direction: the extension declares which composed capabilities it wants delivered at Lifecycle::on_compose. The declaration is load-bearing (the view gates on it) and auditable (composition can answer "which extensions declared model access").

    ExtensionManifest::ExtensionManifest

    source
    fn ExtensionManifest::ExtensionManifest(id~ : String, models? : Array[&ModelPort], decisions? : Array[&DecisionPort], logs? : Array[&LogPort], tools? : Array[&ToolProvider], sessions? : Array[&SessionStore], observers? : Array[&Observer], hooks? : Array[&PipelineHook], memory? : Array[&MemoryPort], lifecycle? : Array[&Lifecycle], commands? : Array[&CommandPort], ui? : Array[&UiPort], prompt_contributors? : Array[&SystemPromptContributor], requires? : Array[Capability]) -> ExtensionManifest

    ExtensionManifest::default

    source
    fn ExtensionManifest::default(id~ : String) -> ExtensionManifest

    Construct an empty manifest with only the id set. Fields can then be assigned individually.

    HookStage

    source
    pub(all) enum HookStage {
      ModelCompleted(completion~ : 
    Completion    )
      ToolCompleted(call~ : 
    ToolCall    , outcome~ : 
    ToolOutcome    )
      ToolFailed(call~ : 
    ToolCall    , reason~ : String)
      ModelFailed(failure~ : 
    ModelFailure    )
    } derive(
    Debug    )

    Describes what just completed, delivered after the effect is committed.
    impl Show for HookStage

    HookStage::output

    source
    fn HookStage::output(self : HookStage, logger : &Logger) -> Unit

    HookStage::to_repr

    source

    HookStage::to_string

    source
    fn HookStage::to_string(self : HookStage) -> String

    LogDurability

    source
    pub(all) enum LogDurability {
      Buffered
      Written
      Durable
    } derive(Eq, 
    Debug    )

    Persistence acknowledgement requested by a log producer.

    • Buffered: the sink accepted the record; it may still live only in memory.
    • Written: the sink completed its normal write path.
    • Durable: the sink crossed its durability barrier before returning.

    LogDurability::equal

    source

    LogDurability::not_equal

    source
    fn LogDurability::not_equal(x : LogDurability, y : LogDurability) -> Bool

    LogDurability::to_repr

    source

    LogLevel

    source
    pub(all) enum LogLevel {
      Trace
      Debug
      Info
      Warn
      Error
    } derive(Eq, 
    Debug    )

    LogLevel::equal

    source
    fn LogLevel::equal(LogLevel, LogLevel) -> Bool

    LogLevel::not_equal

    source
    fn LogLevel::not_equal(x : LogLevel, y : LogLevel) -> Bool

    LogLevel::to_repr

    source

    LogRecord

    source
    pub(all) struct LogRecord {
      level : LogLevel
      source : String
      channel : String
      event : String
      message : String?
      scope : 
    EventScope    ?
      data : Json
    } derive(Eq, 
    Debug    )

    Provider-neutral structured log record.

    source, channel, and event are stable machine-readable identifiers. message is optional human-readable context. scope attributes records to a Posoco session/run/turn when one exists. data is producer-owned JSON; sinks must not inspect it to infer secrets or policy.

    LogRecord::equal

    source
    fn LogRecord::equal(LogRecord, LogRecord) -> Bool

    LogRecord::not_equal

    source
    fn LogRecord::not_equal(x : LogRecord, y : LogRecord) -> Bool

    LogRecord::to_repr

    source

    LogRecord::validate

    source

    Validate the protocol-level fields that every sink may rely on.

    ParamType

    source
    pub(all) enum ParamType {
      Str
      Int
      Bool
      Strs
    } derive(Eq, 
    Debug    )

    Value type of a command parameter. Human-friendly (unlike JSON Schema which targets LLMs). Panel/slash consumers render and parse directly from this.

    ParamType::equal

    source
    fn ParamType::equal(ParamType, ParamType) -> Bool

    ParamType::not_equal

    source
    fn ParamType::not_equal(x : ParamType, y : ParamType) -> Bool

    ParamType::to_repr

    source

    ProviderConfig

    source
    pub(all) struct ProviderConfig {
      reasoning_effort_values : Array[String]
      context_window : Int?
      compact_threshold : Double?
    } derive(Eq, 
    Debug    )

    ProviderConfig: modelport's self-description of accepted config values. A String array (not typed enum) because each provider has its own vocabulary for e.g. reasoning_effort values.

    ProviderConfig::ProviderConfig

    source
    fn ProviderConfig::ProviderConfig(reasoning_effort_values~ : Array[String], context_window? : Int?, compact_threshold? : Double?) -> ProviderConfig

    ProviderConfig::accepts_reasoning_effort

    source
    fn ProviderConfig::accepts_reasoning_effort(self : ProviderConfig, value : String) -> Bool

    Check if the given reasoning_effort value is accepted.

    ProviderConfig::empty

    source

    Empty config: no reasoning_effort values accepted, no window reported.

    ProviderConfig::equal

    source

    ProviderConfig::not_equal

    source
    fn ProviderConfig::not_equal(x : ProviderConfig, y : ProviderConfig) -> Bool

    ProviderConfig::output

    source
    fn ProviderConfig::output(self : ProviderConfig, logger : &Logger) -> Unit

    ProviderConfig::to_repr

    source

    ProviderConfig::to_string

    source
    fn ProviderConfig::to_string(self : ProviderConfig) -> String

    SessionCheckpoint

    source
    pub(all) struct SessionCheckpoint {
      from_index : Int
      messages : Array[
    Message    ]
      metadata : Map[String, Json]?
    } derive(Eq, 
    Debug    )

    One append-safe session durability boundary. from_index is the number of messages the caller believes are already persisted. messages is the canonical tail to append. metadata=None means metadata is unchanged; Some(metadata) replaces the session metadata at the same checkpoint.

    Keeping message and metadata deltas in one operation prevents callers from committing transcript progress while silently dropping session state such as an automatic title, context state, or task bookkeeping.

    SessionCheckpoint::equal

    source

    SessionCheckpoint::not_equal

    source
    fn SessionCheckpoint::not_equal(x : SessionCheckpoint, y : SessionCheckpoint) -> Bool

    SessionCheckpoint::to_repr

    source

    TaskHandle

    source
    pub struct TaskHandle {
      // private fields
    }

    Opaque handle for one admitted task. The callbacks are installed by core composition; extensions only receive wait/cancel operations.

    TaskHandle::cancel

    source
    fn TaskHandle::cancel(self : TaskHandle) -> Unit

    TaskHandle::from_callbacks

    source
    fn TaskHandle::from_callbacks(receipt~ : TaskReceipt, wait~ : async (TaskReceipt) -> TaskOutcome, cancel~ : (TaskReceipt) -> Unit) -> TaskHandle

    Framework construction hook for the opaque handle.

    TaskHandle::receipt

    source
    fn TaskHandle::receipt(self : TaskHandle) -> TaskReceipt

    TaskHandle::wait

    source
    async fn TaskHandle::wait(self : TaskHandle) -> TaskOutcome

    TaskMode

    source
    pub(all) enum TaskMode {
      Foreground
      Background
    } derive(Eq, 
    Debug    )

    Execution lifetime for work submitted through the composed task capability.

    TaskMode::equal

    source
    fn TaskMode::equal(TaskMode, TaskMode) -> Bool

    TaskMode::not_equal

    source
    fn TaskMode::not_equal(x : TaskMode, y : TaskMode) -> Bool

    TaskMode::to_repr

    source

    TaskOutcome

    source
    pub(all) struct TaskOutcome {
      receipt : TaskReceipt
      status : TaskStatus
    } derive(Eq, 
    Debug    )

    A task's terminal result. Background outcomes are retained by session until the owning Agent successfully commits them.

    TaskOutcome::equal

    source
    fn TaskOutcome::equal(TaskOutcome, TaskOutcome) -> Bool

    TaskOutcome::not_equal

    source
    fn TaskOutcome::not_equal(x : TaskOutcome, y : TaskOutcome) -> Bool

    TaskOutcome::to_repr

    source

    TaskReceipt

    source
    pub(all) struct TaskReceipt {
      id : String
      session_id : String
      mode : TaskMode
      label : String
      extension_id : String
    } derive(Eq, 
    Debug    )

    Stable identity returned at admission. The id is opaque to the caller.

    TaskReceipt::equal

    source
    fn TaskReceipt::equal(TaskReceipt, TaskReceipt) -> Bool

    TaskReceipt::not_equal

    source
    fn TaskReceipt::not_equal(x : TaskReceipt, y : TaskReceipt) -> Bool

    TaskReceipt::to_repr

    source

    TaskSpec

    source
    pub(all) struct TaskSpec {
      session_id : String
      mode : TaskMode
      label : String
      timeout_ms : Int?
      run : async () -> 
    Message
    }

    A unit of Agent-owned work. The Agent supplies the structured scope and records the terminal outcome; callers never supply a TaskGroup.

    TaskStatus

    source
    pub(all) enum TaskStatus {
      Completed(message~ : 
    Message    )
      Failed(reason~ : String)
      TimedOut
      Cancelled(reason~ : String)
    } derive(Eq, 
    Debug    )

    The single terminal state shared by foreground waits and background inbox delivery.

    TaskStatus::equal

    source
    fn TaskStatus::equal(TaskStatus, TaskStatus) -> Bool

    TaskStatus::not_equal

    source
    fn TaskStatus::not_equal(x : TaskStatus, y : TaskStatus) -> Bool

    TaskStatus::to_repr

    source

    TaskSubmitError

    source
    pub(all) enum TaskSubmitError {
      Unavailable
      Closed
      QueueFull
      InvalidSession(reason~ : String)
    } derive(Eq, 
    Debug    )

    Admission failures are explicit so an extension cannot mistake an inactive scope or a closed Agent for accepted work.

    TaskSubmitError::equal

    source

    TaskSubmitError::not_equal

    source
    fn TaskSubmitError::not_equal(x : TaskSubmitError, y : TaskSubmitError) -> Bool

    TaskSubmitError::to_repr

    source

    Tasks

    source
    pub struct Tasks {
      // private fields
    }

    Concrete composed capability. It is deliberately a value rather than a public trait: task admission is Agent-owned and has no replacement port.

    Tasks::from_submit

    source
    fn Tasks::from_submit(submit~ : (TaskSpec) -> Result[TaskHandle, TaskSubmitError]) -> Tasks

    Framework construction hook. Product extensions obtain the value through CompositionView and do not need this constructor.

    Tasks::submit

    source
    fn Tasks::submit(self : Tasks, spec : TaskSpec) -> Result[TaskHandle, TaskSubmitError]

    ToolDecision

    source
    pub(all) enum ToolDecision {
      Approve(call~ : 
    ToolCall    )
      ApproveAfterConsent(call~ : 
    ToolCall    , consent_scope~ : String)
      Defer(reason~ : String)
      Reject(reason~ : String)
    } derive(
    Debug    )

    The hook's decision for a pending tool call.

    Chain semantics: every registered hook is evaluated (no short-circuit). Precedence: a raise aborts the run; Defer terminal-rejects until M5; ApproveAfterConsent beats Reject; Reject skips the call and feeds the joined reasons back to the model as a NotExecuted(RejectedByHook) tool result; otherwise the call executes with the chained rewrite. The complete chain is finalized before catalog validation and scheduling, so the final call determines its schema, owner, and execution policy. Consent binds to the exact call_id, name, and arguments returned by that consent decision; a later mutation cannot reuse it, and call_id is never rewriteable.

    ToolDecision::output

    source
    fn ToolDecision::output(self : ToolDecision, logger : &Logger) -> Unit

    ToolDecision::to_repr

    source

    ToolDecision::to_string

    source
    fn ToolDecision::to_string(self : ToolDecision) -> String

    UiBody

    source
    pub(all) enum UiBody {
      Text(String)
      Lines(Array[String])
      KeyValue(Array[(String, String)])
      Entries(Array[UiEntry])
      Progress(Double)
      Markdown(String)
    } derive(
    Debug    )

    Structured payload a render intent carries. Host decides layout and color.
    impl Show for UiBody

    UiBody::output

    source
    fn UiBody::output(self : UiBody, logger : &Logger) -> Unit

    UiBody::to_repr

    source

    UiBody::to_string

    source
    fn UiBody::to_string(self : UiBody) -> String

    UiDescriptor

    source
    pub(all) struct UiDescriptor {
      autocomplete_sources : Array[AutocompleteSource]
    } derive(
    Debug    )

    Collected at composition time: the host aggregates every UiPort's descriptors to know which autocomplete triggers to honor.

    UiDescriptor::empty

    source
    fn UiDescriptor::empty() -> UiDescriptor

    Empty descriptor used by UIs that contribute no autocomplete sources.

    UiDescriptor::to_repr

    source

    UiEntry

    source
    pub(all) struct UiEntry {
      key : String
      value : String
      color : String?
    } derive(
    Debug    )

    One keyed entry of an Entries body. color carries a semantic role name from the host-negotiated vocabulary, never a raw color value.

    UiEntry::to_repr

    source

    UiHint

    source
    pub(all) enum UiHint {
      RefreshModelList
      RefreshSettings
      ClosePanel
      Toast
      None
    } derive(Eq, 
    Debug    )

    Hint to a panel consumer about what UI action to take after invoke. Slash consumers ignore this. Fixed enum + None fallback; ext long-tail needs go through CommandDef.metadata.

    UiHint::equal

    source
    fn UiHint::equal(UiHint, UiHint) -> Bool

    UiHint::not_equal

    source
    fn UiHint::not_equal(x : UiHint, y : UiHint) -> Bool

    UiHint::to_repr

    source

    UiRender

    source
    pub(all) struct UiRender {
      slot : UiSlot
      key : String
      title : String?
      body : UiBody
      ttl_ms : Int?
    } derive(
    Debug    )

    One render intent. Same key replaces a prior intent in the same UiSlot.
    impl Show for UiRender

    UiRender::output

    source
    fn UiRender::output(self : UiRender, logger : &Logger) -> Unit

    UiRender::to_repr

    source

    UiRender::to_string

    source
    fn UiRender::to_string(self : UiRender) -> String

    UiRequest

    source
    pub(all) enum UiRequest {
      Input(prompt~ : String, default~ : String?)
      Confirm(prompt~ : String)
      Select(prompt~ : String, options~ : Array[String], default~ : Int?)
    } derive(
    Debug    )

    User interaction primitives. Hosts that lack a variant raise UiError::Unsupported.
    impl Show for UiRequest

    UiRequest::output

    source
    fn UiRequest::output(self : UiRequest, logger : &Logger) -> Unit

    UiRequest::to_repr

    source

    UiRequest::to_string

    source
    fn UiRequest::to_string(self : UiRequest) -> String

    UiResponse

    source
    pub(all) enum UiResponse {
      Text(String)
      Yes
      No
      Selected(Int)
      Cancelled
    } derive(Eq, 
    Debug    )

    Response to a UiRequest. Cancelled = user dismissed; no UI = UiError::Unsupported.
    impl Show for UiResponse

    UiResponse::equal

    source
    fn UiResponse::equal(UiResponse, UiResponse) -> Bool

    UiResponse::not_equal

    source
    fn UiResponse::not_equal(x : UiResponse, y : UiResponse) -> Bool

    UiResponse::output

    source
    fn UiResponse::output(self : UiResponse, logger : &Logger) -> Unit

    UiResponse::to_repr

    source

    UiResponse::to_string

    source
    fn UiResponse::to_string(self : UiResponse) -> String

    UiSlot

    source
    pub(all) enum UiSlot {
      Status
      Notice
      Widget
    } derive(Eq, 
    Debug    )

    Where a render intent lands: Status (single-line bar), Notice (transient toast), Widget (persistent region).
    impl Show for UiSlot

    UiSlot::equal

    source
    fn UiSlot::equal(UiSlot, UiSlot) -> Bool

    UiSlot::not_equal

    source
    fn UiSlot::not_equal(x : UiSlot, y : UiSlot) -> Bool

    UiSlot::output

    source
    fn UiSlot::output(self : UiSlot, logger : &Logger) -> Unit

    UiSlot::to_repr

    source

    UiSlot::to_string

    source
    fn UiSlot::to_string(self : UiSlot) -> String

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io