client

Import

Import

import * as api from "@fungi.computer/shiitake/client";

Exports

Kind	Export	Description
Ttype alias	ParticipantPolicy	The host decides which Agent work may be delivered to this participant.
Ttype alias	VisitorView	What a visitor may see of their own conversation Session.
Ttype alias	VisitorPendingPrompt	Public pending facts exclude the host’s private metadata and admission origin.
Ttype alias	Accepted	Semantic acknowledgement returned after one durable acceptance commit.
Ttype alias	Held	Durable relay custody, not acceptance of a command by the recipient.
Ttype alias	DelegationReceipt	A delegation send can be accepted by the Agent or held by its relay.
Ttype alias	TooLate	Cancelling found nothing left to cancel: the command is unknown to this Session, has already started (for an onlyIfPending cancel) or has already settled. It is an ordinary outcome, never an error.
Ttype alias	UnknownRequest	No command has been admitted under this request key in the addressed Session.
Ttype alias	CancelResult	Outcome of one cancel command or request-based recall.
Ttype alias	WithdrawResult	Atomic admission resolution: accepted work is kept; an unknown key is fenced forever.
Ttype alias	ForkedSession	Result returned after a fork commits a new cold-readable Session.
Ttype alias	SessionCommandHandler	Execute one retained type-discriminated Session command.
Ttype alias	SendOptions	Optional controls for the Promise-friendly text sender.
Ttype alias	ModelMessage	Model-facing Pi content. Application tool display payloads belong to the surrounding entry’s data, never to a message sent back to a provider.
Ttype alias	SessionMessage	One completed model message and its separate application payload.
Ttype alias	ShiitakeEventSourceConstructor	Minimal constructor seam for runtimes without a global EventSource.
Ttype alias	SessionTerminal	Durable outcome for one accepted work item on the selected Session lineage.
Ttype alias	AgentRunningWork	Work occupying the executor partition that this queued command requires, without message or provider data.
Ttype alias	SessionActivity	Raw facts about what a Session is doing now. Shiitake publishes facts only; a client decides what they mean (see Parakeet’s sessionViewState).
Ttype alias	SessionExtensionSlots	Encoded extension slots keyed by extension identity; absent means unavailable.
Ttype alias	SessionExtensionControls	Generic Session-scope extension commands.
Ttype alias	AgentExtensionControls	Generic Agent-scope extension controls.
Ttype alias	SessionToolOutput	Process-local running tool tail; never a durable Session fact.
Ttype alias	SessionProgress	Process-local assistant progress; never a durable Session fact.
Ttype alias	SessionPendingPrompt	Accepted prompt waiting to enter the conversation, not a scheduling command.
Ttype alias	SessionPendingPrompts	Bounded current admission view, in acceptance order rather than execution order.
Ttype alias	SessionCompactionMarker	Minimal full-history compaction boundary marker. sequence is the Woodstock order of the row this marker precedes (ties sort the marker first); at is when the compaction ran. The agent’s model context is unaffected by this marker; it exists only for the client timeline.
Ttype alias	SessionCompactionTrigger	What started a compaction: the user, the context threshold, or an overflow.
Ttype alias	SessionCompactionNotice	A compaction that changed nothing: a manual request with nothing to summarize yet, a compaction that failed, or a finished background summary dropped unplaced: stale because the context had moved past its head, or insufficient because placing it would have left the context over the limit. Automatic failures are never silent; each one is a notice at its own place in the timeline.
Ttype alias	SessionContext	The Session’s context use as compaction measures it, against the window of the model a run would select now; the window is null when that model reports none.
Ttype alias	SessionSnapshot	Bounded Session baseline at one opaque owner cursor.
Ttype alias	SessionFrame	One bounded replay or live frame.
Ttype alias	SubscribeOptions	Strict-after replay request.
Ttype alias	ReadOptions	Bounded baseline request.
Ttype alias	WatchOptions	Race-safe observation request.
Ttype alias	SessionWatch	Race-safe baseline plus live changes resource.
Ttype alias	ShiitakeSession	Addressable Session interface. Addressing itself performs no I/O.
Ttype alias	SessionInboxState	Owner-decided inbox state, from Watchdog’s queue head and latest outcome. running covers queued, thinking, streaming, retrying and cancelling; errored covers failed, interrupted and outcome_unknown; done covers completed, cancelled and never run. Any open extension attention produces needs_you, taking priority over live and settled work.
Ttype alias	SessionSummary	Read-only saved conversation projection; opening does not update recency.
Ttype alias	SessionSummaryRow	One listed conversation, or a saved Session its owner could not read.
Ttype alias	SessionSummaryPage	One owner-bounded page: needs_you, then running, then settled rows, each newest activity first. next is an opaque owner cursor.
Ttype alias	ShiitakeAgent	Constructed durable harness.
Ttype alias	ExtensionViewV0	What one client sees of an extension in a Session observation.
Ttype alias	ScopedCommandsV0	Command names of one scope, typed by the shared contract.
Ttype alias	BoundCallV0	Typed call surface of one contract’s commands in one scope.
Ttype alias	BoundSessionExtensionV0	One Session bound to one extension contract.
Ttype alias	BoundAgentExtensionV0	One Agent bound to one extension contract.
Ttype alias	ShiitakeClientOptions	Network location of one remotely hosted Shiitake agent.
Ttype alias	SessionAttention	One open attention item in a Session observation.
constconstant	AcceptedSchema	Decode a durable command acceptance value at an RPC boundary.
constconstant	HeldSchema	Parse the relay’s custody acknowledgment without implying Agent acceptance.
constconstant	DelegationReceiptSchema	A delegated send is accepted by its owner or held in durable mail custody.
fnfunction	participantSnapshot()	Filter participant delivery only; the holder’s stored Session is unchanged.
fnfunction	visitorPendingPrompt()	Project one owner-selected prompt without exposing host identity or correlation metadata.
fnfunction	visitorSnapshot()	Visitor-scoped Session facts use the visitor’s public address, never the internal Session ID.
fnfunction	visitorView()	Project only this visitor’s host-attributed prompts, their replies, and explicit operator replies.
fnfunction	parseDelegationReceipt()	Decode one delegated send’s acceptance or durable-custody result.
fnfunction	parseWithdrawResult()	Decode the owner’s atomic request resolution.
fnfunction	parseAccepted()	Parse one serialized command acceptance using Shiitake’s public grammar.
fnfunction	parseCancelResult()	Parse one serialized cancel outcome: accepted, or too late.
fnfunction	parseLatestPendingPrompt()	Decode the host-authorized newest pending lookup, including an empty result.
fnfunction	parseShiitakeError()	Parse one serialized canonical Shiitake failure.
fnfunction	parseSessionSummaryPage()	Decode the existing bounded saved-conversation projection.
fnfunction	bindSessionExtension()	Bind one Session to one extension contract; the contract’s schemas decode.
fnfunction	bindAgentExtension()	Bind one Agent to one extension contract’s Agent-scope commands.
fnfunction	createShiitakeClient()	Connect to a remotely hosted Shiitake agent.

ParticipantPolicyTtype alias

Signature

type ParticipantPolicy = Readonly<{
  turnIsCurrent: (sessionId, commandId) => boolean;
  deliverAgentReply: (sessionId, commandId, reply) => boolean;
}>;

The host decides which Agent work may be delivered to this participant.

---

VisitorViewTtype alias

Signature

type VisitorView = Readonly<{
  status: "idle" | "working";
  lines: readonly Readonly<{
    id: string;
    from: "visitor" | "agent" | "operator";
    text: string;
  }>[];
  progress: string | null;
}>;

What a visitor may see of their own conversation Session.

---

VisitorPendingPromptTtype alias

Signature

type VisitorPendingPrompt = Pick<
  SessionPendingPrompt,
  "commandId" | "requestId" | "text" | "delivery" | "images"
>;

Public pending facts exclude the host’s private metadata and admission origin.

---

AcceptedTtype alias

Signature

type Accepted = Readonly<{
  status: "accepted";
  commandId: string;
  sessionId?: string;
}>;

Semantic acknowledgement returned after one durable acceptance commit.

---

HeldTtype alias

Signature

type Held = Readonly<{
  status: "held";
  reason: "recipient_offline";
  message: "waiting: recipient offline";
}>;

Durable relay custody, not acceptance of a command by the recipient.

---

DelegationReceiptTtype alias

Signature

type DelegationReceipt = Accepted | Held;

A delegation send can be accepted by the Agent or held by its relay.

---

TooLateTtype alias

Signature

type TooLate = Readonly<{
  status: "too_late";
  commandId: string;
}>;

Cancelling found nothing left to cancel: the command is unknown to this Session, has already started (for an onlyIfPending cancel) or has already settled. It is an ordinary outcome, never an error.

---

UnknownRequestTtype alias

Signature

type UnknownRequest = Readonly<{
  status: "unknown";
}>;

No command has been admitted under this request key in the addressed Session.

---

CancelResultTtype alias

Signature

type CancelResult = Accepted | TooLate | UnknownRequest;

Outcome of one cancel command or request-based recall.

---

WithdrawResultTtype alias

Signature

type WithdrawResult = Accepted | UnknownRequest;

Atomic admission resolution: accepted work is kept; an unknown key is fenced forever.

---

ForkedSessionTtype alias

Signature

type ForkedSession = Readonly<{
  sessionId: string;
}>;

Result returned after a fork commits a new cold-readable Session.

---

SessionCommandHandlerTtype alias

Signature

type SessionCommandHandler = {
  (input): Promise<
    Readonly<{
      status: "accepted";
      commandId: string;
      sessionId?: string;
    }>
  >;
  (input): Promise<CancelResult>;
  (input): Promise<undefined>;
  (input): Promise<
    Readonly<{
      sessionId: string;
    }>
  >;
  (input): Promise<
    | CancelResult
    | Readonly<{
        sessionId: string;
      }>
    | undefined
  >;
};

Execute one retained type-discriminated Session command.

Call Signature

Signature

(input): Promise<Readonly<{
  status: "accepted";
  commandId: string;
  sessionId?: string;
}>>;

Accept a prompt or a compaction request as queued Session work.

Parameters

Parameter	Type
input	| { delivery: "followUp" | "steer"; requestId: string; type: "prompt"; text: string; images?: readonly object[]; } | { type: "compact"; requestId: string; instructions?: string; }

Returns

Promise<Readonly<{ status: "accepted"; commandId: string; sessionId?: string; }>>

Call Signature

Signature

(input): Promise<CancelResult>;

Cancel one accepted command, or report that it is too late.

Parameters

Parameter	Type
input	{ commandId: string; onlyIfPending?: boolean; type: "cancel"; }
input.commandId	string
input.onlyIfPending?	boolean
input.type	"cancel"

Returns

Promise<CancelResult>

Call Signature

Signature

(input): Promise<undefined>;

Abort the active run, select a lineage leaf, record an operator line, or set the title.

Parameters

Parameter	Type
input	| { type: "abort"; } | { type: "branch"; entryId: string; } | { type: "operator"; requestId: string; author: "operator" | "party"; text: string; } | { type: "title"; title: string | null; }

Returns

Promise<undefined>

Call Signature

Signature

(input): Promise<Readonly<{
  sessionId: string;
}>>;

Fork one complete entry lineage into a new Session.

Parameters

Parameter	Type
input	{ type: "fork"; entryId: string; }
input.type	"fork"
input.entryId	string

Returns

Promise<Readonly<{ sessionId: string; }>>

Call Signature

Signature

(input): Promise<
  | CancelResult
  | Readonly<{
  sessionId: string;
}>
| undefined>;

Execute an already-decoded command union.

Parameters

Parameter

Type

input

| { delivery: "followUp" | "steer"; requestId: string; type: "prompt"; text: string; images?: readonly object[]; } | { type: "abort"; } | { commandId: string; onlyIfPending?: boolean; type: "cancel"; } | { type: "branch"; entryId: string; } | { type: "fork"; entryId: string; } | { type: "operator"; requestId: string; author: "operator" | "party"; text: string; } | { type: "compact"; requestId: string; instructions?: string; } | { type: "title"; title: string | null; }

Returns

Promise< | CancelResult | Readonly<{ sessionId: string; }> | undefined>

---

SendOptionsTtype alias

Signature

type SendOptions = Readonly<{
  images?: PromptCommand["images"];
  delivery?: PromptDelivery;
  requestId?: string;
}>;

Optional controls for the Promise-friendly text sender.

---

ModelMessageTtype alias

Signature

type ModelMessage =
  | Exclude<
      Message,
      {
        role: "toolResult";
      }
    >
  | Omit<
      Extract<
        Message,
        {
          role: "toolResult";
        }
      >,
      "details"
    >;

Model-facing Pi content. Application tool display payloads belong to the surrounding entry’s data, never to a message sent back to a provider.

---

SessionMessageTtype alias

Signature

type SessionMessage = Readonly<{
  requestId?: string;
  meta?: Json;
  data?: Json;
  origin?: Readonly<{
    extensionId: string;
    correlation: string | null;
  }>;
  id: string;
  sequence: number;
  commandId: string | null;
  value: ModelMessage;
}>;

One completed model message and its separate application payload.

---

ShiitakeEventSourceConstructorTtype alias

Signature

type ShiitakeEventSourceConstructor = (
  url,
) => Pick<EventTarget, "addEventListener"> &
  Pick<EventSource, "close"> &
  object;

Minimal constructor seam for runtimes without a global EventSource.

Parameters

Parameter	Type
url	string

Returns

Pick<EventTarget, "addEventListener"> & Pick<EventSource, "close"> & object

---

SessionTerminalTtype alias

Signature

type SessionTerminal = Readonly<{
  commandId: string;
  outcome: "completed" | "cancelled" | "failed" | "interrupted";
  sequence: number;
  diagnostic: string | null;
  meta?: Json;
}>;

Durable outcome for one accepted work item on the selected Session lineage.

---

AgentRunningWorkTtype alias

Signature

type AgentRunningWork =
  | Readonly<{
      kind: "session";
      sessionId: string;
      commandId: string;
    }>
  | Readonly<{
      kind: "host";
      lane: string;
      jobId: string;
    }>;

Work occupying the executor partition that this queued command requires, without message or provider data.

---

SessionActivityTtype alias

Signature

type SessionActivity = Readonly<{
  queue:
    | Readonly<{
        state: "idle";
      }>
    | Readonly<{
        state: "queued";
        commandId: string;
        runningWork: AgentRunningWork | null;
      }>
    | Readonly<{
        state: "running";
        commandId: string;
      }>;
  cancellationRequested: boolean;
  retry: Readonly<{
    attempt: number;
    maxAttempts: number;
    delayMs: number;
    errorMessage: string;
    scheduledAt: number;
  }> | null;
  activeTool: string | null;
  lastModelChoiceSequence: number | null;
  compaction: Readonly<{
    trigger: SessionCompactionTrigger;
  }> | null;
}>;

Raw facts about what a Session is doing now. Shiitake publishes facts only; a client decides what they mean (see Parakeet’s sessionViewState).

---

SessionExtensionSlotsTtype alias

Signature

type SessionExtensionSlots = Readonly<Record<string, ExtensionSlotV0>>;

Encoded extension slots keyed by extension identity; absent means unavailable.

---

SessionExtensionControlsTtype alias

Signature

type SessionExtensionControls = Readonly<{
  call: (command, input) => Promise<Json>;
}>;

Generic Session-scope extension commands.

---

AgentExtensionControlsTtype alias

Signature

type AgentExtensionControls = Readonly<{
  list: () => Promise<readonly ExtensionStatusV0[]>;
  resume: (extensionId) => Promise<ExtensionStatusV0>;
  call: (extensionId, command, input) => Promise<Json>;
}>;

Generic Agent-scope extension controls.

---

SessionToolOutputTtype alias

Signature

type SessionToolOutput = Readonly<{
  toolCallId: string;
  revision: number;
  tail: string;
  droppedBytes: number;
  totalBytes: number;
}>;

Process-local running tool tail; never a durable Session fact.

---

SessionProgressTtype alias

Signature

type SessionProgress = Readonly<{
  messageId: string;
  revision: number;
  text: string;
  thinking: string;
  textTruncated: boolean;
  thinkingTruncated: boolean;
}>;

Process-local assistant progress; never a durable Session fact.

---

SessionPendingPromptTtype alias

Signature

type SessionPendingPrompt = Readonly<{
  requestId: string;
  meta?: SessionMessage["meta"];
  origin?: SessionMessage["origin"];
  commandId: string;
  text: string;
  images?: PromptCommand["images"];
  delivery: PromptDelivery;
}>;

Accepted prompt waiting to enter the conversation, not a scheduling command.

---

SessionPendingPromptsTtype alias

Signature

type SessionPendingPrompts = Readonly<{
  total: number;
  prompts: readonly SessionPendingPrompt[];
  hasMore: boolean;
}>;

Bounded current admission view, in acceptance order rather than execution order.

---

SessionCompactionMarkerTtype alias

Signature

type SessionCompactionMarker = Readonly<{
  id: string;
  sequence: number;
  at: number;
  tokensBefore: number;
  tokensAfter: number | null;
  trigger: SessionCompactionTrigger | null;
}>;

Minimal full-history compaction boundary marker. sequence is the Woodstock order of the row this marker precedes (ties sort the marker first); at is when the compaction ran. The agent’s model context is unaffected by this marker; it exists only for the client timeline.

---

SessionCompactionTriggerTtype alias

Signature

type SessionCompactionTrigger = "manual" | "threshold" | "overflow";

What started a compaction: the user, the context threshold, or an overflow.

---

SessionCompactionNoticeTtype alias

Signature

type SessionCompactionNotice = Readonly<{
  id: string;
  sequence: number;
  at: number;
  trigger: SessionCompactionTrigger;
  result: "nothing_to_compact" | "failed" | "stale" | "insufficient";
  diagnostic: string | null;
}>;

A compaction that changed nothing: a manual request with nothing to summarize yet, a compaction that failed, or a finished background summary dropped unplaced: stale because the context had moved past its head, or insufficient because placing it would have left the context over the limit. Automatic failures are never silent; each one is a notice at its own place in the timeline.

---

SessionContextTtype alias

Signature

type SessionContext = Readonly<{
  tokens: number;
  window: number | null;
}>;

The Session’s context use as compaction measures it, against the window of the model a run would select now; the window is null when that model reports none.

---

SessionSnapshotTtype alias

Signature

type SessionSnapshot = Readonly<{
  sessionId: string;
  cursor: string | null;
  hasMore: boolean;
  oldestCursor?: string | null;
  messages: readonly SessionMessage[];
  terminals: readonly SessionTerminal[];
  compactions?: readonly SessionCompactionMarker[];
  compactionNotices?: readonly SessionCompactionNotice[];
  sandboxFailures?: readonly SandboxFailureEvent[];
  pending: SessionPendingPrompts;
  activity: SessionActivity;
  progress: SessionProgress | null;
  toolOutput: readonly SessionToolOutput[];
  extensions: SessionExtensionSlots;
  attention: readonly SessionAttention[];
  context?: SessionContext;
}>;

Bounded Session baseline at one opaque owner cursor.

---

SessionFrameTtype alias

Signature

type SessionFrame =
  | Readonly<{
      kind: "activity";
      activity: SessionActivity;
    }>
  | Readonly<{
      kind: "tool_output";
      toolOutput: readonly SessionToolOutput[];
      activity: SessionActivity;
    }>
  | Readonly<{
      kind: "update";
      delivery: "replay" | "live";
      cursor: string | null;
      pending: SessionPendingPrompts;
      messages: readonly SessionMessage[];
      terminals: readonly SessionTerminal[];
      compactions?: readonly SessionCompactionMarker[];
      compactionNotices?: readonly SessionCompactionNotice[];
      sandboxFailures?: readonly SandboxFailureEvent[];
      activity: SessionActivity;
      extensions: SessionExtensionSlots;
      attention: readonly SessionAttention[];
      context?: SessionContext;
    }>
  | Readonly<{
      kind: "progress";
      progress: SessionProgress;
      activity: SessionActivity;
    }>
  | Readonly<{
      kind: "reset";
      reason: "history_unavailable";
      cursor: string | null;
      baseline: SessionSnapshot;
    }>;

One bounded replay or live frame.

---

SubscribeOptionsTtype alias

Signature

type SubscribeOptions = Readonly<{
  includeSandboxFailures?: boolean;
  after?: string;
}>;

Strict-after replay request.

---

ReadOptionsTtype alias

Signature

type ReadOptions = Readonly<{
  includeSandboxFailures?: boolean;
  limit?: number;
  before?: string;
}>;

Bounded baseline request.

---

WatchOptionsTtype alias

Signature

type WatchOptions = ReadOptions;

Race-safe observation request.

---

SessionWatchTtype alias

Signature

type SessionWatch = Readonly<{
  snapshot: SessionSnapshot;
  changes: AsyncIterable<SessionFrame>;
  close: () => Promise<void>;
}>;

Race-safe baseline plus live changes resource.

---

ShiitakeSessionTtype alias

Signature

type ShiitakeSession = Readonly<{
  address: string;
  command: SessionCommandHandler;
  withdraw: (requestId) => Promise<WithdrawResult>;
  abort: () => Promise<void>;
  send: (text, options?) => Promise<Accepted>;
  cancel: (input) => Promise<CancelResult>;
  latestPending: () => Promise<SessionPendingPrompt | null>;
  extension: (extensionId) => SessionExtensionControls;
  modelPreference: Readonly<{
    read: () => Promise<ModelPreference | null>;
    set: (preference) => Promise<void>;
  }>;
  read: (input?) => Promise<SessionSnapshot>;
  readSettlement: (
    commandId,
    options?,
  ) => Promise<CommandSettlement | undefined>;
  subscribe: (input) => AsyncIterable<SessionFrame>;
  watch: (input?) => Promise<SessionWatch>;
}>;

Addressable Session interface. Addressing itself performs no I/O.

---

SessionInboxStateTtype alias

Signature

type SessionInboxState = "needs_you" | "running" | "errored" | "done";

Owner-decided inbox state, from Watchdog’s queue head and latest outcome. running covers queued, thinking, streaming, retrying and cancelling; errored covers failed, interrupted and outcome_unknown; done covers completed, cancelled and never run. Any open extension attention produces needs_you, taking priority over live and settled work.

---

SessionSummaryTtype alias

Signature

type SessionSummary = Readonly<{
  createdAt: number;
  lastActivityAt: number;
  settledAt?: number;
  title: string;
  state: SessionInboxState;
}>;

Read-only saved conversation projection; opening does not update recency.

---

SessionSummaryRowTtype alias

Signature

type SessionSummaryRow =
  | (SessionSummary &
      Readonly<{
        sessionId: string;
      }>)
  | Readonly<{
      sessionId: string;
      state: "unavailable";
    }>;

One listed conversation, or a saved Session its owner could not read.

---

SessionSummaryPageTtype alias

Signature

type SessionSummaryPage = Readonly<{
  sessions: readonly SessionSummaryRow[];
  next: string | undefined;
}>;

One owner-bounded page: needs_you, then running, then settled rows, each newest activity first. next is an opaque owner cursor.

---

ShiitakeAgentTtype alias

Signature

type ShiitakeAgent = Readonly<{
  createSession: (requestId) => Promise<string>;
  deleteSession: (sessionId) => Promise<boolean>;
  listSessions: (after?) => Promise<SessionSummaryPage>;
  extensions: AgentExtensionControls;
  session: (sessionId) => ShiitakeSession;
  close: () => Promise<void>;
}>;

Constructed durable harness.

---

ExtensionViewV0Ttype alias

Signature

type ExtensionViewV0<P> =
  | Readonly<{
      status: "unavailable";
    }>
  | Readonly<{
      status: "stopped";
      reason: string;
    }>
  | Readonly<{
      status: "running";
      value: P | null;
    }>;

What one client sees of an extension in a Session observation.

Type Parameters

Type Parameter
P

---

ScopedCommandsV0Ttype alias

Signature

type ScopedCommandsV0<C, S> = {
  [K in keyof C & string]: C[K]["scope"] extends S ? K : never;
}[keyof C & string];

Command names of one scope, typed by the shared contract.

Type Parameters

Type Parameter
C extends CommandsV0
S extends "session" | "agent"

---

BoundCallV0Ttype alias

Signature

type BoundCallV0<C, S> = <K>(name, input) => Promise<C[K]["output"]["Type"]>;

Typed call surface of one contract’s commands in one scope.

Type Parameters

Type Parameter
C extends CommandsV0
S extends "session" | "agent"

Type Parameters

Type Parameter
K extends ScopedCommandsV0<C, S>

Parameters

Parameter	Type
name	K
input	C[K]["input"]["Type"]

Returns

Promise<C[K]["output"]["Type"]>

---

BoundSessionExtensionV0Ttype alias

Signature

type BoundSessionExtensionV0<C, P> = Readonly<{
  view: (observation) => ExtensionViewV0<P>;
  call: BoundCallV0<C, "session">;
}>;

One Session bound to one extension contract.

Type Parameters

Type Parameter
C extends CommandsV0
P

---

BoundAgentExtensionV0Ttype alias

Signature

type BoundAgentExtensionV0<C> = Readonly<{
  call: BoundCallV0<C, "agent">;
}>;

One Agent bound to one extension contract.

Type Parameters

Type Parameter
C extends CommandsV0

---

ShiitakeClientOptionsTtype alias

Signature

type ShiitakeClientOptions = Readonly<{
  baseUrl: string;
  fetch?: typeof globalThis.fetch;
  eventSource?: ShiitakeEventSourceConstructor;
}>;

Network location of one remotely hosted Shiitake agent.

---

SessionAttentionTtype alias

Signature

type SessionAttention = typeof SessionAttentionSchema.Type;

One open attention item in a Session observation.

AcceptedSchemaconstconstant

Signature

const AcceptedSchema: Schema.Codec<Accepted>;

Decode a durable command acceptance value at an RPC boundary.

---

HeldSchemaconstconstant

Signature

const HeldSchema: Schema.Codec<Held>;

Parse the relay’s custody acknowledgment without implying Agent acceptance.

---

DelegationReceiptSchemaconstconstant

Signature

const DelegationReceiptSchema: Schema.Codec<DelegationReceipt>;

A delegated send is accepted by its owner or held in durable mail custody.

participantSnapshot()fnfunction

Signature

function participantSnapshot(snapshot, owner): SessionSnapshot;

Filter participant delivery only; the holder’s stored Session is unchanged.

Parameters

Parameter	Type
snapshot	SessionSnapshot
owner	ParticipantPolicy

Returns

SessionSnapshot

---

visitorPendingPrompt()fnfunction

Signature

function visitorPendingPrompt(prompt, visitorId): VisitorPendingPrompt;

Project one owner-selected prompt without exposing host identity or correlation metadata.

Parameters

Parameter	Type
prompt	SessionPendingPrompt
visitorId	string

Returns

VisitorPendingPrompt

---

visitorSnapshot()fnfunction

Signature

function visitorSnapshot(snapshot, visitorId): SessionSnapshot;

Visitor-scoped Session facts use the visitor’s public address, never the internal Session ID.

Parameters

Parameter	Type
snapshot	SessionSnapshot
visitorId	string

Returns

SessionSnapshot

---

visitorView()fnfunction

Signature

function visitorView(snapshot, visitorId): VisitorView;

Project only this visitor’s host-attributed prompts, their replies, and explicit operator replies.

Parameters

Parameter	Type
snapshot	| Readonly<{ sessionId: string; cursor: string | null; hasMore: boolean; oldestCursor?: string | null; messages: readonly Readonly<{ requestId?: string; meta?: Json; data?: Json; origin?: Readonly<{ extensionId: string; correlation: string | null; }>; id: string; sequence: number; commandId: string | null; value: ModelMessage; }>[]; terminals: readonly Readonly<{ commandId: string; outcome: "completed" | "failed" | "cancelled" | "interrupted"; sequence: number; diagnostic: string | null; meta?: Json; }>[]; compactions?: readonly Readonly<{ id: string; sequence: number; at: number; tokensBefore: number; tokensAfter: number | null; trigger: SessionCompactionTrigger | null; }>[]; compactionNotices?: readonly Readonly<{ id: string; sequence: number; at: number; trigger: SessionCompactionTrigger; result: "failed" | "nothing_to_compact" | "stale" | "insufficient"; diagnostic: string | null; }>[]; sandboxFailures?: readonly object[]; pending: SessionPendingPrompts; activity: SessionActivity; progress: | Readonly<{ messageId: string; revision: number; text: string; thinking: string; textTruncated: boolean; thinkingTruncated: boolean; }> | null; toolOutput: readonly Readonly<{ toolCallId: string; revision: number; tail: string; droppedBytes: number; totalBytes: number; }>[]; extensions: SessionExtensionSlots; attention: readonly object[]; context?: Readonly<{ tokens: number; window: number | null; }>; }> | null
visitorId	string

Returns

VisitorView

---

parseDelegationReceipt()fnfunction

Signature

function parseDelegationReceipt(value): DelegationReceipt;

Decode one delegated send’s acceptance or durable-custody result.

Parameters

Parameter	Type
value	string

Returns

DelegationReceipt

---

parseWithdrawResult()fnfunction

Signature

function parseWithdrawResult(value): WithdrawResult;

Decode the owner’s atomic request resolution.

Parameters

Parameter	Type
value	string

Returns

WithdrawResult

---

parseAccepted()fnfunction

Signature

function parseAccepted(value): Accepted;

Parse one serialized command acceptance using Shiitake’s public grammar.

Parameters

Parameter	Type
value	string

Returns

Accepted

---

parseCancelResult()fnfunction

Signature

function parseCancelResult(value): CancelResult;

Parse one serialized cancel outcome: accepted, or too late.

Parameters

Parameter	Type
value	string

Returns

CancelResult

---

parseLatestPendingPrompt()fnfunction

Signature

function parseLatestPendingPrompt(value): Readonly<{
  requestId: string;
  meta?: Json;
  origin?: Readonly<{
    extensionId: string;
    correlation: string | null;
  }>;
  commandId: string;
  text: string;
  images?: readonly object[];
  delivery: PromptDelivery;
}> | null;

Decode the host-authorized newest pending lookup, including an empty result.

Parameters

Parameter	Type
value	string

Returns

| Readonly<{ requestId: string; meta?: Json; origin?: Readonly<{ extensionId: string; correlation: string | null; }>; commandId: string; text: string; images?: readonly object[]; delivery: PromptDelivery; }> | null

---

parseShiitakeError()fnfunction

Signature

function parseShiitakeError(value): ShiitakeError;

Parse one serialized canonical Shiitake failure.

Parameters

Parameter	Type
value	string

Returns

ShiitakeError

---

parseSessionSummaryPage()fnfunction

Signature

function parseSessionSummaryPage(value): SessionSummaryPage;

Decode the existing bounded saved-conversation projection.

Parameters

Parameter	Type
value	string

Returns

SessionSummaryPage

---

bindSessionExtension()fnfunction

Signature

function bindSessionExtension<C, P, PI>(
  session,
  contract,
): BoundSessionExtensionV0<C, P>;

Bind one Session to one extension contract; the contract’s schemas decode.

Type Parameters

Type Parameter
C extends Readonly<Record<string, Readonly<{ scope: "session" | "agent"; input: Codec<unknown>; output: Codec<unknown>; }>>>
P
PI

Parameters

Parameter	Type
session	Pick<ShiitakeSession, "extension">
contract	ExtensionContractV0<C, P, PI>

Returns

BoundSessionExtensionV0<C, P>

---

bindAgentExtension()fnfunction

Signature

function bindAgentExtension<C, P, PI>(
  agent,
  contract,
): BoundAgentExtensionV0<C>;

Bind one Agent to one extension contract’s Agent-scope commands.

Type Parameters

Type Parameter
C extends Readonly<Record<string, Readonly<{ scope: "session" | "agent"; input: Codec<unknown>; output: Codec<unknown>; }>>>
P
PI

Parameters

Parameter	Type
agent	Pick<ShiitakeAgent, "extensions">
contract	ExtensionContractV0<C, P, PI>

Returns

BoundAgentExtensionV0<C>

---

createShiitakeClient()fnfunction

Signature

function createShiitakeClient(options): ShiitakeAgent;

Connect to a remotely hosted Shiitake agent.

Parameters

Parameter	Type
options	ShiitakeClientOptions

Returns

ShiitakeAgent

References

CommandSettlement

Re-exports CommandSettlement

---

parseForkedSession

Re-exports parseForkedSession

---

parseSessionFrame

Re-exports parseSessionFrame

---

parseSessionSnapshot

Re-exports parseSessionSnapshot

---

AbortCommand

Re-exports AbortCommand

---

BranchCommand

Re-exports BranchCommand

---

CompactCommand

Re-exports CompactCommand

---

CancelCommand

Re-exports CancelCommand

---

ForkCommand

Re-exports ForkCommand

---

OperatorCommand

Re-exports OperatorCommand

---

PromptCommand

Re-exports PromptCommand

---

PromptDelivery

Re-exports PromptDelivery

---

SessionCommand

Re-exports SessionCommand

---

TitleCommand

Re-exports TitleCommand

---

ModelPreference

Re-exports ModelPreference