@dxos/agent-runtime 0.0.0

package/dist/types/src/agent-service/AgentService.d.ts

@@ -0,0 +1,45 @@
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import { McpServer, Skill } from '@dxos/compute';
+import { ProcessManager } from '@dxos/compute-runtime';
+import { AgentService, type Session } from '@dxos/compute/AgentService';
+import { Database, Obj, Ref, Registry } from '@dxos/echo';
+import { DXN } from '@dxos/keys';
+import { type DelegationStrategy } from './delegation-strategy';
+export interface CreateSessionOptions {
+    readonly skills?: Skill.Skill[];
+    readonly context?: Ref.Ref<Obj.Unknown>[];
+    readonly model?: DXN.DXN;
+    readonly provider?: DXN.DXN;
+    readonly systemPrompt?: string;
+}
+export declare const createSession: (opts?: CreateSessionOptions) => Effect.Effect<Session, Skill.NotFoundError, Database.Service | Registry.Service | AgentService>;
+export interface AgentServiceOptions {
+    systemPrompt?: string;
+    /**
+     * Default model used by sessions that don't specify one explicitly.
+     */
+    model?: DXN.DXN;
+    /**
+     * Default provider used to resolve the model for sessions that don't specify one explicitly.
+     */
+    provider?: DXN.DXN;
+    /**
+     * Provider for space-level MCP server configs.
+     */
+    getMcpServers?: () => McpServer.McpServer[];
+    /**
+     * If true, long-running tool calls are moved to the background and the agent is notified
+     * asynchronously when they complete. Currently unstable — disabled by default.
+     *
+     * @default false
+     */
+    enableToolBackgrounding?: boolean;
+    /**
+     * When provided, sessions act as supervisors: the agent delegates outstanding work to sub-agent
+     * child processes and folds their results back into the conversation. Absent — a plain agent.
+     */
+    delegationStrategy?: DelegationStrategy;
+}
+export declare const layer: (opts?: AgentServiceOptions) => Layer.Layer<AgentService, never, ProcessManager.Service>;
+//# sourceMappingURL=AgentService.d.ts.map

package/dist/types/src/agent-service/AgentService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AgentService.d.ts","sourceRoot":"","sources":["../../../../src/agent-service/AgentService.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AAGtC,OAAO,EAAE,SAAS,EAAW,KAAK,EAAE,MAAM,eAAe,CAAC;AAC1D,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,EACL,YAAY,EAGZ,KAAK,OAAO,EAEb,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAAc,QAAQ,EAAQ,GAAG,EAAE,GAAG,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE5E,OAAO,EAAE,GAAG,EAAO,MAAM,YAAY,CAAC;AAItC,OAAO,EAAE,KAAK,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAWhE,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,MAAM,CAAC,EAAE,KAAK,CAAC,KAAK,EAAE,CAAC;IAChC,QAAQ,CAAC,OAAO,CAAC,EAAE,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,CAAC;IAC1C,QAAQ,CAAC,KAAK,CAAC,EAAE,GAAG,CAAC,GAAG,CAAC;IACzB,QAAQ,CAAC,QAAQ,CAAC,EAAE,GAAG,CAAC,GAAG,CAAC;IAC5B,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;CAChC;AAED,eAAO,MAAM,aAAa,EAAE,CAC1B,IAAI,CAAC,EAAE,oBAAoB,KACxB,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,KAAK,CAAC,aAAa,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,OAAO,GAAG,YAAY,CAmBlF,CAAC;AAElB,MAAM,WAAW,mBAAmB;IAClC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;OAEG;IACH,KAAK,CAAC,EAAE,GAAG,CAAC,GAAG,CAAC;IAEhB;;OAEG;IACH,QAAQ,CAAC,EAAE,GAAG,CAAC,GAAG,CAAC;IAEnB;;OAEG;IACH,aAAa,CAAC,EAAE,MAAM,SAAS,CAAC,SAAS,EAAE,CAAC;IAE5C;;;;;OAKG;IACH,uBAAuB,CAAC,EAAE,OAAO,CAAC;IAElC;;;OAGG;IACH,kBAAkB,CAAC,EAAE,kBAAkB,CAAC;CACzC;AAED,eAAO,MAAM,KAAK,UAAW,mBAAmB,KAAG,KAAK,CAAC,KAAK,CAAC,YAAY,EAAE,KAAK,EAAE,cAAc,CAAC,OAAO,CA+GvG,CAAC"}

package/dist/types/src/agent-service/AgentService.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=AgentService.test.d.ts.map

package/dist/types/src/agent-service/AgentService.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AgentService.test.d.ts","sourceRoot":"","sources":["../../../../src/agent-service/AgentService.test.ts"],"names":[],"mappings":""}

package/dist/types/src/agent-service/agent-process.d.ts

@@ -0,0 +1,457 @@
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
+import { AiService, OpaqueToolkit } from '@dxos/ai';
+import { Credential, McpServer, Operation } from '@dxos/compute';
+import { Process } from '@dxos/compute';
+import { ProcessManager } from '@dxos/compute-runtime';
+import * as StorageService from '@dxos/compute/StorageService';
+import { Database, Obj, Ref, Registry } from '@dxos/echo';
+import { DXN } from '@dxos/keys';
+import { type DelegationStrategy } from './delegation-strategy';
+interface AgentProcessOptions {
+    systemPrompt?: string;
+    model?: DXN.DXN;
+    provider?: DXN.DXN;
+    /**
+     * Provider for space-level MCP server configs, called on each turn.
+     */
+    getMcpServers?: () => McpServer.McpServer[];
+    /**
+     * If true, long-running tool calls are moved to the background after `backgroundThreshold`
+     * and the agent is notified asynchronously when they complete.
+     *
+     * Currently unstable — disabled by default.
+     *
+     * @default false
+     */
+    enableToolBackgrounding?: boolean;
+    /**
+     * When provided, the agent acts as a supervisor: after each turn it delegates outstanding work to
+     * linked child processes and folds their results back into the conversation on completion. Absent
+     * (the default) the process behaves as a plain conversational agent.
+     */
+    delegationStrategy?: DelegationStrategy;
+}
+export declare const AGENT_PROCESS_KEY = "org.dxos.testing.process.agent";
+/**
+ * Hosts a persistent, suspendible AiAgent that can process a number of prompts.
+ * The process target is a queue DXN string.
+ */
+export declare const AgentProcess: (options: AgentProcessOptions) => Process.Process<string, void, AiService.AiService | Credential.CredentialsService | OpaqueToolkit.OpaqueToolkitProvider | Registry.Service | Database.Service | Operation.Service | ProcessManager.ProcessOperationInvoker.Service | StorageService.StorageService, import("@effect/rpc/Rpc").Rpc<"enqueueMessage", Schema.Struct<{
+    content: Schema.Array$<Schema.Union<[Schema.TaggedStruct<"anchor", {
+        pending: Schema.optional<typeof Schema.Boolean>;
+        objectId: import("@dxos/keys").EntityIdClass;
+        version: typeof Schema.Unknown;
+    }>, Schema.TaggedStruct<"file", {
+        pending: Schema.optional<typeof Schema.Boolean>;
+        url: typeof Schema.String;
+        name: Schema.optional<typeof Schema.String>;
+        mediaType: Schema.optional<typeof Schema.String>;
+    }>, Schema.TaggedStruct<"image", {
+        pending: Schema.optional<typeof Schema.Boolean>;
+        id: Schema.optional<typeof Schema.String>;
+        source: Schema.optional<Schema.Union<[Schema.Struct<{
+            type: Schema.Literal<["base64"]>;
+            mediaType: typeof Schema.String;
+            data: typeof Schema.String;
+        }>, Schema.Struct<{
+            type: Schema.Literal<["http"]>;
+            url: typeof Schema.String;
+        }>]>>;
+    }>, Schema.TaggedStruct<"json", {
+        pending: Schema.optional<typeof Schema.Boolean>;
+        disposition: Schema.optional<Schema.Literal<["user", "synthetic", "cot", "version-pin"]>>;
+        data: typeof Schema.String;
+    }>, Schema.TaggedStruct<"proposal", {
+        pending: Schema.optional<typeof Schema.Boolean>;
+        text: typeof Schema.String;
+    }>, Schema.TaggedStruct<"reasoning", {
+        pending: Schema.optional<typeof Schema.Boolean>;
+        reasoningText: Schema.optional<typeof Schema.String>;
+        redactedText: Schema.optional<typeof Schema.String>;
+        signature: Schema.optional<typeof Schema.String>;
+    }>, Schema.TaggedStruct<"reference", {
+        pending: Schema.optional<typeof Schema.Boolean>;
+        reference: import("@dxos/echo/Ref").RefSchema<import("@dxos/echo/Obj").Unknown>;
+    }>, Schema.TaggedStruct<"select", {
+        pending: Schema.optional<typeof Schema.Boolean>;
+        options: Schema.mutable<Schema.Array$<typeof Schema.String>>;
+    }>, Schema.TaggedStruct<"status", {
+        pending: Schema.optional<typeof Schema.Boolean>;
+        statusText: typeof Schema.String;
+    }>, Schema.TaggedStruct<"suggestion", {
+        pending: Schema.optional<typeof Schema.Boolean>;
+        text: typeof Schema.String;
+    }>, Schema.TaggedStruct<"stats", {
+        pending: Schema.optional<typeof Schema.Boolean>;
+        mimeType: Schema.optional<typeof Schema.String>;
+        message: Schema.optional<typeof Schema.String>;
+        model: Schema.optional<typeof Schema.String>;
+        usage: Schema.optional<Schema.Struct<{
+            inputTokens: Schema.optional<typeof Schema.Number>;
+            outputTokens: Schema.optional<typeof Schema.Number>;
+            totalTokens: Schema.optional<typeof Schema.Number>;
+        }>>;
+        toolCalls: Schema.optional<typeof Schema.Number>;
+        errors: Schema.optional<typeof Schema.Number>;
+        duration: Schema.optional<typeof Schema.Number>;
+        finishReason: Schema.optional<Schema.Literal<["stop", "length", "content-filter", "tool-calls", "error", "pause", "other", "unknown"]>>;
+    }>, Schema.TaggedStruct<"surface", {
+        pending: Schema.optional<typeof Schema.Boolean>;
+        role: typeof Schema.String;
+        data: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+    }>, Schema.TaggedStruct<"text", {
+        pending: Schema.optional<typeof Schema.Boolean>;
+        mimeType: Schema.optional<typeof Schema.String>;
+        text: typeof Schema.String;
+        disposition: Schema.optional<Schema.Literal<["user", "synthetic", "cot", "version-pin"]>>;
+    }>, Schema.TaggedStruct<"summary", {
+        pending: Schema.optional<typeof Schema.Boolean>;
+        content: typeof Schema.String;
+    }>, Schema.TaggedStruct<"toolkit", {
+        pending: Schema.optional<typeof Schema.Boolean>;
+    }>, Schema.TaggedStruct<"toolCall", {
+        pending: Schema.optional<typeof Schema.Boolean>;
+        toolCallId: typeof Schema.String;
+        name: typeof Schema.String;
+        input: typeof Schema.String;
+        providerExecuted: typeof Schema.Boolean;
+        operationKey: Schema.optional<typeof Schema.String>;
+        operationName: Schema.optional<typeof Schema.String>;
+        operationIcon: Schema.optional<typeof Schema.String>;
+    }>, Schema.TaggedStruct<"toolResult", {
+        pending: Schema.optional<typeof Schema.Boolean>;
+        toolCallId: typeof Schema.String;
+        name: typeof Schema.String;
+        result: Schema.optional<Schema.Union<[typeof Schema.String, Schema.suspend<{
+            readonly _tag: "~@dxos/types/ContentBlock.ContentBlockResult";
+            readonly content: readonly ({
+                readonly _tag: "text";
+                readonly pending?: boolean | undefined;
+                readonly mimeType?: string | undefined;
+                readonly text: string;
+                readonly disposition?: "cot" | "synthetic" | "user" | "version-pin" | undefined;
+            } | {
+                readonly _tag: "image";
+                readonly pending?: boolean | undefined;
+                readonly id?: string | undefined;
+                readonly source?: {
+                    readonly type: "base64";
+                    readonly mediaType: string;
+                    readonly data: string;
+                } | {
+                    readonly type: "http";
+                    readonly url: string;
+                } | undefined;
+            } | {
+                readonly _tag: "file";
+                readonly pending?: boolean | undefined;
+                readonly url: string;
+                readonly name?: string | undefined;
+                readonly mediaType?: string | undefined;
+            })[];
+        }, {
+            readonly _tag: "~@dxos/types/ContentBlock.ContentBlockResult";
+            readonly content: readonly ({
+                readonly _tag: "text";
+                readonly disposition?: "cot" | "synthetic" | "user" | "version-pin" | undefined;
+                readonly mimeType?: string | undefined;
+                readonly pending?: boolean | undefined;
+                readonly text: string;
+            } | {
+                readonly _tag: "image";
+                readonly id?: string | undefined;
+                readonly pending?: boolean | undefined;
+                readonly source?: {
+                    readonly data: string;
+                    readonly mediaType: string;
+                    readonly type: "base64";
+                } | {
+                    readonly type: "http";
+                    readonly url: string;
+                } | undefined;
+            } | {
+                readonly _tag: "file";
+                readonly mediaType?: string | undefined;
+                readonly name?: string | undefined;
+                readonly pending?: boolean | undefined;
+                readonly url: string;
+            })[];
+        }, never>]>>;
+        error: Schema.optional<typeof Schema.String>;
+        providerExecuted: typeof Schema.Boolean;
+    }>, Schema.TaggedStruct<"transcript", {
+        pending: Schema.optional<typeof Schema.Boolean>;
+        started: typeof Schema.String;
+        text: typeof Schema.String;
+        corrected: Schema.optional<typeof Schema.String>;
+        references: Schema.optional<Schema.mutable<Schema.Array$<import("@dxos/echo/Ref").RefSchema<import("@dxos/echo/Obj").Unknown>>>>;
+        candidates: Schema.optional<Schema.mutable<Schema.Array$<Schema.Struct<{
+            text: typeof Schema.String;
+            kind: Schema.Literal<["noun", "proper-noun"]>;
+            start: typeof Schema.Number;
+            end: typeof Schema.Number;
+            suggested: Schema.optional<Schema.Struct<{
+                typename: typeof Schema.String;
+            }>>;
+        }>>>>;
+        translation: Schema.optional<typeof Schema.String>;
+    }>]>>;
+}>, typeof Schema.Void, typeof Schema.Never, never> | import("@effect/rpc/Rpc").Rpc<"setAlarm", Schema.Struct<{
+    at: typeof Schema.DateTimeUtc;
+    message: Schema.NullOr<typeof Schema.String>;
+}>, typeof Schema.Void, typeof Schema.Never, never>>;
+declare const AgentEvent: Schema.Union<[Schema.TaggedStruct<"prompt", {
+    content: Schema.Array$<Schema.Union<[Schema.TaggedStruct<"anchor", {
+        pending: Schema.optional<typeof Schema.Boolean>;
+        objectId: import("@dxos/keys").EntityIdClass;
+        version: typeof Schema.Unknown;
+    }>, Schema.TaggedStruct<"file", {
+        pending: Schema.optional<typeof Schema.Boolean>;
+        url: typeof Schema.String;
+        name: Schema.optional<typeof Schema.String>;
+        mediaType: Schema.optional<typeof Schema.String>;
+    }>, Schema.TaggedStruct<"image", {
+        pending: Schema.optional<typeof Schema.Boolean>;
+        id: Schema.optional<typeof Schema.String>;
+        source: Schema.optional<Schema.Union<[Schema.Struct<{
+            type: Schema.Literal<["base64"]>;
+            mediaType: typeof Schema.String;
+            data: typeof Schema.String;
+        }>, Schema.Struct<{
+            type: Schema.Literal<["http"]>;
+            url: typeof Schema.String;
+        }>]>>;
+    }>, Schema.TaggedStruct<"json", {
+        pending: Schema.optional<typeof Schema.Boolean>;
+        disposition: Schema.optional<Schema.Literal<["user", "synthetic", "cot", "version-pin"]>>;
+        data: typeof Schema.String;
+    }>, Schema.TaggedStruct<"proposal", {
+        pending: Schema.optional<typeof Schema.Boolean>;
+        text: typeof Schema.String;
+    }>, Schema.TaggedStruct<"reasoning", {
+        pending: Schema.optional<typeof Schema.Boolean>;
+        reasoningText: Schema.optional<typeof Schema.String>;
+        redactedText: Schema.optional<typeof Schema.String>;
+        signature: Schema.optional<typeof Schema.String>;
+    }>, Schema.TaggedStruct<"reference", {
+        pending: Schema.optional<typeof Schema.Boolean>;
+        reference: Ref.RefSchema<Obj.Unknown>;
+    }>, Schema.TaggedStruct<"select", {
+        pending: Schema.optional<typeof Schema.Boolean>;
+        options: Schema.mutable<Schema.Array$<typeof Schema.String>>;
+    }>, Schema.TaggedStruct<"status", {
+        pending: Schema.optional<typeof Schema.Boolean>;
+        statusText: typeof Schema.String;
+    }>, Schema.TaggedStruct<"suggestion", {
+        pending: Schema.optional<typeof Schema.Boolean>;
+        text: typeof Schema.String;
+    }>, Schema.TaggedStruct<"stats", {
+        pending: Schema.optional<typeof Schema.Boolean>;
+        mimeType: Schema.optional<typeof Schema.String>;
+        message: Schema.optional<typeof Schema.String>;
+        model: Schema.optional<typeof Schema.String>;
+        usage: Schema.optional<Schema.Struct<{
+            inputTokens: Schema.optional<typeof Schema.Number>;
+            outputTokens: Schema.optional<typeof Schema.Number>;
+            totalTokens: Schema.optional<typeof Schema.Number>;
+        }>>;
+        toolCalls: Schema.optional<typeof Schema.Number>;
+        errors: Schema.optional<typeof Schema.Number>;
+        duration: Schema.optional<typeof Schema.Number>;
+        finishReason: Schema.optional<Schema.Literal<["stop", "length", "content-filter", "tool-calls", "error", "pause", "other", "unknown"]>>;
+    }>, Schema.TaggedStruct<"surface", {
+        pending: Schema.optional<typeof Schema.Boolean>;
+        role: typeof Schema.String;
+        data: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+    }>, Schema.TaggedStruct<"text", {
+        pending: Schema.optional<typeof Schema.Boolean>;
+        mimeType: Schema.optional<typeof Schema.String>;
+        text: typeof Schema.String;
+        disposition: Schema.optional<Schema.Literal<["user", "synthetic", "cot", "version-pin"]>>;
+    }>, Schema.TaggedStruct<"summary", {
+        pending: Schema.optional<typeof Schema.Boolean>;
+        content: typeof Schema.String;
+    }>, Schema.TaggedStruct<"toolkit", {
+        pending: Schema.optional<typeof Schema.Boolean>;
+    }>, Schema.TaggedStruct<"toolCall", {
+        pending: Schema.optional<typeof Schema.Boolean>;
+        toolCallId: typeof Schema.String;
+        name: typeof Schema.String;
+        input: typeof Schema.String;
+        providerExecuted: typeof Schema.Boolean;
+        operationKey: Schema.optional<typeof Schema.String>;
+        operationName: Schema.optional<typeof Schema.String>;
+        operationIcon: Schema.optional<typeof Schema.String>;
+    }>, Schema.TaggedStruct<"toolResult", {
+        pending: Schema.optional<typeof Schema.Boolean>;
+        toolCallId: typeof Schema.String;
+        name: typeof Schema.String;
+        result: Schema.optional<Schema.Union<[typeof Schema.String, Schema.suspend<{
+            readonly _tag: "~@dxos/types/ContentBlock.ContentBlockResult";
+            readonly content: readonly ({
+                readonly _tag: "text";
+                readonly pending?: boolean | undefined;
+                readonly mimeType?: string | undefined;
+                readonly text: string;
+                readonly disposition?: "cot" | "synthetic" | "user" | "version-pin" | undefined;
+            } | {
+                readonly _tag: "image";
+                readonly pending?: boolean | undefined;
+                readonly id?: string | undefined;
+                readonly source?: {
+                    readonly type: "base64";
+                    readonly mediaType: string;
+                    readonly data: string;
+                } | {
+                    readonly type: "http";
+                    readonly url: string;
+                } | undefined;
+            } | {
+                readonly _tag: "file";
+                readonly pending?: boolean | undefined;
+                readonly url: string;
+                readonly name?: string | undefined;
+                readonly mediaType?: string | undefined;
+            })[];
+        }, {
+            readonly _tag: "~@dxos/types/ContentBlock.ContentBlockResult";
+            readonly content: readonly ({
+                readonly _tag: "text";
+                readonly disposition?: "cot" | "synthetic" | "user" | "version-pin" | undefined;
+                readonly mimeType?: string | undefined;
+                readonly pending?: boolean | undefined;
+                readonly text: string;
+            } | {
+                readonly _tag: "image";
+                readonly id?: string | undefined;
+                readonly pending?: boolean | undefined;
+                readonly source?: {
+                    readonly data: string;
+                    readonly mediaType: string;
+                    readonly type: "base64";
+                } | {
+                    readonly type: "http";
+                    readonly url: string;
+                } | undefined;
+            } | {
+                readonly _tag: "file";
+                readonly mediaType?: string | undefined;
+                readonly name?: string | undefined;
+                readonly pending?: boolean | undefined;
+                readonly url: string;
+            })[];
+        }, never>]>>;
+        error: Schema.optional<typeof Schema.String>;
+        providerExecuted: typeof Schema.Boolean;
+    }>, Schema.TaggedStruct<"transcript", {
+        pending: Schema.optional<typeof Schema.Boolean>;
+        started: typeof Schema.String;
+        text: typeof Schema.String;
+        corrected: Schema.optional<typeof Schema.String>;
+        references: Schema.optional<Schema.mutable<Schema.Array$<Ref.RefSchema<Obj.Unknown>>>>;
+        candidates: Schema.optional<Schema.mutable<Schema.Array$<Schema.Struct<{
+            text: typeof Schema.String;
+            kind: Schema.Literal<["noun", "proper-noun"]>;
+            start: typeof Schema.Number;
+            end: typeof Schema.Number;
+            suggested: Schema.optional<Schema.Struct<{
+                typename: typeof Schema.String;
+            }>>;
+        }>>>>;
+        translation: Schema.optional<typeof Schema.String>;
+    }>]>>;
+}>, Schema.TaggedStruct<"tool_result", {
+    pid: Schema.brand<typeof Schema.String, "ProcessId">;
+    result: typeof Schema.Unknown;
+    isError: typeof Schema.Boolean;
+}>, Schema.TaggedStruct<"alarm", {
+    firedAt: typeof Schema.Number;
+    message: Schema.NullOr<typeof Schema.String>;
+}>]>;
+type AgentEvent = Schema.Schema.Type<typeof AgentEvent>;
+/**
+ * Tracks delegated sub-agent child processes (pid -> correlation id) so that, after a hibernation,
+ * a delegated child's exit can be matched back to the work it was fulfilling.
+ */
+declare const Delegation: Schema.mutable<Schema.Struct<{
+    pid: Schema.brand<typeof Schema.String, "ProcessId">;
+    id: typeof Schema.String;
+}>>;
+type Delegation = Schema.Schema.Type<typeof Delegation>;
+declare class ToolCallManager {
+    #private;
+    constructor(storageService: StorageService.Service);
+    load(): Effect.Effect<void, never, never>;
+    beginCall(pid: Process.ID): Effect.Effect<void, never, never>;
+    markAsReported(pid: Process.ID): Effect.Effect<void, never, never>;
+    isToolCall(pid: Process.ID): boolean;
+    isReported(pid: Process.ID): boolean;
+    /** True while a tool-call result has not yet been delivered back to the agent turn. */
+    hasPendingToolResults(): boolean;
+    /**
+     * Clears reported flags for tool calls that still have a pending queue entry.
+     * After reload the in-flight createRequest is gone, so those results must be redelivered via onAlarm.
+     */
+    reconcileWithInputQueue(queue: readonly AgentEvent[]): Effect.Effect<void, never, never>;
+}
+export type AgentIdleSnapshot = {
+    inputQueue: readonly AgentEvent[];
+    alarmManager: AlarmManager;
+    delegations: readonly Delegation[];
+    toolCallManager: Pick<ToolCallManager, 'hasPendingToolResults'>;
+};
+/** True while the agent still has queued work, a self-wake, subprocesses, or undelivered tool results. */
+export declare const isAgentWorkPending: ({ inputQueue, alarmManager, delegations, toolCallManager, }: AgentIdleSnapshot) => boolean;
+/**
+ * Computes the timeout to pass to `ctx.setAlarm`, reconciling pending queue work with the agent's
+ * self-wake alarm. Returns `null` when no alarm should be scheduled (process can go idle).
+ */
+export declare const computeAlarmDelay: ({ hasPendingWork, wakeAt, now, }: {
+    hasPendingWork: boolean;
+    wakeAt: number | null;
+    now: number;
+}) => number | null;
+interface AlarmManagerOptions {
+    storageService: StorageService.Service;
+    setAlarm: (timeout?: number) => void;
+    /**
+     * Source of the current time. Injectable for deterministic tests.
+     * @default () => Date.now()
+     */
+    now?: () => number;
+}
+/**
+ * Tracks the next agent-scheduled self-wake and keeps it in sync with the process alarm
+ * (`ctx.setAlarm`). The agent sets alarms via the alarm blueprint, which dispatches to this manager
+ * through the `HarnessControl` RPC surface; the process reconciles the underlying single-shot alarm
+ * timer to fire at the earliest of pending work or the self-wake.
+ */
+export declare class AlarmManager {
+    #private;
+    constructor({ storageService, setAlarm, now }: AlarmManagerOptions);
+    /** Currently scheduled self-wake timestamp (ms), or `null` when none is set. */
+    get wakeAt(): number | null;
+    /** Reminder message delivered when the current self-wake fires, or `null` when none is set. */
+    get message(): string | null;
+    now(): number;
+    /** Restores the persisted alarm state. */
+    load(): Effect.Effect<void>;
+    /** Records a new self-wake target (with an optional reminder message) and persists it. */
+    setWakeAt(wakeAt: number, message?: string | null): Effect.Effect<void>;
+    /**
+     * Clears the self-wake alarm if it is due, returning the timestamp it was scheduled for and the
+     * reminder message it carried (or `null` if no alarm was due).
+     */
+    takeFiredAlarm(): Effect.Effect<{
+        firedAt: number;
+        message: string | null;
+    } | null>;
+    /**
+     * Reconciles the process alarm timer with pending work and the tracked self-wake, scheduling the
+     * earliest of the two. Does nothing when there is neither pending work nor a self-wake.
+     */
+    reconcile(hasPendingWork: boolean): void;
+}
+export {};
+//# sourceMappingURL=agent-process.d.ts.map

package/dist/types/src/agent-service/agent-process.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-process.d.ts","sourceRoot":"","sources":["../../../../src/agent-service/agent-process.ts"],"names":[],"mappings":"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"}

package/dist/types/src/agent-service/agent-process.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=agent-process.test.d.ts.map

package/dist/types/src/agent-service/agent-process.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-process.test.d.ts","sourceRoot":"","sources":["../../../../src/agent-service/agent-process.test.ts"],"names":[],"mappings":""}

package/dist/types/src/agent-service/delegation-strategy.d.ts

@@ -0,0 +1,47 @@
+import type * as Effect from 'effect/Effect';
+import type * as Exit from 'effect/Exit';
+import { type Process } from '@dxos/compute';
+import { type ProcessManager } from '@dxos/compute-runtime';
+import { type Database, type Feed } from '@dxos/echo';
+/**
+ * A unit of work the supervisor delegates to a linked child process. `spawn` is an existential over
+ * the child operation's input/output types: the strategy constructs it (e.g. via `invokeFiber`)
+ * so {@link AgentProcess} can remain agnostic to the operation type and just track the returned pid.
+ */
+export interface Delegation {
+    /**
+     * Stable id correlating this delegation with its completion (e.g. a plan task id).
+     */
+    readonly id: string;
+    /**
+     * Spawns the child for this delegation and returns its process id. Must be linked (non-blocking)
+     * so the child's exit wakes the supervisor's `onChildEvent` — i.e. `ProcessOperationInvoker.invokeFiber`.
+     */
+    readonly spawn: Effect.Effect<Process.ID, never, ProcessManager.ProcessOperationInvoker.Service>;
+}
+/**
+ * Services the strategy callbacks may use. The hosting {@link AgentProcess} provides these.
+ */
+export type StrategyServices = Database.Service;
+/**
+ * Turns a conversational agent process into a supervisor: after each turn it reconciles outstanding
+ * work into linked child processes, and folds their results back into the conversation on completion.
+ *
+ * Implemented outside `@dxos/functions-runtime` (which cannot depend on the agent/plan types)
+ * and passed to {@link AgentService.layer} so {@link AgentProcess} stays generic.
+ * Absent by default — a plain conversational agent.
+ */
+export interface DelegationStrategy {
+    /**
+     * Called after each agent turn. Returns delegations for outstanding work not already in flight.
+     * @param feed - The conversation feed (identifies which agent/plan to reconcile).
+     * @param activeIds - Ids of delegations already running, so reconcile does not double-spawn.
+     */
+    readonly reconcile: (feed: Feed.Feed, activeIds: ReadonlySet<string>) => Effect.Effect<readonly Delegation[], never, StrategyServices>;
+    /**
+     * Called when a delegated child completes. Use to record the result and notify the user (e.g.
+     * update the plan task status and append a message to the conversation feed).
+     */
+    readonly onComplete: (feed: Feed.Feed, id: string, exit: Exit.Exit<unknown>) => Effect.Effect<void, never, StrategyServices>;
+}
+//# sourceMappingURL=delegation-strategy.d.ts.map

package/dist/types/src/agent-service/delegation-strategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delegation-strategy.d.ts","sourceRoot":"","sources":["../../../../src/agent-service/delegation-strategy.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,KAAK,MAAM,MAAM,eAAe,CAAC;AAC7C,OAAO,KAAK,KAAK,IAAI,MAAM,aAAa,CAAC;AAEzC,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,eAAe,CAAC;AAC7C,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,IAAI,EAAE,MAAM,YAAY,CAAC;AAEtD;;;;GAIG;AACH,MAAM,WAAW,UAAU;IACzB;;OAEG;IACH,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IAEpB;;;OAGG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,EAAE,KAAK,EAAE,cAAc,CAAC,uBAAuB,CAAC,OAAO,CAAC,CAAC;CAClG;AAED;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG,QAAQ,CAAC,OAAO,CAAC;AAEhD;;;;;;;GAOG;AACH,MAAM,WAAW,kBAAkB;IACjC;;;;OAIG;IACH,QAAQ,CAAC,SAAS,EAAE,CAClB,IAAI,EAAE,IAAI,CAAC,IAAI,EACf,SAAS,EAAE,WAAW,CAAC,MAAM,CAAC,KAC3B,MAAM,CAAC,MAAM,CAAC,SAAS,UAAU,EAAE,EAAE,KAAK,EAAE,gBAAgB,CAAC,CAAC;IAEnE;;;OAGG;IACH,QAAQ,CAAC,UAAU,EAAE,CACnB,IAAI,EAAE,IAAI,CAAC,IAAI,EACf,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,KACrB,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,EAAE,gBAAgB,CAAC,CAAC;CACnD"}

package/dist/types/src/agent-service/index.d.ts

@@ -0,0 +1,4 @@
+export * as AgentService from './AgentService';
+export { AGENT_PROCESS_KEY } from './agent-process';
+export { type Delegation, type DelegationStrategy } from './delegation-strategy';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/src/agent-service/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/agent-service/index.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,YAAY,MAAM,gBAAgB,CAAC;AAC/C,OAAO,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AACpD,OAAO,EAAE,KAAK,UAAU,EAAE,KAAK,kBAAkB,EAAE,MAAM,uBAAuB,CAAC"}

package/dist/types/src/assistant-session-tests/format.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=format.test.d.ts.map

package/dist/types/src/assistant-session-tests/format.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format.test.d.ts","sourceRoot":"","sources":["../../../../src/assistant-session-tests/format.test.ts"],"names":[],"mappings":""}

package/dist/types/src/assistant-session-tests/request.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=request.test.d.ts.map

package/dist/types/src/assistant-session-tests/request.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request.test.d.ts","sourceRoot":"","sources":["../../../../src/assistant-session-tests/request.test.ts"],"names":[],"mappings":""}

package/dist/types/src/assistant-session-tests/session-ollama.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=session-ollama.test.d.ts.map

package/dist/types/src/assistant-session-tests/session-ollama.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-ollama.test.d.ts","sourceRoot":"","sources":["../../../../src/assistant-session-tests/session-ollama.test.ts"],"names":[],"mappings":""}

package/dist/types/src/assistant-session-tests/session.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=session.test.d.ts.map

package/dist/types/src/assistant-session-tests/session.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.test.d.ts","sourceRoot":"","sources":["../../../../src/assistant-session-tests/session.test.ts"],"names":[],"mappings":""}

package/dist/types/src/assistant-session-tests/xml-response.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=xml-response.test.d.ts.map

package/dist/types/src/assistant-session-tests/xml-response.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"xml-response.test.d.ts","sourceRoot":"","sources":["../../../../src/assistant-session-tests/xml-response.test.ts"],"names":[],"mappings":""}

package/dist/types/src/functions.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=functions.test.d.ts.map

package/dist/types/src/functions.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"functions.test.d.ts","sourceRoot":"","sources":["../../../src/functions.test.ts"],"names":[],"mappings":""}

package/dist/types/src/index.d.ts

@@ -0,0 +1,2 @@
+export * from './agent-service';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":"AAMA,cAAc,iBAAiB,CAAC"}