@fungi.computer/shiitake

Classes

ShiitakeError

Sanitized failure from a parsed Shiitake boundary.

Extends

Error

Constructors

Constructor

new ShiitakeError(boundary, category, message, requestId?, cause?): ShiitakeError

Construct a sanitized boundary failure.

Parameters

boundary

Boundary that rejected the operation.

message

string

Human-readable message safe for callers to display.

requestId?

string

Request identity recoverable when a send may have reached the owner.

cause?

unknown

The original thrown value, kept for server-side diagnosis only. It is never serialized: the wire encoder copies named fields only.

Returns

ShiitakeError

Overrides

Error.constructor

Properties

_tag

readonly _tag: "ShiitakeError"

Stable runtime tag for typed Shiitake failures.

cause

readonly cause: "closed" | "conflict" | "incompatible" | "invalid" | "rejected" | "unavailable"

Safe category describing why it was rejected.

Overrides

Error.cause

underlying?

readonly optional underlying?: unknown

Original cause retained only for server-side diagnosis.

boundary

readonly boundary: "contract" | "extensions" | "instructions" | "model" | "runtime" | "store" | "tools"

Boundary that rejected the operation.

requestId?

readonly optional requestId?: string

Request identity recoverable when a send may have reached the owner.

Type Aliases

ShiitakeErrorBoundary

ShiitakeErrorBoundary = Schema.Schema.Type<typeof ShiitakeErrorBoundarySchema>>

Stable boundary that rejected a Shiitake operation.

ShiitakeErrorCause

ShiitakeErrorCause = Schema.Schema.Type<typeof ShiitakeErrorCauseSchema>>

Safe failure category exposed by both Shiitake facades.

ExtensionCapabilityV0

ExtensionCapabilityV0 = "state" | "settled" | "send" | "timers" | "commands" | "projection" | "run_tools" | "prompt" | "compaction_handoff"

Closed, versioned, feature-free capability vocabulary.

ShiitakeApi

ShiitakeApi = Readonly<{ make: (options) => Promise<ShiitakeAgent>>; }>

Public construction namespace for the Promise-facing durable harness.

ShiitakeHost

ShiitakeHost = Readonly<{ agent: ShiitakeAgent; acceptMail: (mail) => Promise<Accepted>>; }>

Promise-facing host composition with addressed mail kept off Session.

PromptDelivery

PromptDelivery = "steer" | "followUp"

Delivery policy for input accepted while a Session run is active.

SessionCommand

SessionCommand = Schema.Schema.Type<typeof SessionCommandSchema>>

Public Session command inferred from its one runtime parser.

PromptCommand

PromptCommand = Schema.Schema.Type<typeof PromptCommandSchema>>

Public prompt command accepted as durable Session work.

AbortCommand

AbortCommand = Schema.Schema.Type<typeof AbortCommandSchema>>

Public fast-path command that aborts the active Session run.

CancelCommand

CancelCommand = Schema.Schema.Type<typeof CancelCommandSchema>>

Public command that cancels exactly one accepted request.

BranchCommand

BranchCommand = Extract<SessionCommand, Readonly<{ type: "branch"; }>>

Public command that selects one complete entry as the active lineage leaf.

ForkCommand

ForkCommand = Extract<SessionCommand, Readonly<{ type: "fork"; }>>

Public command that creates a new Session from one complete entry lineage.

SqliteValue

SqliteValue = WatchdogSqliteValue

Native SQLite scalar and row grammar shared with the work queue owner.

SqliteRow

SqliteRow = WatchdogSqliteRow

Raw row grammar shared by Woodstock and Watchdog.

SqliteCursor

SqliteCursor = WatchdogSqliteCursor & Readonly<{ one: () => SqliteRow; }>

Native rows stay raw until the query’s maintained schema decodes them.

SqliteOwner

SqliteOwner = Omit<WatchdogSqliteOwner, "sql"> > & Readonly<{ sql: Readonly<{ exec: (statement, …bindings) => SqliteCursor; }>; }>

Synchronous SQL and transactions held by the surrounding runtime.

ModelAcquisition

ModelAcquisition = Readonly<{ model: Model<Api>>; stream?: MuleStreamFunction; retryAfterMs?: (message) => number | undefined; release: () => Promise<void>>; }>

Acquired Pi model and optional explicit Pi stream function.

ModelSource

ModelSource = Readonly<{ acquire: (input) => Promise<ModelAcquisition>>; }>

Deterministic host seam for model selection and ready egress.

InstructionSnapshot

InstructionSnapshot = Readonly<{ revision: string; text: string; modules?: readonly ModuleRegistration[]; release?: () => void; }>

Immutable instruction snapshot captured for one run.

InstructionSource

InstructionSource = Readonly<{ load: (input) => Promise<InstructionSnapshot>>; }>

Host seam for one bounded instruction snapshot.

ToolSource

ToolSource = Readonly<{ execution?: ExecutionOptions; modules?: readonly ModuleRegistration[]; sources?: readonly CapabilitySource[]; sandbox: Sandbox; }>

Mycelium construction inputs captured by the Shiitake-owned run scope.

RuntimePendingWork

RuntimePendingWork = Readonly<{ pending: boolean; nextWakeAt: number | null; }>

Promise host for scheduling the opaque durable reconciler.

RuntimeHost

RuntimeHost = Readonly<{ bind: (input) => Promise<Readonly<{ commit: <A>>(mutation) => Promise<A>>; requestWake: () => Promise<void>>; close: () => Promise<void>>; }>>; }>

Promise host for scheduling the opaque durable reconciler.

ShiitakeOptions

ShiitakeOptions = Readonly<{ store: SqliteOwner; runtime: RuntimeHost; model: ModelSource; instructions: InstructionSource; tools?: ToolSource; files?: FilesSurface; gateTool?: (input) => OperationGate; extensions: ExtensionRosterV0; }>

Validated immutable construction bag for the durable harness.

ModelPreference

ModelPreference = Schema.Schema.Type<typeof ModelPreferenceSchema>>

Null at the Session boundary means inherit the Agent default.

DocumentForkPolicyV0

DocumentForkPolicyV0 = "inherit-at-fork-point" | "current" | "fresh"

Which source value a new Session starts with.

DocumentSpecV0

DocumentSpecV0<A, I> > = Readonly<{ schema: Schema.Codec<A, I>>; initial: A; fork: DocumentForkPolicyV0; maxBytes: number; }>

A typed JSON document, bounded by its encoded UTF-8 size.

Type Parameters

A

A

I

I = A

DocumentsV0

DocumentsV0 = Readonly<Record<string, Readonly<{ schema: Schema.Codec<unknown>>; initial: unknown; fork: DocumentForkPolicyV0; maxBytes: number; }>>>

Existential declarations; each initial value is decoded by its own schema.

DocumentHandleV0

DocumentHandleV0<A> > = Readonly<{ read: (sessionId) => A; update: (sessionId, change) => void; }>

Both operations require the declaring extension’s active core transaction.

Type Parameters

A

A

DocumentHandlesV0

DocumentHandlesV0<D> > = { readonly [K in keyof D]: DocumentHandleV0<D[K]["schema"]["Type"]> }

Handles preserve the decoded type of each declared document.

Type Parameters

D

D extends DocumentsV0

Variables

Shiitake

const Shiitake: ShiitakeApi

Construct the Promise facade over the canonical Effect program.

sqliteRowSchema

const sqliteRowSchema: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.instanceOf<ArrayBuffer, unknown>>, Schema.String, Schema.Number, Schema.Null]>>

A native row is a scalar record; each query owner decodes its own projection.

Functions

parseForkedSession()

parseForkedSession(value): ForkedSession

Parse one serialized fork result using Shiitake’s public client grammar.

Parameters

value

string

Returns

ForkedSession

parseSessionSnapshot()

parseSessionSnapshot(value): SessionSnapshot

Parse one serialized snapshot using Shiitake’s public client grammar.

Parameters

value

string

Returns

SessionSnapshot

parseSessionFrame()

parseSessionFrame(value): SessionFrame

Parse one serialized frame using Shiitake’s public client grammar.

Parameters

value

string

Returns

SessionFrame

makeHost()

makeHost(options, mailRoom): Promise<Readonly<{ agent: ShiitakeAgent; acceptMail: (mail) => Promise<Readonly<{ status: "accepted"; commandId: string; }>>; }>>

Construct the host-only Promise facade over the canonical Effect program.

Parameters

options

ShiitakeOptions

mailRoom

BirdDogEffect

Returns

Promise<Readonly<{ agent: ShiitakeAgent; acceptMail: (mail) => Promise<Readonly<{ status: "accepted"; commandId: string; }>>; }>>