@fungi.computer/shiitake 0.0.0-stage → 0.1.0

package/dist/extensions.js

@@ -0,0 +1,263 @@
+export { AttentionItemSchema, } from "./session-attention.js";
+import * as Brand from "effect/Brand";
+import * as Context from "effect/Context";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Result from "effect/Result";
+import * as Schema from "effect/Schema";
+import { ExtensionId, extensionFingerprintSchema, extensionRevisionSchema, } from "./extension-contract.js";
+export { ExtensionId, extensionIdentifier, extensionVersion, } from "./extension-contract.js";
+import { extensionVersion } from "./extension-contract.js";
+import { registerExtensionCommands, } from "./internal/extension-command-registry.js";
+import { commandTools, } from "./internal/extension-command-tools.js";
+import { bindExtensionState, bindExtensionDocuments, } from "./internal/extension-context.js";
+import { definitionReader } from "./internal/extension-definitions.js";
+import { ExtensionHookError, invokeExtensionHook, invokeSyncHandler, invokeTransactionHook, } from "./internal/extension-hook.js";
+export { ExtensionHookError } from "./internal/extension-hook.js";
+import { JsonValueSchema } from "./internal/json-value.js";
+const parseJsonSource = Schema.decodeUnknownSync(Schema.fromJsonString(JsonValueSchema));
+/** Parse a serialized extension value into the finite JSON contract. */
+export function parseExtensionJson(source) {
+    return parseJsonSource(source);
+}
+/** Present only inside a core-run read (projection, run tools, hooks). */
+export class ExtensionRead extends Context.Service()("@fungi.computer/shiitake/ExtensionRead") {
+}
+/**
+ * Present only inside a core-run write transaction (hooks, commands,
+ * `transact`). Core runs these Effects synchronously inside the owner
+ * transaction; an asynchronous boundary is a defect that stops the extension.
+ */
+export class ExtensionTx extends Context.Service()("@fungi.computer/shiitake/ExtensionTx") {
+}
+/** Durable record failure: stored or supplied values broke their schema or bounds. */
+export class ExtensionStateError extends Data.TaggedError("ExtensionStateError") {
+}
+/** The door refused an extension admission. */
+export class AdmissionError extends Data.TaggedError("AdmissionError") {
+}
+/** Typed rejection of one extension command, returned to its caller. */
+export class ExtensionCommandError extends Data.TaggedError("ExtensionCommandError") {
+}
+/** Fail a hook with this (or die) to stop this extension with a visible reason. */
+export class ExtensionStop extends Data.TaggedError("ExtensionStop") {
+}
+/** Typed activation failure; the extension is stopped with this message. */
+export class ExtensionActivationError extends Data.TaggedError("ExtensionActivationError") {
+}
+/** Marks a `defineCollection` result, across copies of this package. */
+const collectionBrand = Symbol.for("@fungi.computer/shiitake/collection");
+const stateDeclarationKeys = new Set([
+    "version",
+    "collections",
+    "migrations",
+]);
+/** The full form names `collections` and nothing outside the declaration keys. */
+function isStateDeclaration(value) {
+    const keys = Object.keys(value);
+    return (keys.includes("collections") &&
+        keys.every((key) => stateDeclarationKeys.has(key)));
+}
+/** Configure typed metadata, then register callbacks against its actual values. */
+export class ExtensionBuilderV0 {
+    metadata;
+    constructor(metadata) {
+        this.metadata = metadata;
+    }
+    /** Begin with concrete empty metadata and no requested capability. */
+    static fromIdentity(identity) {
+        return new ExtensionBuilderV0({
+            ...identity,
+            config: {},
+            state: { version: 1, collections: {}, migrations: {} },
+            documents: {},
+            declaresState: false,
+            declaresDocuments: false,
+        });
+    }
+    /** Hash this explicit JSON configuration with the extension revision. */
+    config(value) {
+        return new ExtensionBuilderV0({ ...this.metadata, config: value });
+    }
+    /**
+     * Request state and bind handles to each collection's declared schema.
+     * Pass the collections alone (state version 1, no migrations) or the full
+     * versioned declaration.
+     */
+    state(value) {
+        const declared = isStateDeclaration(value) ? value : { collections: value };
+        if (isStateDeclaration(value)
+            ? !Object.values(value.collections).every((spec) => collectionBrand in spec)
+            : Object.keys(value).some((name) => stateDeclarationKeys.has(name)))
+            throw new Error("A collection named collections, version or migrations needs the full state declaration");
+        return new ExtensionBuilderV0({
+            ...this.metadata,
+            state: {
+                version: declared.version ?? 1,
+                collections: declared.collections,
+                migrations: declared.migrations ?? {},
+            },
+            declaresState: true,
+        });
+    }
+    /** Request bounded Session documents under the state grant. */
+    documents(value) {
+        return new ExtensionBuilderV0({
+            ...this.metadata,
+            documents: value,
+            declaresDocuments: true,
+        });
+    }
+    define(definition) {
+        return compileExtension(this.metadata, definition);
+    }
+}
+const decodeExtensionId = Schema.decodeUnknownSync(ExtensionId);
+const decodeExtensionVersion = Schema.decodeUnknownSync(extensionVersion);
+const isBareExtensionId = Schema.is(Schema.String);
+/**
+ * Begin with honest empty defaults; optional contributions are declared
+ * explicitly. The version defaults to `0.0.0` and any SemVer, including a
+ * pre-release, is valid. It is part of the extension's revision, which already
+ * covers schemas, config and requested capabilities; a different version marks
+ * a behaviour change those do not show, such as a fixed hook.
+ */
+export function defineExtension(identity) {
+    const declared = isBareExtensionId(identity) ? { id: identity } : identity;
+    return ExtensionBuilderV0.fromIdentity({
+        id: decodeExtensionId(declared.id),
+        version: decodeExtensionVersion(declared.version ?? "0.0.0"),
+    });
+}
+function compileExtension(metadata, definition) {
+    if (definition.projection?.catalog !== undefined &&
+        definition.catalog === undefined)
+        throw new Error("A projected catalog requires an advertised catalog");
+    const requests = [];
+    if (definition.attention === true)
+        requests.push("attention");
+    if (metadata.declaresState || metadata.declaresDocuments)
+        requests.push("state");
+    if (definition.hooks?.onSettled !== undefined)
+        requests.push("settled", "send");
+    if (definition.commands !== undefined)
+        requests.push("commands", "send");
+    if (definition.hooks?.onTimer !== undefined || definition.timers === true)
+        requests.push("timers", "send");
+    if (definition.projection !== undefined)
+        requests.push("projection");
+    if (definition.tools !== undefined)
+        requests.push("run_tools");
+    if (definition.files !== undefined)
+        requests.push("files");
+    if (definition.prompt !== undefined)
+        requests.push("prompt");
+    if (definition.compaction !== undefined)
+        requests.push("compaction_handoff");
+    const manifest = {
+        protocol: "shiitake.extension/v0",
+        id: metadata.id,
+        version: metadata.version,
+        requests: [...new Set(requests)],
+    };
+    const contract = {
+        id: metadata.id,
+        commands: definition.commands?.specs ?? {},
+        projection: definition.projection === undefined
+            ? null
+            : { schema: definition.projection.schema },
+    };
+    const { hooks, commands, projection, prompt, tools, files, compaction } = definition;
+    const onSettled = hooks?.onSettled;
+    const onTimer = hooks?.onTimer;
+    const engine = {
+        manifest,
+        contract,
+        config: metadata.config,
+        state: metadata.state,
+        activate: (port) => {
+            const context = Object.freeze({
+                ...port.context,
+                config: metadata.config,
+                state: bindExtensionState(metadata.state.collections, port),
+                documents: bindExtensionDocuments(metadata.documents, port),
+            });
+            return Effect.gen(function* () {
+                if (hooks?.start !== undefined)
+                    yield* invokeExtensionHook(() => hooks.start?.(context));
+                const registered = commands === undefined
+                    ? new Map()
+                    : registerExtensionCommands(commands.specs, commands.handlers(context));
+                const result = {
+                    commands: registered,
+                };
+                if (onSettled !== undefined)
+                    Object.assign(result, {
+                        onSettled: (page) => invokeTransactionHook(() => onSettled(context, page)),
+                    });
+                if (onTimer !== undefined)
+                    Object.assign(result, {
+                        onTimer: (timer) => invokeTransactionHook(() => onTimer(context, timer)),
+                    });
+                if (tools !== undefined)
+                    Object.assign(result, {
+                        moduleForRun: (run) => invokeExtensionHook(() => tools(context, run, commandTools(commands?.specs, () => registered, context.transact, run, context.grants.includes("commands")))).pipe(Effect.map((value) => Option.isOption(value) ? value : Option.fromNullishOr(value))),
+                    });
+                if (files !== undefined)
+                    Object.assign(result, {
+                        filesForRun: (run) => invokeExtensionHook(() => files(context, run)).pipe(Effect.map((value) => Option.isOption(value) ? value : Option.fromNullishOr(value))),
+                    });
+                if (prompt !== undefined)
+                    Object.assign(result, {
+                        prompt: (run) => prompt(context, run),
+                    });
+                if (projection !== undefined)
+                    Object.assign(result, {
+                        project: (sessionId) => {
+                            const value = invokeSyncHandler(() => projection.read(context, sessionId), undefined);
+                            return Option.isOption(value)
+                                ? value
+                                : Option.fromUndefinedOr(value);
+                        },
+                    });
+                const projectCatalog = projection?.catalog;
+                if (projection !== undefined && projectCatalog !== undefined)
+                    Object.assign(result, {
+                        projectCatalog: (value) => projectCatalog(Schema.decodeUnknownSync(projection.schema)(value)),
+                    });
+                if (compaction !== undefined) {
+                    const contribution = compaction(context);
+                    Object.assign(result, {
+                        compactionHandoff: {
+                            consume: (view) => invokeExtensionHook(() => contribution.consume(view)),
+                        },
+                    });
+                }
+                return result;
+            });
+        },
+    };
+    if (metadata.declaresDocuments)
+        Object.assign(engine, { documents: metadata.documents });
+    if (definition.catalog !== undefined)
+        Object.assign(engine, { catalog: definition.catalog });
+    const brand = Brand.nominal();
+    const rostered = Object.assign(brand({ manifest, [definitionReader]: () => engine }), { contract });
+    Object.defineProperty(rostered, definitionReader, { enumerable: false });
+    return Object.freeze(rostered);
+}
+/** Declare one collection with its key inferred from the row schema. */
+export function defineCollection(schema, keys) {
+    const spec = {
+        schema,
+        ...keys,
+        bind: (port, name) => ({
+            read: port.collection(name, spec),
+            update: port.updateCollection(name, spec),
+        }),
+        indexFromEncoded: (value) => Result.map(Schema.decodeUnknownResult(schema)(value), (decoded) => spec.index?.(decoded) ?? null),
+    };
+    Object.defineProperty(spec, collectionBrand, { value: true });
+    return Object.freeze(spec);
+}

package/dist/fleet.d.ts

@@ -0,0 +1,313 @@
+import { type VerifiedAgentReply } from "./internal/woodstock/index.js";
+import type { CommandSettlement } from "./internal/contracts.js";
+import { type Pending } from "@fungi.computer/agar";
+import type { BirdDogMail } from "@fungi.computer/bird-dog";
+import * as Schema from "effect/Schema";
+import { type Accepted, type ShiitakeAgent } from "./client.js";
+import type { Json } from "./extensions.js";
+import type { WatchdogSqliteOwner } from "@fungi.computer/watchdog";
+import { type CairnId } from "@fungi.computer/cairn/id";
+import { z } from "zod";
+import { type FungiAuthor } from "@fungi.computer/agar/agents";
+/** Operations explicitly admitted by the host. */
+export declare const agentActionSchema: z.ZodEnum<{
+    send: "send";
+    read: "read";
+    create: "create";
+    manage: "manage";
+    delegate: "delegate";
+}>;
+/** One host-admitted fleet operation. */
+export type AgentAction = z.infer<typeof agentActionSchema>;
+/** Attribution supplied by the admitting host, without Team semantics. */
+export declare const agentProvenanceSchema: z.ZodObject<{
+    actor: z.ZodString;
+    workflowRunId: z.ZodOptional<z.ZodString>;
+    toolCallInputDigest: z.ZodOptional<z.ZodString>;
+    session: z.ZodOptional<z.ZodObject<{
+        agentId: z.ZodString;
+        sessionId: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+/** Fleet authority is supplied, never looked up in host policy. */
+export declare const agentGrantSchema: z.ZodObject<{
+    agents: z.ZodUnion<readonly [z.ZodLiteral<"all">, z.ZodArray<z.ZodString>]>;
+    actions: z.ZodArray<z.ZodEnum<{
+        send: "send";
+        read: "read";
+        create: "create";
+        manage: "manage";
+        delegate: "delegate";
+    }>>;
+    expiresAt: z.ZodNumber;
+    provenance: z.ZodObject<{
+        actor: z.ZodString;
+        workflowRunId: z.ZodOptional<z.ZodString>;
+        toolCallInputDigest: z.ZodOptional<z.ZodString>;
+        session: z.ZodOptional<z.ZodObject<{
+            agentId: z.ZodString;
+            sessionId: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    meta: z.ZodOptional<z.ZodJSONSchema>;
+    maxDepth: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+/** A trusted host's bounded, addressed authority for fleet operations. */
+export type AgentGrant = z.infer<typeof agentGrantSchema>;
+/** A committed directory transition, returned in the host's transaction. */
+export type AgentLifecycleFact = Readonly<{
+    kind: "created" | "deleted";
+    agentId: string;
+    provenance: AgentGrant["provenance"];
+}>;
+/** Refusal of supplied authority; no host policy lookup is performed. */
+export declare class AgentGrantError extends Error {
+    readonly reason: "agent" | "action" | "expired" | "delegation_loop" | "delegation_depth";
+    constructor(reason: "agent" | "action" | "expired" | "delegation_loop" | "delegation_depth");
+}
+/** Check every operation against its explicit authority. */
+export declare function assertAgentGrant(grant: AgentGrant, action: AgentAction, agentId?: string): void;
+/** Stable Agent identities, retained across host compositions. */
+export declare const agentIds: Readonly<{
+    readonly agent: import("@fungi.computer/cairn/id").IdCodec<"agent", "agent", 1>;
+}>;
+/** An ordinary Agent directory identity. */
+export type AgentId = CairnId<"agent", "agent">;
+/** Stable replay input; configuration is an opaque host creation choice. */
+export declare const agentCreationSchema: z.ZodObject<{
+    name: z.ZodString;
+    requestId: z.ZodString;
+    configuration: z.ZodString;
+}, z.core.$strict>;
+/** One idempotent directory reservation. */
+export type AgentCreation = z.infer<typeof agentCreationSchema>;
+/** Owner-only rename input: an Agent's new display name. */
+export declare const agentRenameSchema: z.ZodObject<{
+    name: z.ZodString;
+}, z.core.$strict>;
+/** Input to {@link createAgentDirectory}'s `rename`. */
+export type AgentRename = z.infer<typeof agentRenameSchema>;
+/** One durable Agent directory record. */
+export type DirectoryAgent = Readonly<{
+    agentId: AgentId;
+    name: string;
+    createdAt: number;
+    updatedAt: number;
+}>;
+/** Directory input, replay or storage refusal. */
+export declare class DirectoryError extends Error {
+    readonly status: 400 | 403 | 404 | 409 | 503;
+    readonly code: "invalid_input" | "not_found" | "name_taken" | "request_conflict" | "computer_team_conflict" | "partial_init";
+    constructor(status: 400 | 403 | 404 | 409 | 503, code: "invalid_input" | "not_found" | "name_taken" | "request_conflict" | "computer_team_conflict" | "partial_init");
+}
+/**
+ * Agent identities, replay receipts and erasure roster. Mutations belong inside
+ * the caller's storage transaction, so lifecycle facts and host projections
+ * commit together. Physical table names retain the existing Hub store layout.
+ */
+export declare function createAgentDirectory(sql: WatchdogSqliteOwner["sql"]): {
+    /** Resolve a matching creation receipt before host admission of a new reservation. */
+    readCreation: (grant: AgentGrant, raw: AgentCreation) => DirectoryAgent | null;
+    /** Reserve an Agent once and return its committed lifecycle fact. */
+    create: (grant: AgentGrant, raw: AgentCreation) => {
+        agent: Readonly<{
+            agentId: AgentId;
+            name: string;
+            createdAt: number;
+            updatedAt: number;
+        }>;
+        fact: null;
+    } | {
+        agent: Readonly<{
+            agentId: AgentId;
+            name: string;
+            createdAt: number;
+            updatedAt: number;
+        }>;
+        fact: {
+            kind: "created";
+            agentId: CairnId<"agent", "agent", 1>;
+            provenance: {
+                actor: string;
+                workflowRunId?: string | undefined;
+                toolCallInputDigest?: string | undefined;
+                session?: {
+                    agentId: string;
+                    sessionId: string;
+                } | undefined;
+            };
+        };
+    };
+    /** Read one admitted Agent identity. */
+    read: (grant: AgentGrant, agentId: AgentId) => DirectoryAgent | null;
+    /** List only identities covered by the supplied grant. */
+    list: (grant: AgentGrant) => readonly DirectoryAgent[];
+    /** Remove an identity while retaining its erasure address. */
+    remove: (grant: AgentGrant, agentId: AgentId) => AgentLifecycleFact | null;
+    /** Rename an existing Agent; refuses a name already held by another one. */
+    rename: (grant: AgentGrant, agentId: AgentId, raw: AgentRename) => DirectoryAgent;
+    /** Read the host actor recorded at creation. */
+    readCreator: (grant: AgentGrant, agentId: string) => string | null;
+    /** Enumerate retained addresses for host erasure. */
+    listErasureIds: () => readonly string[];
+    /** Whether the retained erasure roster covers this store. */
+    erasureRosterComplete: () => boolean;
+};
+/** Replay identity and work, with the parent supplied exclusively by the grant. */
+export declare const agentDelegationTaskSchema: z.ZodObject<{
+    requestId: z.ZodString;
+    agentId: z.ZodString;
+    sessionId: z.ZodOptional<z.ZodString>;
+    text: z.ZodString;
+}, z.core.$strict>;
+/** A caller reuses this task unchanged while polling Pending. */
+export type AgentDelegationTask = z.infer<typeof agentDelegationTaskSchema>;
+/** Exact host facts encoded over internal transports, without transcript content. */
+export declare const commandSettlementSchema: Schema.Codec<CommandSettlement>;
+/** Exact settled Session facts, including Pi usage and tool-call records. */
+export type AgentDelegationOutcome = Readonly<{
+    kind: "settled";
+    agentId: string;
+    sessionId: string;
+}> & CommandSettlement;
+/** Ordinary runtime and mail transports; these ports do not decide host policy. */
+export type FleetDelegationOptions = Readonly<{
+    storage: WatchdogSqliteOwner;
+    /** Admit the frozen addressed mail through the destination owner. */
+    deliver: (mail: BirdDogMail) => Promise<Accepted>;
+    /** Read exact work facts at the target owner, independent of transcript selection. */
+    readSettlement: (agentId: string, sessionId: string, commandId: string) => Promise<CommandSettlement | undefined>;
+    /** Acquire a Session client only when creating the delegated conversation. */
+    open: (agentId: string) => Promise<Readonly<{
+        agent: ShiitakeAgent;
+        /** Release the borrowed transport without stopping its run. */
+        release: () => Promise<void>;
+    }>>;
+}>;
+/**
+ * The delegation meta the host attaches to an authenticated reply: the
+ * caller's own path plus the verified reply, whose `agentId` is the reply's
+ * author.
+ */
+export type AuthenticatedDelegationReply = Readonly<{
+    ancestors: readonly string[];
+    maxDepth: number;
+    reply: VerifiedAgentReply;
+}>;
+/** The host metadata a delegated send carries, as JSON. */
+export type DelegationSendMeta = {
+    author: FungiAuthor;
+    delegation?: {
+        ancestors: string[];
+        maxDepth: number;
+    };
+};
+/** The host metadata on one authenticated reply line, as JSON. */
+export type DelegationReplyMeta = Readonly<{
+    author: FungiAuthor;
+    delegation: Readonly<{
+        ancestors: readonly string[];
+        maxDepth: number;
+        reply: VerifiedAgentReply;
+    }>;
+}>;
+/**
+ * Provenance for one delegated send from the invoking Agent's Session. The
+ * model program's digest is frozen with the replay input, so a retried tool
+ * call that changed its code conflicts instead of replaying.
+ */
+export declare function delegationProvenance(session: Readonly<{
+    agentId: string;
+    sessionId: string;
+}>, toolCallCode?: string): Promise<AgentGrant["provenance"]>;
+/**
+ * The host metadata one delegated send carries: the sending Agent as author
+ * and only the path inherited from the invoking line. A reply's verified facts
+ * stay on that reply's own line and never travel onward.
+ */
+export declare function delegationSendMeta(sender: FungiAuthor, invocationMeta?: Json): DelegationSendMeta;
+/**
+ * The host metadata for one authenticated reply line: the replying Agent is
+ * its author, and the verified reply rides beside the caller's own path.
+ */
+export declare function delegationReplyMeta(delegation: AuthenticatedDelegationReply, replierName: string): DelegationReplyMeta;
+/** One Agent a Session sent work to: its latest addressed conversation. */
+export type FleetRecipient = Readonly<{
+    agentId: string;
+    sessionId: string;
+    sentAt: number;
+}>;
+/** A bounded page of recipients and how many more exist past it. */
+export type FleetRecipients = Readonly<{
+    recipients: readonly FleetRecipient[];
+    more: number;
+}>;
+/**
+ * Hosted BirdDog submission and Pending observation. The durable row freezes
+ * correspondence before transport; an ambiguous delivery reuses that exact mail.
+ * Shiitake owns work deduplication, execution and settlement; Post owns replies.
+ */
+export declare function createFleetDelegation(options: FleetDelegationOptions): {
+    /** Authenticate a reply against its frozen mail and restore the caller's path. */
+    authenticateReply: (mail: BirdDogMail) => AuthenticatedDelegationReply | undefined;
+    /** One grouped read of the Agents a parent Session sent work to. */
+    recipients: (parent: Readonly<{
+        agentId: string;
+        sessionId: string;
+    }>, limit: number) => FleetRecipients;
+    /** Submit once and return the existing Shiitake admission receipt. */
+    start: (grant: AgentGrant, raw: AgentDelegationTask) => Promise<Accepted>;
+    /** Submit or poll the exact turn, yielding Agar Pending until settled. */
+    delegate: (grant: AgentGrant, task: AgentDelegationTask) => Promise<Pending | AgentDelegationOutcome>;
+};
+/** Acquire ordinary Session access; an in-process host applies meta with withMeta. */
+export type FleetAgentAccess = (agentId: string, meta?: Json) => Promise<Readonly<{
+    agent: ShiitakeAgent;
+    /** Release the borrowed transport without stopping its run. */
+    release: () => Promise<void>;
+}>>;
+/** One idempotent prompt, using the Session owner's existing delivery grammar. */
+export type FleetMessage = Readonly<{
+    requestId: string;
+    text: string;
+    delivery?: "steer" | "followUp";
+}>;
+/**
+ * Addressed Session operations over the existing Shiitake client. Each operation
+ * checks a fresh supplied grant and releases its transport without stopping work.
+ */
+export declare function createFleetSessions(open: FleetAgentAccess): {
+    /** Enumerate existing Sessions through the owner's bounded cursor. */
+    list: (grant: AgentGrant, agentId: string, after?: string) => Promise<Readonly<{
+        sessions: readonly import("./client.js").SessionSummaryRow[];
+        next: string | undefined;
+    }>>;
+    /** Open the exact saved conversation without creating work. */
+    read: (grant: AgentGrant, agentId: string, sessionId: string) => Promise<Readonly<{
+        sessionId: string;
+        cursor: string | null;
+        hasMore: boolean;
+        oldestCursor?: string | null;
+        messages: readonly import("./client.js").SessionMessage[];
+        terminals: readonly import("./client.js").SessionTerminal[];
+        compactions?: readonly import("./client.js").SessionCompactionMarker[];
+        compactionNotices?: readonly import("./client.js").SessionCompactionNotice[];
+        sandboxFailures?: readonly import("@fungi.computer/mycelium").SandboxFailureEvent[];
+        pending: import("./client.js").SessionPendingPrompts;
+        activity: import("./client.js").SessionActivity;
+        progress: import("./client.js").SessionProgress | null;
+        extensions: import("./client.js").SessionExtensionSlots;
+        attention: readonly import("./session-attention.js").SessionAttention[];
+        context?: import("./client.js").SessionContext;
+    }>>;
+    /** Create a Session once under the caller's replay identity. */
+    create: (grant: AgentGrant, agentId: string, requestId: string) => Promise<string>;
+    /** Remove a Session through its runtime owner. */
+    remove: (grant: AgentGrant, agentId: string, sessionId: string) => Promise<boolean>;
+    /** Send once; an omitted Session is created under the same replay identity. */
+    send: (grant: AgentGrant, agentId: string, sessionId: string | undefined, message: FleetMessage) => Promise<{
+        sessionId: string;
+        status: "accepted";
+        commandId: string;
+    }>;
+};