@yanlinglabs/winter-agent-sdk 0.0.1 → 0.0.3

package/dist/protocol/messaging.d.ts

@@ -0,0 +1,111 @@
+import type { DeliveryOutcome, GlobalAgentMessage, ListedRuntimeObject, NotificationRecord, PermissionClassLabel, RuntimeAddress } from "../messaging/index.js";
+/** Every subtype, in one place, so neither side spells a literal the other does not. */
+export declare const MESSAGING_CONTROL_SUBTYPES: {
+    readonly listReachable: "messaging.list_reachable";
+    readonly deliver: "messaging.deliver";
+    readonly steerChild: "messaging.steer_child";
+    readonly resumeChild: "messaging.resume_child";
+    readonly subscribeIdle: "messaging.subscribe_idle";
+    readonly senderClass: "messaging.sender_class";
+    readonly readNotifications: "messaging.read_notifications";
+    readonly idleNotice: "messaging.idle_notice";
+};
+export type MessagingControlSubtype = (typeof MESSAGING_CONTROL_SUBTYPES)[keyof typeof MESSAGING_CONTROL_SUBTYPES];
+/**
+ * The subtypes the RUNTIME serves (host -> runtime). The engine dispatches on exactly this set.
+ *
+ * `idleNotice` is deliberately absent: it travels runtime -> host, is answered by the WRAPPER, and a
+ * runtime that dispatched it would be answering its own request.
+ */
+export declare const MESSAGING_HOST_REQUEST_SUBTYPES: readonly MessagingControlSubtype[];
+/** The subtypes the WRAPPER serves (runtime -> host). */
+export declare const MESSAGING_RUNTIME_REQUEST_SUBTYPES: readonly MessagingControlSubtype[];
+/** Every subtype, both directions. */
+export declare const MESSAGING_CONTROL_SUBTYPE_LIST: readonly MessagingControlSubtype[];
+/** `messaging.list_reachable` and `messaging.sender_class` are payload-free (like the pinned `list_models`). */
+export interface MessagingDeliverRequest {
+    message: GlobalAgentMessage;
+}
+export interface MessagingChildRequest {
+    /** A canonical address, or a bare child id read within the receiving session. */
+    id: string;
+    message: GlobalAgentMessage;
+}
+export interface MessagingSubscribeIdleRequest {
+    /** A canonical address, or a bare child id read within the receiving session. */
+    id: string;
+    /**
+     * The HOST's own message id. The facet never allocates one: allocation is the router's
+     * (WS-10 §12 keys it to the sender session plus tool-call id), and a second allocator on the far
+     * side of a pipe would break the retry idempotency that key exists for.
+     */
+    messageId: string;
+    /**
+     * Whose notification queue an eventual idle notice belongs to. WS-10 §15's `subscribeIdle(addr,
+     * {messageId})` carries no subscriber at all, and the in-process reference answers that gap with a
+     * router-side directory keyed by messageId -- which a REMOTE caller cannot write into. So the
+     * caller names it here; absent means the receiving session itself.
+     */
+    subscriberSessionId?: string;
+}
+export interface MessagingSenderClassResponse {
+    senderClass: PermissionClassLabel;
+}
+/**
+ * `messaging.read_notifications` — the CATCH-UP half of `notify_when_idle` (WS-15 §6.4).
+ *
+ * A bounded page: `max` caps how many records come back and `remaining` says how many are still
+ * queued, so a host recovering after a restart drains in pages rather than in one unbounded frame
+ * whose size nothing governs.
+ */
+export interface MessagingReadNotificationsRequest {
+    /** Whose queue to drain. Absent = the receiving session's own. */
+    subscriberSessionId?: string;
+    /** Page size. Absent = everything queued for that key. */
+    max?: number;
+}
+export interface MessagingNotificationsPage {
+    notifications: NotificationRecord[];
+    remaining: number;
+}
+/**
+ * `messaging.idle_notice` — the LIVE half, and the ONE subtype that travels runtime -> host.
+ *
+ * The SAME notice the drain returns, carrying the same `notification_id`, because the queue is the
+ * durable record and this is a signal derived from it: a host that missed the frame (crashed, not yet
+ * connected) still finds the entry via `read_notifications`, and a host that got both dedupes on the
+ * id. The runtime does NOT wait for a handler — an unanswered or refused notice is a dropped LIVE
+ * signal, never a dropped notice.
+ */
+export interface MessagingIdleNoticePayload {
+    /** The queue key the notice was filed under -- the SUBSCRIBER, not the target that went idle. */
+    subscriberSessionId: string;
+    notice: NotificationRecord;
+}
+export declare function isRuntimeAddress(v: unknown): v is RuntimeAddress;
+export declare function isGlobalAgentMessage(v: unknown): v is GlobalAgentMessage;
+export declare function isDeliveryOutcome(v: unknown): v is DeliveryOutcome;
+export declare function isListedRuntimeObjectArray(v: unknown): v is ListedRuntimeObject[];
+export declare function isPermissionClassLabel(v: unknown): v is PermissionClassLabel;
+export declare function isMessagingDeliverRequest(v: unknown): v is MessagingDeliverRequest;
+export declare function isMessagingChildRequest(v: unknown): v is MessagingChildRequest;
+export declare function isNotificationRecord(v: unknown): v is NotificationRecord;
+export declare function isMessagingNotificationsPage(v: unknown): v is MessagingNotificationsPage;
+export declare function isMessagingIdleNoticePayload(v: unknown): v is MessagingIdleNoticePayload;
+export declare function isMessagingReadNotificationsRequest(v: unknown): v is MessagingReadNotificationsRequest;
+export declare function isMessagingSubscribeIdleRequest(v: unknown): v is MessagingSubscribeIdleRequest;
+/**
+ * Turns a facet `id` into a `RuntimeAddress` within the receiving session.
+ *
+ * TWO forms, and no third:
+ *   1. a CANONICAL address (`session:<id>` / `agent:<parent>:<child>`) -- parsed by WS-10 §11's own
+ *      inverse, so a router that already holds a directory entry addresses it exactly;
+ *   2. a bare stable CHILD id -- read within the receiving session, which is the only scope in which
+ *      a child id means anything (WS-10 §10.3: a child is reachable only through its owning parent).
+ *
+ * It deliberately does NOT fall back to display-name lookup. That is resolution rule 3, and rules
+ * 3/4/5 are inseparable -- a name that resolves here would be a name that never got its ambiguity
+ * and staleness checks, because those need the whole directory the router holds and this side does
+ * not.
+ */
+export declare function resolveFacetTarget(sessionId: string, id: string, parse: (s: string) => RuntimeAddress | undefined, buildChild: (parent: string, childId: string) => RuntimeAddress): RuntimeAddress;

package/dist/query.d.ts

@@ -2,6 +2,8 @@ import type { SdkMessage as RuntimeSdkMessage } from "./protocol/frames.js";
 import type { AccountInfo, ModelInfo, ModelFamilyListing, RewindFilesResult } from "./protocol/config.js";
 import { type Options } from "./options.js";
 import type { PermissionMode, PermissionResult } from "./permissions/types.js";
+import { type DeliveryOutcome, type GlobalAgentMessage, type ListedRuntimeObject, type PermissionClassLabel } from "./messaging/index.js";
+import { type MessagingNotificationsPage, type MessagingIdleNoticePayload } from "./protocol/messaging.js";
 export type SdkMessage = Extract<RuntimeSdkMessage, {
     type: "system";
 } | {
@@ -24,6 +26,88 @@ export interface QueryInternal {
     registerControlRequestHandler(subtype: string, handler: ControlRequestHandler): void;
     respondPermission(requestId: string, result: PermissionResult): void;
 }
+/**
+ * R-7b-4: the per-session MESSAGING FACET -- `RuntimeMessagingAdapter` (WS-10 §15) reached over this
+ * session's own control channel.
+ *
+ * WHO CALLS IT: `@yanlinglabs/winter-runtime-sdk`, from the HOST process. A spawned Winter session's
+ * children live inside that session's process, behind a pipe; without this facet the router owns a
+ * RuntimeDirectory that can address the session and nothing inside it, so WS-15 §6.2's "running
+ * Winter child" and "terminal Winter child" rows have no mechanism at all.
+ *
+ * WHAT IT IS NOT: the router. Every rule that needs the whole directory -- WS-10 §11's resolution
+ * order, ambiguity, staleness, §12's dedupe/retry ledger and loop guard, §13's hold/refuse policy --
+ * runs ABOVE this, in the host, once, for both runtimes. This is the six owner-specific operations
+ * the router delegates to whichever runtime actually holds the object.
+ *
+ * WINTER-ONLY, disclosed: the pinned official SDK has no messaging surface of any kind (its `Query`
+ * declares none), so there is no counterpart to mirror and nothing here is a divergence FROM one.
+ *
+ * FOUR THINGS A CONSUMER MUST KNOW, because none of them is visible in the signatures:
+ *
+ *  1. NO DELIVERY METHOD REJECTS. `deliver`, `steerChild`, `resumeChild` and `subscribeIdle` always
+ *     RESOLVE with a typed `DeliveryOutcome` -- a caller that must record an outcome for every
+ *     message (WS-10 §12's ledger) is never left with nothing to write down. A refusal the runtime
+ *     could name arrives as `refused`; an unregistered messaging runtime as non-retryable
+ *     `unavailable`; every other failure, including a transport fault, as `delivery_uncertain`,
+ *     because from the host's side that is genuinely indistinguishable from "it already happened".
+ *  2. THIS FACET SERVES ONE SESSION -- its own, and its own children. A target naming another session
+ *     is refused, even though the runtime could reach it in a shared process: cross-session delivery
+ *     belongs to the router, through its directory, which is the one party that holds every session's
+ *     entry and can pick the right adapter for it.
+ *  3. THE RECEIVER RE-RUNS INBOUND POLICY on the `senderPermissionClass` YOU stamped (WS-10 §13), so
+ *     a caller-side decision to deliver can still come back `held` or `refused`. The envelope's class
+ *     is an input to the receiver's matrix, never a verdict.
+ *  4. NOTIFICATIONS ARE NAMESPACED. `subscribeIdle` and `readNotifications` default to the FACET's own
+ *     queue key (`host:<sessionId>`), deliberately separate from the one the session's own model
+ *     drains with its `ReadNotifications` tool -- a drain REMOVES, so a shared key would have
+ *     whichever side read first silently eat the other's notices. Passing
+ *     `subscriberSessionId: <the session's own id>` opts into the model's bucket on purpose.
+ */
+export interface SessionMessagingFacet {
+    /** Every object this session can currently reach: its own children, plus the reachable live peers its adapter knows (WS-10 §10.2 -- never exited transcripts). */
+    listReachable(): Promise<ListedRuntimeObject[]>;
+    /** Deliver a fully-addressed envelope. The target is `msg.to`; the receiver's inbound policy (WS-10 §13) runs inside. */
+    deliver(msg: GlobalAgentMessage): Promise<DeliveryOutcome>;
+    /** Steer a RUNNING child (WS-10 §10.3). `id` is a canonical address or a bare child id within this session. */
+    steerChild(id: string, msg: GlobalAgentMessage): Promise<DeliveryOutcome>;
+    /** Resume a TERMINAL, addressable child (WS-10 §10.3). Never the reverse of `steerChild`. */
+    resumeChild(id: string, msg: GlobalAgentMessage): Promise<DeliveryOutcome>;
+    /**
+     * Subscribe to a target going idle (WS-10 §14). `opts.messageId` is the CALLER's -- the facet never
+     * allocates one, because allocation is keyed to the sender session plus tool-call id (§12) and a
+     * second allocator across the pipe would break the retry idempotency that key exists for.
+     * `subscriberSessionId` names whose notification queue the eventual notice belongs to; absent means
+     * the receiving session itself.
+     */
+    subscribeIdle(id: string, opts: {
+        messageId: string;
+        subscriberSessionId?: string;
+    }): Promise<DeliveryOutcome>;
+    /** This session's own sender permission class (WS-10 §13's matrix input), from its LIVE permission mode. */
+    senderClass(): Promise<PermissionClassLabel>;
+    /**
+     * Drain a bounded page of queued notifications -- the CATCH-UP half of `notify_when_idle`
+     * (WS-15 §6.4's restart recovery). `remaining` says how many are still queued, so a host that
+     * reconnects drains in pages rather than in one frame whose size nothing governs.
+     *
+     * A drain is the ACKNOWLEDGEMENT: a record it returns is removed. `onIdleNotice` below carries the
+     * same notice live, with the same `notification_id`, so a host that got both dedupes on the id.
+     */
+    readNotifications(opts?: {
+        subscriberSessionId?: string;
+        max?: number;
+    }): Promise<MessagingNotificationsPage>;
+    /**
+     * Subscribe to LIVE idle notices for this session. Returns an unsubscribe.
+     *
+     * A handler-plus-unsubscribe rather than an async iterator, because a notice is a fire-and-forget
+     * SIGNAL, not a stream a consumer may fall behind on: an iterator would need a buffer, and the
+     * durable buffer already exists on the runtime side (`readNotifications`). A handler that is never
+     * registered, or that throws, loses no notice -- the entry stays queued for the drain.
+     */
+    onIdleNotice(handler: (payload: MessagingIdleNoticePayload) => void): () => void;
+}
 export interface Query extends AsyncGenerator<SdkMessage> {
     interrupt(): Promise<void>;
     setModel(model?: string): Promise<void>;
@@ -73,6 +157,13 @@ export interface Query extends AsyncGenerator<SdkMessage> {
         dryRun?: boolean;
     }): Promise<RewindFilesResult>;
     setPermissionMode(mode: PermissionMode): Promise<void>;
+    /**
+     * R-7b-4: this session's messaging facet, backed by the six `messaging.*` control subtypes.
+     *
+     * ADDITIVE and Winter-only: the pinned `Query` contract loses nothing, and the official SDK has no
+     * member this could collide with. See `SessionMessagingFacet` for what it is and is not.
+     */
+    messaging: SessionMessagingFacet;
     __internal?: QueryInternal;
 }
 export declare function query(args: {

package/dist/tools/accept.d.ts

@@ -0,0 +1,39 @@
+/** The native `SendMessage` arguments (WS-10 §10.1), after validation. */
+export interface NativeSendMessageArgs {
+    to: string;
+    message: string;
+    summary?: string;
+    notify_when_idle?: boolean;
+}
+/** The native `ListAgents` arguments (WS-10 §10.2). Both fields are reserved in the pinned build. */
+export interface NativeListAgentsArgs {
+    channel?: string;
+    q?: string;
+}
+export type NativeArgsResult<T> = {
+    ok: true;
+    args: T;
+} | {
+    ok: false;
+    reason: string;
+};
+/** Accepts the native `SendMessage` arguments EXACTLY — no more, no less. */
+export declare function acceptNativeSendMessageArgs(input: unknown): NativeArgsResult<NativeSendMessageArgs>;
+/** The same treatment for `ListAgents`: two reserved optional fields, both capped, nothing else. */
+export declare function acceptNativeListAgentsArgs(input: unknown): NativeArgsResult<NativeListAgentsArgs>;
+/**
+ * `ReadNotifications` takes the empty object, and only the empty object (ruling P-4).
+ *
+ * The Winter runtime's executor used to accept stray fields on the reasoning that an inert extra is
+ * not a reason to fail an otherwise-harmless call. That reasoning is right about HARM and wrong
+ * about SCHEMAS: a model that got away with `{ limit: 5 }` here has been told, by the runtime's own
+ * silence, that a `limit` exists.
+ */
+export declare function acceptNativeReadNotificationsArgs(input: unknown): NativeArgsResult<Record<string, never>>;
+/**
+ * WS-10 §10.1: "summary?: derived from first message line when absent; truncated when overlong."
+ *
+ * NEVER a validation error — a computed value, or absent when there is nothing to derive from (the
+ * pure-idle-subscription case, whose message is empty by construction).
+ */
+export declare function deriveSendMessageSummary(rawSummary: string | undefined, message: string): string | undefined;

package/dist/tools/advisor.d.ts

@@ -0,0 +1,106 @@
+import type { SessionKey, SessionStore } from "../store/session-store.js";
+import type { WinterToolHandler } from "./messaging-handlers.js";
+/**
+ * One raw entry of a session's transcript — deliberately narrower/speech-shaped (who said what) than
+ * any host's own provider message type, which additionally carries structured content blocks for
+ * wire purposes this assembler has no need of.
+ */
+export interface TranscriptEntry {
+    role: "user" | "assistant" | "tool";
+    text: string;
+}
+/**
+ * `getEntries` may be SYNCHRONOUS or async. The Winter runtime's real source is a live in-memory
+ * array captured by reference from the round loop (synchronous, and it must stay that way — a
+ * snapshot taken at wiring time would be empty forever); a host reading a durable transcript off
+ * disk needs the promise. The union is what lets one factory serve both.
+ */
+export interface TranscriptSource {
+    getEntries(): TranscriptEntry[] | Promise<TranscriptEntry[]>;
+}
+export interface AdvisorReviewerRequest {
+    messages: ReadonlyArray<{
+        role: "user" | "assistant" | "tool";
+        content: string;
+    }>;
+}
+export interface AdvisorReviewerTurn {
+    kind: string;
+    text?: string;
+}
+export interface AdvisorReviewer {
+    generate(input: AdvisorReviewerRequest): Promise<AdvisorReviewerTurn>;
+}
+/**
+ * Resolves BOTH the provider to call and the model id the result must report, TOGETHER: WS-06 §4's
+ * result shape pins `model: string` as required, but a provider interface has no `model` field to
+ * read back — whatever backs the reviewer capability must hand back the model id alongside the
+ * provider instance it resolved, in ONE seam, rather than two seams that could disagree.
+ */
+export interface ResolvedReviewer {
+    provider: AdvisorReviewer;
+    model: string;
+}
+/** `undefined` is the "no reviewer resolvable" case — WS-06 §4's ordinary tool error, never a throw. */
+export type ReviewerResolver = () => ResolvedReviewer | undefined;
+export interface AdvisorToolDeps {
+    transcriptSource: TranscriptSource;
+    resolveReviewer: ReviewerResolver;
+    /** Injectable so a host can pin the truncation boundary without a multi-KB fixture transcript. */
+    maxChars?: number;
+}
+export declare const ADVISOR_DEFAULT_MAX_CHARS = 20000;
+/**
+ * RULING R3-3: "the assembler enforces the enforceable floor now — provider-opaque state
+ * (encrypted_content, signatures, reasoning items) is NEVER included."
+ *
+ * `thinking` and `redacted_thinking` are in the list because a probe fed both to a scripted reviewer
+ * as literal transcript text and both reached the wire verbatim, payload included, while the
+ * original three were correctly stripped. WS-06 §4's constraint reads "provider-opaque state", not
+ * "these three keys", and `redacted_thinking.data` is opaque by name.
+ *
+ * THE COST IS REAL AND ACCEPTED: "thinking" is an ordinary English word, so a review line that
+ * merely USES it ("I was thinking about the schema") is dropped along with the ones that carry a
+ * key. That is this function's declared posture — drop the whole line, never partially redact, fail
+ * toward the reviewer seeing less — and the price is one line of context in an advisory channel
+ * against a class of leak the transcript has no other guard for.
+ */
+export declare const OPAQUE_MARKERS: readonly ["encrypted_content", "reasoning_item", "signature", "thinking", "redacted_thinking"];
+export declare function stripOpaqueMarkers(text: string): string;
+/**
+ * Keeps the transcript TAIL (recent turns are what advice needs) and reports `truncated: true` only
+ * when something was actually clipped. Opaque-marker stripping runs PER ENTRY before truncation is
+ * measured, so a kept entry is always a whole, already-cleaned entry — truncation never bisects one,
+ * and a 4-KB `signature:` line never evicts the real conversation that came before it.
+ */
+export declare function assembleReviewerMessages(entries: readonly TranscriptEntry[], maxChars?: number): {
+    messages: Array<{
+        role: "user" | "assistant" | "tool";
+        content: string;
+    }>;
+    truncated: boolean;
+};
+/**
+ * NO CACHE (WS-06 §4's closing line: "the advisor and the auto-mode classifier are separate routes
+ * and MUST NOT share a verdict cache"). Every call re-resolves the reviewer, re-assembles the
+ * transcript, and re-generates from scratch; nothing in this module is memoized, so there is nothing
+ * here that COULD be shared with a classifier's verdict cache even by accident.
+ */
+export declare function createAdvisorToolHandler(deps: AdvisorToolDeps): WinterToolHandler;
+/**
+ * A `TranscriptSource` over the DURABLE transcript of one session.
+ *
+ * For a host that does not hold the live turn array — the router package, or any consumer wiring the
+ * advisor outside an engine's own closure. The Winter runtime keeps its in-memory source (the live
+ * `messages` array, captured by reference), because a resumed session's file and its live turns are
+ * not the same conversation until the turn ends.
+ *
+ * Reads through the pinned `SessionStore` interface so a host may inject an in-memory one; the
+ * default is the filesystem store over the resolved Winter home. A missing transcript is NO ENTRIES,
+ * never a throw: the advisor's whole posture is that an unavailable reviewer context degrades to an
+ * ordinary tool error rather than blocking the turn.
+ */
+export declare function transcriptSourceForSessionKey(key: SessionKey, opts?: {
+    store?: SessionStore;
+    winterHome?: string;
+}): TranscriptSource;

package/dist/tools/definitions.d.ts

@@ -0,0 +1,31 @@
+import { type JsonSchemaObject } from "./schemas.js";
+export interface WinterToolDefinition {
+    /** The BARE tool name: `send_message`, `list_agents`, `read_notifications`, `advisor`. */
+    readonly toolName: string;
+    /** The official SDK's built-in name for the same tool — the alias key a host binds under. */
+    readonly builtinName?: string;
+    readonly description: string;
+    /** Tool-Search terms, for a host that defers this tool. Advertised nowhere when it does not. */
+    readonly searchHint?: string;
+    readonly inputSchema: JsonSchemaObject;
+    readonly outputSchema?: JsonSchemaObject;
+    readonly annotations?: {
+        readOnlyHint?: boolean;
+        destructiveHint?: boolean;
+        openWorldHint?: boolean;
+        idempotentHint?: boolean;
+        title?: string;
+    };
+    /**
+     * What the CALL does, not where the descriptor came from. `advisor` is `"mcp"` because it sends
+     * conversation content to a provider in the session's own trust domain (the same class of egress
+     * as the worker model's own requests), even though it registers as a bare built-in name.
+     */
+    readonly permissionClass: "messaging" | "mcp";
+}
+export declare const SEND_MESSAGE_DEFINITION: WinterToolDefinition;
+export declare const LIST_AGENTS_DEFINITION: WinterToolDefinition;
+export declare const READ_NOTIFICATIONS_DEFINITION: WinterToolDefinition;
+export declare const ADVISOR_DEFINITION: WinterToolDefinition;
+/** The four, in the order a host registers them. */
+export declare const WINTER_DEFAULT_TOOL_DEFINITIONS: readonly [typeof SEND_MESSAGE_DEFINITION, typeof LIST_AGENTS_DEFINITION, typeof READ_NOTIFICATIONS_DEFINITION, typeof ADVISOR_DEFINITION];

package/dist/tools/index.d.ts

@@ -0,0 +1,14 @@
+export { SEND_MESSAGE_TO_MAX, SEND_MESSAGE_SUMMARY_MAX, LIST_AGENTS_FIELD_MAX, NATIVE_SEND_MESSAGE_SCHEMA, NATIVE_LIST_AGENTS_SCHEMA, NATIVE_LIST_AGENTS_OUTPUT_SCHEMA, NATIVE_READ_NOTIFICATIONS_SCHEMA, NATIVE_READ_NOTIFICATIONS_OUTPUT_SCHEMA, NATIVE_ADVISOR_SCHEMA, NATIVE_ADVISOR_OUTPUT_SCHEMA, } from "./schemas.js";
+export type { JsonSchemaObject } from "./schemas.js";
+export { SEND_MESSAGE_DEFINITION, LIST_AGENTS_DEFINITION, READ_NOTIFICATIONS_DEFINITION, ADVISOR_DEFINITION, WINTER_DEFAULT_TOOL_DEFINITIONS } from "./definitions.js";
+export type { WinterToolDefinition } from "./definitions.js";
+export { acceptNativeSendMessageArgs, acceptNativeListAgentsArgs, acceptNativeReadNotificationsArgs, deriveSendMessageSummary } from "./accept.js";
+export type { NativeSendMessageArgs, NativeListAgentsArgs, NativeArgsResult } from "./accept.js";
+export { messagingToolPortFromRuntimeDeps, callerAddress } from "./port.js";
+export type { MessagingToolPort } from "./port.js";
+export { createMessagingToolHandlers, toolUseIdFromExtra, VENDOR_TOOL_USE_ID_META_KEY } from "./messaging-handlers.js";
+export type { WinterToolCaller, WinterToolResult, WinterToolHandler, MessagingToolHandlers } from "./messaging-handlers.js";
+export { ADVISOR_DEFAULT_MAX_CHARS, OPAQUE_MARKERS, stripOpaqueMarkers, assembleReviewerMessages, createAdvisorToolHandler, transcriptSourceForSessionKey } from "./advisor.js";
+export type { TranscriptEntry, TranscriptSource, AdvisorReviewerRequest, AdvisorReviewerTurn, AdvisorReviewer, ResolvedReviewer, ReviewerResolver, AdvisorToolDeps } from "./advisor.js";
+export type { RuntimeAddress, ListedRuntimeObject, SendMessageResult, NotificationRecord, MessagingRuntimeDeps } from "../messaging/index.js";
+export type { SessionKey, SessionStore } from "../store/session-store.js";