🥮 mooncakes.io

    colmugx/posoco/error does not have a README file

    AgentError

    source
    pub(all) suberror AgentError {
      Model(String)
      Session(SessionError)
      Runtime(RuntimeError)
      ToolLoopExceeded(consumed~ : Int, limit~ : Int)
      PipelineAborted(String)
      Cancelled(String)
      AutoCompactFailed(String)
    } derive(
    Debug    )

    impl Show for AgentError

    AgentError::output

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

    AgentError::to_repr

    source

    AgentError::to_string

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

    CommandError

    source
    pub(all) suberror CommandError {
      NotFound(String)
      InvalidArgs(reason~ : String)
      ExecutionFailed(String)
    } derive(
    Debug    )

    Errors raised by CommandPort.invoke: unknown command id, invalid args, or execution failure.

    CommandError::output

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

    CommandError::to_repr

    source

    CommandError::to_string

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

    CompositionError

    source
    pub(all) suberror CompositionError {
      ToolCollision(String, String, manifests~ : Array[String])
      CommandCollision(String, manifests~ : Array[String])
      MissingModel
      MultipleModels(manifests~ : Array[String])
      MultipleDecisions(manifests~ : Array[String])
      MultipleLogs(manifests~ : Array[String])
      EmptyManifests
      ManifestSchemaError(manifest_id~ : String, detail~ : String)
      EmptyPort(String)
      ExtensionComposeFailed(manifest_id~ : String, detail~ : String)
    } derive(
    Debug    )

    Composition errors raised during Agent::new (manifest aggregation failures).

    Every variant that involves a specific extension carries manifest_id so callers can locate the offending extension without guessing. Multi-party collisions carry the list of involved manifest ids.

    CompositionError::output

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

    CompositionError::to_repr

    source

    CompositionError::to_string

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

    DecisionError

    source
    pub(all) suberror DecisionError {
      InvalidRequest(String)
      RequestBuild(String)
      Transport(String)
      ResponseParse(String)
      RateLimited(RateLimitInfo)
    } derive(
    Debug    )

    Errors raised by DecisionPort::evaluate. Provider adapters normalize transport/protocol failures into this bounded provider-neutral surface.

    DecisionError::output

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

    DecisionError::to_repr

    source

    DecisionError::to_string

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

    LogError

    source
    pub(all) suberror LogError {
      InvalidRecord(String)
      Write(String)
      Flush(String)
      Unavailable(String)
    } derive(
    Debug    )

    Errors raised by LogPort implementations. Logging failures stay explicit: each consumer decides whether a failed write is best-effort or fatal.
    impl Show for LogError

    LogError::output

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

    LogError::to_repr

    source

    LogError::to_string

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

    MemoryError

    source
    pub(all) suberror MemoryError {
      Inbound(String)
      Store(String)
      Search(String)
      Delete(String)
    } derive(
    Debug    )

    impl Show for MemoryError

    MemoryError::output

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

    MemoryError::to_repr

    source

    MemoryError::to_string

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

    ModelError

    source
    pub(all) suberror ModelError {
      RequestBuild(String)
      Transport(String)
      ResponseParse(String)
      RateLimited(RateLimitInfo)
    } derive(
    Debug    )

    impl Show for ModelError

    ModelError::output

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

    ModelError::to_repr

    source

    ModelError::to_string

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

    RuntimeError

    source
    pub(all) suberror RuntimeError {
      UnknownTool(String)
      InvocationFailed(String)
      Transport(String)
      ToolAlreadyRegistered(String)
    } derive(
    Debug    )

    RuntimeError::output

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

    RuntimeError::to_repr

    source

    RuntimeError::to_string

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

    SessionError

    source
    pub(all) suberror SessionError {
      Load(String)
      Save(String)
      Conflict(String)
    } derive(
    Debug    )

    SessionError::output

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

    SessionError::to_repr

    source

    SessionError::to_string

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

    UiError

    source
    pub(all) suberror UiError {
      Unsupported(detail~ : String)
      Cancelled
      InvalidRequest(detail~ : String)
      IoFailure(detail~ : String)
    } derive(
    Debug    )

    Errors raised by UiPort implementations. UiPort::request MUST raise one of these typed variants instead of an untyped error, so that callers can distinguish "user cancelled" from "this UI doesn't support requests".
    impl Show for UiError

    UiError::output

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

    UiError::to_repr

    source

    UiError::to_string

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

    RateLimitInfo

    source
    pub(all) struct RateLimitInfo {
      message : String
      reset_at_ms : Int64?
      provider_code : String?
    } derive(Eq, 
    Debug    )

    Structured quota/rate-limit verdict returned by a provider. Raised as ModelError::RateLimited instead of Transport so hosts can schedule recovery from typed data instead of parsing strings. Providers disagree on the carrier (HTTP 429, Kimi's 403, gateway JSON fields, free text), so the verdict deliberately carries no status code — only scheduling semantics.

    reset_at_ms is the Unix epoch in milliseconds at which the provider stated the quota window frees; None means no explicit reset time was stated, so waiting is not schedulable and the caller should treat the verdict as terminal for this turn. provider_code is the provider's own machine code for the verdict when available (for example z.ai "1308", OpenAI "usage_limit_reached"). message is a bounded excerpt of the provider message, safe to display.

    RateLimitInfo::equal

    source

    RateLimitInfo::not_equal

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

    RateLimitInfo::to_repr

    source

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io