@relayfx/sdk 0.3.6 → 0.4.0

package/dist/types/relay/client.d.ts

@@ -1 +1,118 @@
-export * from "./client-public";
+import { getAgentDefinition, getSkillDefinition, listAgentDefinitionRevisions, listAgentDefinitions, listSkillDefinitionRevisions, listSkillDefinitions, registerAgent, registerAgentDefinition } from "./client-public-agents";
+import { cancelChildFanOut, createChildFanOut, inspectChildFanOut, spawnChildRun } from "./client-public-child-runs";
+import { ackEnvelopeReady, claimEnvelopeReady, releaseEnvelopeReady } from "./client-public-envelope-ready";
+import { cancelExecution, followExecution, getExecution, getSession, inspectExecution, listExecutions, listRunners, listSessions, listWaits, pageExecutionEvents, replayExecution, routeExecution, startExecution, startExecutionByAddress, startExecutionByAgentDefinition, steer, streamExecution, streamSession, watchExecutions } from "./client-public-executions";
+import { awaitWait, getAddressBookRoute, getPresence, listAddressBookRoutes, listInboxMessages, listTopicSubscriptions, publishTopic, registerAddressBookRoute, send, submitInboundEnvelope, subscribeTopic, unsubscribeTopic, wake, watchPresence } from "./client-public-messaging";
+import { askResident, deleteResidentState, destroyResident, getResident, getResidentState, listResidents, listResidentState, putResidentState, registerResidentKind, spawnResident } from "./client-public-residents";
+import { cancelSchedule, createSchedule, listSchedules } from "./client-public-schedules";
+import { claimToolWork, completeToolWork, fulfillToolCall, listPendingApprovals, listPendingToolCalls, listToolAttempts, releaseToolWork, resolvePermission, resolveToolApproval } from "./client-public-tools";
+import { cancelWorkflowRun, getWorkflowDefinitionRevision, inspectWorkflowRun, listWorkflowDefinitionRevisions, registerWorkflowDefinition, replayWorkflowRun, startWorkflowRun } from "./client-public-workflows";
+export { ClientError, EventLogCursorNotFound, ExecutionNotFound, followExecutionFrom, ResidentNamespaceReserved, Service, StateVersionConflict, WaitKindMismatch, } from "./client-public";
+export type { AskResidentInput, FollowExecutionDependencies, Identifier, Interface, RegisterAgent, RegisterAgentInput, RegisterBatonAgentInput, RegisterDefinedAgentInput, StartExecutionByAddressInput, StartExecutionByAgentDefinitionInput, } from "./client-public";
+export declare const executions: {
+    start: typeof startExecution;
+    startByAddress: typeof startExecutionByAddress;
+    startByAgentDefinition: typeof startExecutionByAgentDefinition;
+    cancel: typeof cancelExecution;
+    get: typeof getExecution;
+    list: typeof listExecutions;
+    replay: typeof replayExecution;
+    pageEvents: typeof pageExecutionEvents;
+    inspect: typeof inspectExecution;
+    route: typeof routeExecution;
+    steer: typeof steer;
+    stream: typeof streamExecution;
+    follow: typeof followExecution;
+    watch: typeof watchExecutions;
+};
+export declare const residents: {
+    spawn: typeof spawnResident;
+    get: typeof getResident;
+    destroy: typeof destroyResident;
+    list: typeof listResidents;
+    ask: typeof askResident;
+    registerKind: typeof registerResidentKind;
+    getState: typeof getResidentState;
+    putState: typeof putResidentState;
+    deleteState: typeof deleteResidentState;
+    listState: typeof listResidentState;
+};
+export declare const agents: {
+    register: typeof registerAgent;
+    registerDefinition: typeof registerAgentDefinition;
+    getDefinition: typeof getAgentDefinition;
+    listDefinitions: typeof listAgentDefinitions;
+    listDefinitionRevisions: typeof listAgentDefinitionRevisions;
+};
+export declare const skills: {
+    getDefinition: typeof getSkillDefinition;
+    listDefinitions: typeof listSkillDefinitions;
+    listDefinitionRevisions: typeof listSkillDefinitionRevisions;
+};
+export declare const sessions: {
+    get: typeof getSession;
+    list: typeof listSessions;
+    stream: typeof streamSession;
+};
+export declare const waits: {
+    list: typeof listWaits;
+    await: typeof awaitWait;
+    wake: typeof wake;
+};
+export declare const envelopes: {
+    send: typeof send;
+    submitInbound: typeof submitInboundEnvelope;
+    listInbox: typeof listInboxMessages;
+    claimReady: typeof claimEnvelopeReady;
+    ackReady: typeof ackEnvelopeReady;
+    releaseReady: typeof releaseEnvelopeReady;
+};
+export declare const tools: {
+    listPending: typeof listPendingToolCalls;
+    fulfill: typeof fulfillToolCall;
+    claimWork: typeof claimToolWork;
+    completeWork: typeof completeToolWork;
+    releaseWork: typeof releaseToolWork;
+    listAttempts: typeof listToolAttempts;
+    listPendingApprovals: typeof listPendingApprovals;
+    resolveApproval: typeof resolveToolApproval;
+    resolvePermission: typeof resolvePermission;
+};
+export declare const topics: {
+    subscribe: typeof subscribeTopic;
+    unsubscribe: typeof unsubscribeTopic;
+    publish: typeof publishTopic;
+    listSubscriptions: typeof listTopicSubscriptions;
+};
+export declare const childRuns: {
+    spawn: typeof spawnChildRun;
+    createFanOut: typeof createChildFanOut;
+    cancelFanOut: typeof cancelChildFanOut;
+    inspectFanOut: typeof inspectChildFanOut;
+};
+export declare const schedules: {
+    create: typeof createSchedule;
+    cancel: typeof cancelSchedule;
+    list: typeof listSchedules;
+};
+export declare const workflows: {
+    registerDefinition: typeof registerWorkflowDefinition;
+    getDefinitionRevision: typeof getWorkflowDefinitionRevision;
+    listDefinitionRevisions: typeof listWorkflowDefinitionRevisions;
+    startRun: typeof startWorkflowRun;
+    cancelRun: typeof cancelWorkflowRun;
+    replayRun: typeof replayWorkflowRun;
+    inspectRun: typeof inspectWorkflowRun;
+};
+export declare const addressBook: {
+    register: typeof registerAddressBookRoute;
+    get: typeof getAddressBookRoute;
+    list: typeof listAddressBookRoutes;
+};
+export declare const presence: {
+    get: typeof getPresence;
+    watch: typeof watchPresence;
+};
+export declare const runners: {
+    list: typeof listRunners;
+};

package/dist/types/relay/command.d.ts

@@ -34,14 +34,14 @@ declare const CommandReplyInvalid_base: Schema.Class<CommandReplyInvalid, Schema
 }>, import("effect/Cause").YieldableError>;
 export declare class CommandReplyInvalid extends CommandReplyInvalid_base {
 }
-declare const EntityNotFound_base: Schema.Class<EntityNotFound, Schema.TaggedStruct<"EntityNotFound", {
-    readonly kind: Schema.brand<Schema.String, "Relay.EntityKindName"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EntityKindName">;
+declare const ResidentNotFound_base: Schema.Class<ResidentNotFound, Schema.TaggedStruct<"ResidentNotFound", {
+    readonly kind: Schema.brand<Schema.String, "Relay.ResidentKindName"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ResidentKindName">;
     };
-    readonly key: Schema.brand<Schema.String, "Relay.EntityKey"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EntityKey">;
+    readonly key: Schema.brand<Schema.String, "Relay.ResidentKey"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ResidentKey">;
     };
 }>, import("effect/Cause").YieldableError>;
-export declare class EntityNotFound extends EntityNotFound_base {
+export declare class ResidentNotFound extends ResidentNotFound_base {
 }
 export {};

package/dist/types/relay/http-server.d.ts

@@ -1,9 +1,9 @@
-import type { Agent, Entity, Envelope, Execution, Ids, Inbox, Presence, Shared, State } from "../schema/index";
+import type { Agent, Resident, Envelope, Execution, Ids, Inbox, Presence, Shared, State } from "../schema/index";
 export { StateVersionConflict } from "./state-version-conflict";
 import type { StateVersionConflict } from "./state-version-conflict";
 import { Context } from "effect";
 import type { Effect, Scope, Stream } from "effect";
-import type { CancelExecutionAccepted, CancelExecutionInput, ClaimToolWorkInput, CompleteToolWorkInput, DeleteEntityStateInput, DestroyEntityInput, ExecutionInspection, ExecutionListChange, FulfillToolCallInput, GetEntityInput, GetEntityStateInput, GetOrCreateEntityInput, ListEntitiesInput, ListExecutionsInput, ListExecutionsResult, ListInboxMessagesInput, ListPendingToolCallsInput, ListEntityStateInput, ListToolAttemptsInput, ListWaitsInput, PendingToolCallList, PutEntityStateInput, ReleaseToolWorkInput, ResolvePermissionInput, SessionStreamItem, SpawnChildRunInput, StartExecutionResult, SteerAccepted, SteerInput, StreamExecutionInput, StreamSessionInput, ToolAttemptList, ToolOutcomeAccepted, ToolWorkLease, ToolWorkReleased, WaitView, WakeAccepted, WakeInput, WatchExecutionsInput } from "./operation";
+import type { CancelExecutionAccepted, CancelExecutionInput, ClaimToolWorkInput, CompleteToolWorkInput, DeleteResidentStateInput, DestroyResidentInput, ExecutionInspection, ExecutionListChange, FulfillToolCallInput, GetResidentInput, GetResidentStateInput, ListResidentsInput, ListExecutionsInput, ListExecutionsResult, ListInboxMessagesInput, ListPendingToolCallsInput, ListResidentStateInput, ListToolAttemptsInput, ListWaitsInput, PendingToolCallList, PutResidentStateInput, ReleaseToolWorkInput, ResolvePermissionInput, SessionStreamItem, SpawnResidentInput, SpawnChildRunInput, StartExecutionResult, SteerAccepted, SteerInput, StreamExecutionInput, StreamSessionInput, ToolAttemptList, ToolOutcomeAccepted, ToolWorkLease, ToolWorkReleased, WaitView, WakeAccepted, WakeInput, WatchExecutionsInput } from "./operation";
 export interface ClientError {
     readonly _tag: "ClientError";
     readonly message: string;
@@ -17,8 +17,8 @@ export interface ExecutionNotFound {
     readonly _tag: "ExecutionNotFound";
     readonly execution_id: Ids.ExecutionId;
 }
-export interface EntityNamespaceReserved {
-    readonly _tag: "EntityNamespaceReserved";
+export interface ResidentNamespaceReserved {
+    readonly _tag: "ResidentNamespaceReserved";
     readonly id: string;
     readonly message: string;
 }
@@ -42,39 +42,57 @@ export interface StartExecutionByAddressInput {
     readonly metadata?: Shared.Metadata;
 }
 export interface ClientInterface {
-    readonly listAgentDefinitions: (_?: void) => Effect.Effect<Agent.DefinitionList, ClientError>;
-    readonly registerAgentDefinition: (input: Agent.RegisterDefinitionPayload) => Effect.Effect<Agent.DefinitionRegistered, ClientError>;
-    readonly startExecutionByAddress: (input: StartExecutionByAddressInput) => Effect.Effect<StartExecutionResult, EntityNamespaceReserved | ClientError>;
-    readonly cancelExecution: (input: CancelExecutionInput) => Effect.Effect<CancelExecutionAccepted, ClientError>;
-    readonly steer: (input: SteerInput) => Effect.Effect<SteerAccepted, ClientError>;
-    readonly getExecution: (id: Ids.ExecutionId) => Effect.Effect<Execution.Execution | undefined, ClientError>;
-    readonly inspectExecution: (executionId: Ids.ExecutionId) => Effect.Effect<ExecutionInspection, ExecutionNotFound | ClientError>;
-    readonly listExecutions: (input: ListExecutionsInput) => Effect.Effect<ListExecutionsResult, ClientError>;
-    readonly send: (input: Envelope.SendInput) => Effect.Effect<Envelope.EnvelopeAccepted, ClientError>;
-    readonly listWaits: (input: ListWaitsInput) => Effect.Effect<ReadonlyArray<WaitView>, ClientError>;
-    readonly wake: (input: WakeInput) => Effect.Effect<WakeAccepted, WaitKindMismatch | ClientError>;
-    readonly resolvePermission: (input: ResolvePermissionInput) => Effect.Effect<WakeAccepted, WaitKindMismatch | ClientError>;
-    readonly spawnChildRun: (input: SpawnChildRunInput) => Effect.Effect<Execution.ChildRunAccepted, ClientError>;
-    readonly streamExecution: (input: StreamExecutionInput) => Stream.Stream<Execution.ExecutionEvent, EventLogCursorNotFound | ClientError>;
-    readonly streamSession: (input: StreamSessionInput) => Stream.Stream<SessionStreamItem, EventLogCursorNotFound | ClientError>;
-    readonly watchExecutions: (input: WatchExecutionsInput) => Stream.Stream<ExecutionListChange, ClientError>;
-    readonly getPresence: (scope: Presence.Scope) => Effect.Effect<Presence.View, ClientError>;
-    readonly watchPresence: (scope: Presence.Scope) => Stream.Stream<Presence.View, ClientError>;
-    readonly listPendingToolCalls: (input: ListPendingToolCallsInput) => Effect.Effect<PendingToolCallList, ClientError>;
-    readonly fulfillToolCall: (input: FulfillToolCallInput) => Effect.Effect<ToolOutcomeAccepted, ClientError>;
-    readonly claimToolWork: (input: ClaimToolWorkInput) => Effect.Effect<ToolWorkLease | null, ClientError>;
-    readonly completeToolWork: (input: CompleteToolWorkInput) => Effect.Effect<ToolOutcomeAccepted, ClientError>;
-    readonly releaseToolWork: (input: ReleaseToolWorkInput) => Effect.Effect<ToolWorkReleased, ClientError>;
-    readonly listToolAttempts: (input: ListToolAttemptsInput) => Effect.Effect<ToolAttemptList, ClientError>;
-    readonly getOrCreateEntity: (input: GetOrCreateEntityInput) => Effect.Effect<Entity.Instance, ClientError>;
-    readonly listEntities: (input: ListEntitiesInput) => Effect.Effect<ReadonlyArray<Entity.Instance>, ClientError>;
-    readonly getEntity: (input: GetEntityInput) => Effect.Effect<Entity.Instance | undefined, ClientError>;
-    readonly destroyEntity: (input: DestroyEntityInput) => Effect.Effect<Entity.Instance, ClientError>;
-    readonly listInboxMessages: (input: ListInboxMessagesInput) => Effect.Effect<ReadonlyArray<Inbox.Message>, ClientError>;
-    readonly getEntityState: (input: GetEntityStateInput) => Effect.Effect<State.StateRecordView | undefined, ClientError>;
-    readonly putEntityState: (input: PutEntityStateInput) => Effect.Effect<State.StateRecordView, StateVersionConflict | ClientError>;
-    readonly deleteEntityState: (input: DeleteEntityStateInput) => Effect.Effect<State.StateRecordView | undefined, StateVersionConflict | ClientError>;
-    readonly listEntityState: (input: ListEntityStateInput) => Effect.Effect<ReadonlyArray<State.StateRecordView>, ClientError>;
+    readonly agents: {
+        readonly listDefinitions: (_?: void) => Effect.Effect<Agent.DefinitionList, ClientError>;
+        readonly registerDefinition: (input: Agent.RegisterDefinitionPayload) => Effect.Effect<Agent.DefinitionRegistered, ClientError>;
+    };
+    readonly executions: {
+        readonly startByAddress: (input: StartExecutionByAddressInput) => Effect.Effect<StartExecutionResult, ResidentNamespaceReserved | ClientError>;
+        readonly cancel: (input: CancelExecutionInput) => Effect.Effect<CancelExecutionAccepted, ClientError>;
+        readonly steer: (input: SteerInput) => Effect.Effect<SteerAccepted, ClientError>;
+        readonly get: (id: Ids.ExecutionId) => Effect.Effect<Execution.Execution | undefined, ClientError>;
+        readonly inspect: (executionId: Ids.ExecutionId) => Effect.Effect<ExecutionInspection, ExecutionNotFound | ClientError>;
+        readonly list: (input: ListExecutionsInput) => Effect.Effect<ListExecutionsResult, ClientError>;
+        readonly stream: (input: StreamExecutionInput) => Stream.Stream<Execution.ExecutionEvent, EventLogCursorNotFound | ClientError>;
+        readonly watch: (input: WatchExecutionsInput) => Stream.Stream<ExecutionListChange, ClientError>;
+    };
+    readonly envelopes: {
+        readonly send: (input: Envelope.SendInput) => Effect.Effect<Envelope.EnvelopeAccepted, ClientError>;
+        readonly listInbox: (input: ListInboxMessagesInput) => Effect.Effect<ReadonlyArray<Inbox.Message>, ClientError>;
+    };
+    readonly waits: {
+        readonly list: (input: ListWaitsInput) => Effect.Effect<ReadonlyArray<WaitView>, ClientError>;
+        readonly wake: (input: WakeInput) => Effect.Effect<WakeAccepted, WaitKindMismatch | ClientError>;
+    };
+    readonly tools: {
+        readonly resolvePermission: (input: ResolvePermissionInput) => Effect.Effect<WakeAccepted, WaitKindMismatch | ClientError>;
+        readonly listPending: (input: ListPendingToolCallsInput) => Effect.Effect<PendingToolCallList, ClientError>;
+        readonly fulfill: (input: FulfillToolCallInput) => Effect.Effect<ToolOutcomeAccepted, ClientError>;
+        readonly claimWork: (input: ClaimToolWorkInput) => Effect.Effect<ToolWorkLease | null, ClientError>;
+        readonly completeWork: (input: CompleteToolWorkInput) => Effect.Effect<ToolOutcomeAccepted, ClientError>;
+        readonly releaseWork: (input: ReleaseToolWorkInput) => Effect.Effect<ToolWorkReleased, ClientError>;
+        readonly listAttempts: (input: ListToolAttemptsInput) => Effect.Effect<ToolAttemptList, ClientError>;
+    };
+    readonly childRuns: {
+        readonly spawn: (input: SpawnChildRunInput) => Effect.Effect<Execution.ChildRunAccepted, ClientError>;
+    };
+    readonly sessions: {
+        readonly stream: (input: StreamSessionInput) => Stream.Stream<SessionStreamItem, EventLogCursorNotFound | ClientError>;
+    };
+    readonly presence: {
+        readonly get: (scope: Presence.Scope) => Effect.Effect<Presence.View, ClientError>;
+        readonly watch: (scope: Presence.Scope) => Stream.Stream<Presence.View, ClientError>;
+    };
+    readonly residents: {
+        readonly spawn: (input: SpawnResidentInput) => Effect.Effect<Resident.Instance, ClientError>;
+        readonly list: (input: ListResidentsInput) => Effect.Effect<ReadonlyArray<Resident.Instance>, ClientError>;
+        readonly get: (input: GetResidentInput) => Effect.Effect<Resident.Instance | undefined, ClientError>;
+        readonly destroy: (input: DestroyResidentInput) => Effect.Effect<Resident.Instance, ClientError>;
+        readonly getState: (input: GetResidentStateInput) => Effect.Effect<State.StateRecordView | undefined, ClientError>;
+        readonly putState: (input: PutResidentStateInput) => Effect.Effect<State.StateRecordView, StateVersionConflict | ClientError>;
+        readonly deleteState: (input: DeleteResidentStateInput) => Effect.Effect<State.StateRecordView | undefined, StateVersionConflict | ClientError>;
+        readonly listState: (input: ListResidentStateInput) => Effect.Effect<ReadonlyArray<State.StateRecordView>, ClientError>;
+    };
 }
 export interface PresenceInterface {
     readonly register: (input: {

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

@@ -1,5 +1,4 @@
 import * as AdapterOutboxModule from "./adapter-outbox";
-import * as ClientModule from "./client-public";
 import * as ChildFanOutHostModule from "./child-fan-out-host";
 import * as CommandModule from "./command";
 import * as OperationModule from "./operation";
@@ -7,7 +6,7 @@ import * as ToolWorkerModule from "./tool-worker";
 import * as RuntimeModule from "./runtime";
 import * as WorkflowDefinitionHostModule from "./workflow-definition-host";
 import { DatabaseIdentity, makeDatabaseIdentity } from "./database-identity";
-import { Address, Agent, ChildOrchestration, Content, Entity, Envelope, Execution, Ids, Inbox, Pagination, Presence, Schedule, Shared, Skill, State, Tool, Waits, Workflow } from "../schema/index";
+import { Address, Agent, ChildOrchestration, Content, Resident, Envelope, Execution, Ids, Inbox, Pagination, Presence, Schedule, Shared, Skill, State, Tool, Waits, Workflow } from "../schema/index";
 import * as ArtifactStoreModule from "../runtime/content/artifact-store-service";
 import * as BlobStoreModule from "../runtime/content/blob-store-service";
 import * as EmbeddingModelServiceModule from "../runtime/model/embedding-model-service";
@@ -18,7 +17,7 @@ import * as SchemaRegistryModule from "../runtime/schema-registry/schema-registr
 import * as ToolRuntimeModule from "./tool-runtime";
 import * as LanguageModelRegistrationModule from "./language-model-registration";
 export import AdapterOutbox = AdapterOutboxModule;
-export import Client = ClientModule;
+export * as Client from "./client";
 export import ChildFanOutHost = ChildFanOutHostModule;
 export import Command = CommandModule;
 export import Operation = OperationModule;
@@ -34,4 +33,4 @@ export import PromptAssembler = PromptAssemblerModule;
 export import SchemaRegistry = SchemaRegistryModule;
 export import ToolRuntime = ToolRuntimeModule;
 export import LanguageModelRegistration = LanguageModelRegistrationModule;
-export { Address, Agent, ChildOrchestration, Content, DatabaseIdentity, Entity, Envelope, Execution, Ids, Inbox, Pagination, Presence, Schedule, Shared, Skill, State, Tool, Waits, Workflow, makeDatabaseIdentity, };
+export { Address, Agent, ChildOrchestration, Content, DatabaseIdentity, Resident, Envelope, Execution, Ids, Inbox, Pagination, Presence, Schedule, Shared, Skill, State, Tool, Waits, Workflow, makeDatabaseIdentity, };

package/dist/types/relay/internal-client.d.ts

@@ -1,8 +1,8 @@
 import { Service as AddressBookService } from "../runtime/address/address-book-service";
 import { Service as AgentRegistryService } from "../runtime/agent/agent-registry-service";
 import { Service as EnvelopeServiceService } from "../runtime/envelope/envelope-service";
-import { Service as EntityInstanceServiceService } from "../runtime/entity/entity-instance-service";
-import { Service as EntityRegistryService } from "../runtime/entity/entity-registry-service";
+import { Service as ResidentInstanceServiceService } from "../runtime/resident/resident-instance-service";
+import { Service as ResidentRegistryService } from "../runtime/resident/resident-registry-service";
 import { Service as EventLogService } from "../runtime/execution/event-log-service";
 import { Service as ExecutionServiceService } from "../runtime/execution/execution-service";
 import { Service as ExecutionWatchService } from "../runtime/execution/execution-watch-service";
@@ -16,7 +16,7 @@ import { Service as WaitServiceService } from "../runtime/wait/wait-service";
 import { ChildExecutionRepository, ChildFanOutRepository, ClusterRegistryRepository, EnvelopeRepository, ExecutionRepository, InboxRepository, ScheduleRepository, SessionRepository, SteeringRepository, ToolCallRepository, WorkflowDefinitionRepository } from "../store-sql/portable";
 import { Layer } from "effect";
 import { Sharding, ShardingConfig } from "effect/unstable/cluster";
-import { Service, type Interface } from "./client-public";
-export type RuntimeRequirements = AgentRegistryService | EntityRegistryService | EntityInstanceServiceService | AddressBookService | ExecutionServiceService | EnvelopeServiceService | WaitServiceService | EventLogService | SessionStreamService | ExecutionWatchService | ExecutionStateService | PresenceServiceService | EnvelopeRepository.Service | ExecutionRepository.Service | InboxRepository.Service | TopicServiceService | ToolCallRepository.Service | ChildExecutionRepository.Service | ChildFanOutRepository.Service | SessionRepository.Service | SteeringRepository.Service | ClusterRegistryRepository.Service | ScheduleRepository.Service | SkillRegistryService | ToolTransitionCoordinatorService | WorkflowDefinitionRepository.Service | Sharding.Sharding | ShardingConfig.ShardingConfig;
+import { Service, type FlatInterface } from "./client-public";
+export type RuntimeRequirements = AgentRegistryService | ResidentRegistryService | ResidentInstanceServiceService | AddressBookService | ExecutionServiceService | EnvelopeServiceService | WaitServiceService | EventLogService | SessionStreamService | ExecutionWatchService | ExecutionStateService | PresenceServiceService | EnvelopeRepository.Service | ExecutionRepository.Service | InboxRepository.Service | TopicServiceService | ToolCallRepository.Service | ChildExecutionRepository.Service | ChildFanOutRepository.Service | SessionRepository.Service | SteeringRepository.Service | ClusterRegistryRepository.Service | ScheduleRepository.Service | SkillRegistryService | ToolTransitionCoordinatorService | WorkflowDefinitionRepository.Service | Sharding.Sharding | ShardingConfig.ShardingConfig;
 export declare const layerFromRuntime: Layer.Layer<Service, never, RuntimeRequirements>;
-export declare const testLayer: (implementation: Omit<Interface, "registerWorkflowDefinition" | "getWorkflowDefinitionRevision" | "listWorkflowDefinitionRevisions" | "startWorkflowRun" | "inspectWorkflowRun" | "replayWorkflowRun" | "cancelWorkflowRun" | "streamSession" | "watchExecutions" | "getPresence" | "watchPresence" | "registerEntityKind" | "getOrCreateEntity" | "getEntity" | "destroyEntity" | "listEntities" | "followExecution" | "pageExecutionEvents"> & Partial<Interface>) => Layer.Layer<Service, never, never>;
+export declare const testLayer: (implementation: Omit<FlatInterface, "registerWorkflowDefinition" | "getWorkflowDefinitionRevision" | "listWorkflowDefinitionRevisions" | "startWorkflowRun" | "inspectWorkflowRun" | "replayWorkflowRun" | "cancelWorkflowRun" | "streamSession" | "watchExecutions" | "getPresence" | "watchPresence" | "registerResidentKind" | "spawnResident" | "getResident" | "destroyResident" | "listResidents" | "followExecution" | "pageExecutionEvents"> & Partial<FlatInterface>) => Layer.Layer<Service, never, never>;

package/dist/types/relay/mysql-migrations.d.ts

@@ -1 +1 @@
-export declare const migrations: readonly [readonly [1, "baseline", string], readonly [2, "durable_tool_placement", string], readonly [3, "durable_inbox", string], readonly [4, "execution_state", string], readonly [5, "durable_entities", string], readonly [6, "ephemeral_presence", string], readonly [7, "topic_subscriptions", string], readonly [8, "child_fan_out", string], readonly [9, "workflow_definitions", string], readonly [10, "workflow_runtime", string]];
+export declare const migrations: readonly [readonly [1, "baseline", string], readonly [2, "durable_tool_placement", string], readonly [3, "durable_inbox", string], readonly [4, "execution_state", string], readonly [5, "durable_entities", string], readonly [6, "ephemeral_presence", string], readonly [7, "topic_subscriptions", string], readonly [8, "child_fan_out", string], readonly [9, "workflow_definitions", string], readonly [10, "workflow_runtime", string], readonly [11, "execution_scoped_tool_calls", string], readonly [12, "rename_entity_to_resident", string]];

package/dist/types/relay/operation.d.ts

@@ -98,6 +98,9 @@ export declare const StartExecutionInput: Schema.Struct<{
             readonly fallback?: "allow" | "ask" | "deny";
         };
         readonly turn_policy?: Agent.TurnPolicySnapshot;
+        readonly tool_execution?: Schema.Struct.ReadonlySide<{
+            readonly concurrency: Schema.Finite;
+        }, "Encoded">;
         readonly compaction_policy?: {
             readonly context_window: number;
             readonly reserve_tokens: number;
@@ -185,12 +188,12 @@ export declare const StartExecutionResult: Schema.Struct<{
 }>;
 export interface StartExecutionResult extends Schema.Schema.Type<typeof StartExecutionResult> {
 }
-export declare const GetOrCreateEntityInput: Schema.Struct<{
-    readonly kind: Schema.brand<Schema.String, "Relay.EntityKindName"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EntityKindName">;
+export declare const SpawnResidentInput: Schema.Struct<{
+    readonly kind: Schema.brand<Schema.String, "Relay.ResidentKindName"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ResidentKindName">;
     };
-    readonly key: Schema.brand<Schema.String, "Relay.EntityKey"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EntityKey">;
+    readonly key: Schema.brand<Schema.String, "Relay.ResidentKey"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ResidentKey">;
     };
     readonly input: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
         readonly type: Schema.Literal<"text">;
@@ -244,48 +247,48 @@ export declare const GetOrCreateEntityInput: Schema.Struct<{
     readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
     readonly created_at: Schema.Int;
 }>;
-export interface GetOrCreateEntityInput extends Schema.Schema.Type<typeof GetOrCreateEntityInput> {
+export interface SpawnResidentInput extends Schema.Schema.Type<typeof SpawnResidentInput> {
 }
-export declare const GetEntityInput: Schema.Struct<{
-    readonly kind: Schema.brand<Schema.String, "Relay.EntityKindName"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EntityKindName">;
+export declare const GetResidentInput: Schema.Struct<{
+    readonly kind: Schema.brand<Schema.String, "Relay.ResidentKindName"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ResidentKindName">;
     };
-    readonly key: Schema.brand<Schema.String, "Relay.EntityKey"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EntityKey">;
+    readonly key: Schema.brand<Schema.String, "Relay.ResidentKey"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ResidentKey">;
     };
 }>;
-export interface GetEntityInput extends Schema.Schema.Type<typeof GetEntityInput> {
+export interface GetResidentInput extends Schema.Schema.Type<typeof GetResidentInput> {
 }
-export declare const DestroyEntityInput: Schema.Struct<{
-    readonly kind: Schema.brand<Schema.String, "Relay.EntityKindName"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EntityKindName">;
+export declare const DestroyResidentInput: Schema.Struct<{
+    readonly kind: Schema.brand<Schema.String, "Relay.ResidentKindName"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ResidentKindName">;
     };
-    readonly key: Schema.brand<Schema.String, "Relay.EntityKey"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EntityKey">;
+    readonly key: Schema.brand<Schema.String, "Relay.ResidentKey"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ResidentKey">;
     };
     readonly reason: Schema.optionalKey<Schema.String>;
     readonly destroyed_at: Schema.Int;
 }>;
-export interface DestroyEntityInput extends Schema.Schema.Type<typeof DestroyEntityInput> {
+export interface DestroyResidentInput extends Schema.Schema.Type<typeof DestroyResidentInput> {
 }
-export declare const ListEntitiesInput: Schema.Struct<{
-    readonly kind: Schema.optionalKey<Schema.brand<Schema.String, "Relay.EntityKindName"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EntityKindName">;
+export declare const ListResidentsInput: Schema.Struct<{
+    readonly kind: Schema.optionalKey<Schema.brand<Schema.String, "Relay.ResidentKindName"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ResidentKindName">;
     }>;
-    readonly after_kind: Schema.optionalKey<Schema.brand<Schema.String, "Relay.EntityKindName"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EntityKindName">;
+    readonly after_kind: Schema.optionalKey<Schema.brand<Schema.String, "Relay.ResidentKindName"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ResidentKindName">;
     }>;
     readonly after_key: Schema.optionalKey<Schema.String>;
     readonly limit: Schema.optionalKey<Schema.Int>;
 }>;
-export interface ListEntitiesInput extends Schema.Schema.Type<typeof ListEntitiesInput> {
+export interface ListResidentsInput extends Schema.Schema.Type<typeof ListResidentsInput> {
 }
-export declare const EntityInstance: Schema.Struct<{
-    readonly kind: Schema.brand<Schema.String, "Relay.EntityKindName"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EntityKindName">;
+export declare const ResidentInstance: Schema.Struct<{
+    readonly kind: Schema.brand<Schema.String, "Relay.ResidentKindName"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ResidentKindName">;
     };
-    readonly key: Schema.brand<Schema.String, "Relay.EntityKey"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EntityKey">;
+    readonly key: Schema.brand<Schema.String, "Relay.ResidentKey"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ResidentKey">;
     };
     readonly address_id: Schema.brand<Schema.String, "Relay.AddressId"> & {
         make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
@@ -307,15 +310,15 @@ export declare const StreamExecutionInput: Schema.Struct<{
 }>;
 export interface StreamExecutionInput extends Schema.Schema.Type<typeof StreamExecutionInput> {
 }
-export declare const GetEntityStateInput: Schema.Struct<{
+export declare const GetResidentStateInput: Schema.Struct<{
     readonly execution_id: Schema.brand<Schema.String, "Relay.ExecutionId"> & {
         make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
     };
     readonly key: Schema.String;
 }>;
-export interface GetEntityStateInput extends Schema.Schema.Type<typeof GetEntityStateInput> {
+export interface GetResidentStateInput extends Schema.Schema.Type<typeof GetResidentStateInput> {
 }
-export declare const PutEntityStateInput: Schema.Struct<{
+export declare const PutResidentStateInput: Schema.Struct<{
     readonly execution_id: Schema.brand<Schema.String, "Relay.ExecutionId"> & {
         make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
     };
@@ -325,9 +328,9 @@ export declare const PutEntityStateInput: Schema.Struct<{
     readonly idempotency_key: Schema.optionalKey<Schema.String>;
     readonly updated_at: Schema.Int;
 }>;
-export interface PutEntityStateInput extends Schema.Schema.Type<typeof PutEntityStateInput> {
+export interface PutResidentStateInput extends Schema.Schema.Type<typeof PutResidentStateInput> {
 }
-export declare const DeleteEntityStateInput: Schema.Struct<{
+export declare const DeleteResidentStateInput: Schema.Struct<{
     readonly execution_id: Schema.brand<Schema.String, "Relay.ExecutionId"> & {
         make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
     };
@@ -336,9 +339,9 @@ export declare const DeleteEntityStateInput: Schema.Struct<{
     readonly idempotency_key: Schema.optionalKey<Schema.String>;
     readonly removed_at: Schema.Int;
 }>;
-export interface DeleteEntityStateInput extends Schema.Schema.Type<typeof DeleteEntityStateInput> {
+export interface DeleteResidentStateInput extends Schema.Schema.Type<typeof DeleteResidentStateInput> {
 }
-export declare const ListEntityStateInput: Schema.Struct<{
+export declare const ListResidentStateInput: Schema.Struct<{
     readonly execution_id: Schema.brand<Schema.String, "Relay.ExecutionId"> & {
         make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
     };
@@ -346,7 +349,7 @@ export declare const ListEntityStateInput: Schema.Struct<{
     readonly after_key: Schema.optionalKey<Schema.String>;
     readonly limit: Schema.optionalKey<Schema.Int>;
 }>;
-export interface ListEntityStateInput extends Schema.Schema.Type<typeof ListEntityStateInput> {
+export interface ListResidentStateInput extends Schema.Schema.Type<typeof ListResidentStateInput> {
 }
 export declare const WaitTerminalState: Schema.Literals<readonly ["resolved", "timed_out", "cancelled"]>;
 export type WaitTerminalState = typeof WaitTerminalState.Type;
@@ -644,7 +647,7 @@ export declare const FollowExecutionItem: Schema.Union<readonly [Schema.Struct<{
         readonly child_execution_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.ChildExecutionId"> & {
             make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ChildExecutionId">;
         }>;
-        readonly type: Schema.Literals<readonly ["execution.accepted", "execution.started", "execution.completed", "execution.failed", "execution.cancelled", "model.input.prepared", "model.output.delta", "model.reasoning.delta", "model.toolcall.delta", "model.output.completed", "model.usage.reported", "agent.compaction.committed", "budget.exceeded", "tool.call.requested", "tool.result.received", "tool.approval.requested", "tool.approval.resolved", "permission.ask.requested", "permission.ask.resolved", "steering.received", "state.updated", "state.deleted", "inbox.enqueued", "inbox.drained", "entity.created", "entity.destroyed", "envelope.accepted", "envelope.routed", "envelope.ready", "delivery.attempt", "wait.created", "wait.woken", "wait.timed_out", "wait.cancelled", "child_run.spawned", "child_run.event", "child_fan_out.created", "child_fan_out.member.admitted", "child_fan_out.member.terminal", "child_fan_out.terminal", "workspace.lease.planned", "workspace.lease.acquired", "workspace.suspended", "workspace.resumed", "workspace.snapshot.created", "workspace.lease.released", "workspace.lease.failed"]>;
+        readonly type: Schema.Literals<readonly ["execution.accepted", "execution.started", "execution.completed", "execution.failed", "execution.cancelled", "model.input.prepared", "model.output.delta", "model.reasoning.delta", "model.toolcall.delta", "model.output.completed", "model.usage.reported", "agent.compaction.committed", "budget.exceeded", "tool.call.requested", "tool.result.received", "tool.approval.requested", "tool.approval.resolved", "permission.ask.requested", "permission.ask.resolved", "steering.received", "state.updated", "state.deleted", "inbox.enqueued", "inbox.drained", "resident.created", "resident.destroyed", "envelope.accepted", "envelope.routed", "envelope.ready", "delivery.attempt", "wait.created", "wait.woken", "wait.timed_out", "wait.cancelled", "child_run.spawned", "child_run.event", "child_fan_out.created", "child_fan_out.member.admitted", "child_fan_out.member.terminal", "child_fan_out.terminal", "workspace.lease.planned", "workspace.lease.acquired", "workspace.suspended", "workspace.resumed", "workspace.snapshot.created", "workspace.lease.released", "workspace.lease.failed"]>;
         readonly sequence: Schema.Int;
         readonly cursor: Schema.String;
         readonly content: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
@@ -2401,7 +2404,7 @@ export declare const SessionStreamItem: Schema.Union<readonly [Schema.TaggedStru
         readonly child_execution_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.ChildExecutionId"> & {
             make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ChildExecutionId">;
         }>;
-        readonly type: Schema.Literals<readonly ["execution.accepted", "execution.started", "execution.completed", "execution.failed", "execution.cancelled", "model.input.prepared", "model.output.delta", "model.reasoning.delta", "model.toolcall.delta", "model.output.completed", "model.usage.reported", "agent.compaction.committed", "budget.exceeded", "tool.call.requested", "tool.result.received", "tool.approval.requested", "tool.approval.resolved", "permission.ask.requested", "permission.ask.resolved", "steering.received", "state.updated", "state.deleted", "inbox.enqueued", "inbox.drained", "entity.created", "entity.destroyed", "envelope.accepted", "envelope.routed", "envelope.ready", "delivery.attempt", "wait.created", "wait.woken", "wait.timed_out", "wait.cancelled", "child_run.spawned", "child_run.event", "child_fan_out.created", "child_fan_out.member.admitted", "child_fan_out.member.terminal", "child_fan_out.terminal", "workspace.lease.planned", "workspace.lease.acquired", "workspace.suspended", "workspace.resumed", "workspace.snapshot.created", "workspace.lease.released", "workspace.lease.failed"]>;
+        readonly type: Schema.Literals<readonly ["execution.accepted", "execution.started", "execution.completed", "execution.failed", "execution.cancelled", "model.input.prepared", "model.output.delta", "model.reasoning.delta", "model.toolcall.delta", "model.output.completed", "model.usage.reported", "agent.compaction.committed", "budget.exceeded", "tool.call.requested", "tool.result.received", "tool.approval.requested", "tool.approval.resolved", "permission.ask.requested", "permission.ask.resolved", "steering.received", "state.updated", "state.deleted", "inbox.enqueued", "inbox.drained", "resident.created", "resident.destroyed", "envelope.accepted", "envelope.routed", "envelope.ready", "delivery.attempt", "wait.created", "wait.woken", "wait.timed_out", "wait.cancelled", "child_run.spawned", "child_run.event", "child_fan_out.created", "child_fan_out.member.admitted", "child_fan_out.member.terminal", "child_fan_out.terminal", "workspace.lease.planned", "workspace.lease.acquired", "workspace.suspended", "workspace.resumed", "workspace.snapshot.created", "workspace.lease.released", "workspace.lease.failed"]>;
         readonly sequence: Schema.Int;
         readonly cursor: Schema.String;
         readonly content: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
@@ -2712,7 +2715,7 @@ export declare const ReplayExecutionResult: Schema.Struct<{
         readonly child_execution_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.ChildExecutionId"> & {
             make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ChildExecutionId">;
         }>;
-        readonly type: Schema.Literals<readonly ["execution.accepted", "execution.started", "execution.completed", "execution.failed", "execution.cancelled", "model.input.prepared", "model.output.delta", "model.reasoning.delta", "model.toolcall.delta", "model.output.completed", "model.usage.reported", "agent.compaction.committed", "budget.exceeded", "tool.call.requested", "tool.result.received", "tool.approval.requested", "tool.approval.resolved", "permission.ask.requested", "permission.ask.resolved", "steering.received", "state.updated", "state.deleted", "inbox.enqueued", "inbox.drained", "entity.created", "entity.destroyed", "envelope.accepted", "envelope.routed", "envelope.ready", "delivery.attempt", "wait.created", "wait.woken", "wait.timed_out", "wait.cancelled", "child_run.spawned", "child_run.event", "child_fan_out.created", "child_fan_out.member.admitted", "child_fan_out.member.terminal", "child_fan_out.terminal", "workspace.lease.planned", "workspace.lease.acquired", "workspace.suspended", "workspace.resumed", "workspace.snapshot.created", "workspace.lease.released", "workspace.lease.failed"]>;
+        readonly type: Schema.Literals<readonly ["execution.accepted", "execution.started", "execution.completed", "execution.failed", "execution.cancelled", "model.input.prepared", "model.output.delta", "model.reasoning.delta", "model.toolcall.delta", "model.output.completed", "model.usage.reported", "agent.compaction.committed", "budget.exceeded", "tool.call.requested", "tool.result.received", "tool.approval.requested", "tool.approval.resolved", "permission.ask.requested", "permission.ask.resolved", "steering.received", "state.updated", "state.deleted", "inbox.enqueued", "inbox.drained", "resident.created", "resident.destroyed", "envelope.accepted", "envelope.routed", "envelope.ready", "delivery.attempt", "wait.created", "wait.woken", "wait.timed_out", "wait.cancelled", "child_run.spawned", "child_run.event", "child_fan_out.created", "child_fan_out.member.admitted", "child_fan_out.member.terminal", "child_fan_out.terminal", "workspace.lease.planned", "workspace.lease.acquired", "workspace.suspended", "workspace.resumed", "workspace.snapshot.created", "workspace.lease.released", "workspace.lease.failed"]>;
         readonly sequence: Schema.Int;
         readonly cursor: Schema.String;
         readonly content: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
@@ -2794,7 +2797,7 @@ export declare const PageExecutionEventsResult: Schema.Struct<{
         readonly child_execution_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.ChildExecutionId"> & {
             make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ChildExecutionId">;
         }>;
-        readonly type: Schema.Literals<readonly ["execution.accepted", "execution.started", "execution.completed", "execution.failed", "execution.cancelled", "model.input.prepared", "model.output.delta", "model.reasoning.delta", "model.toolcall.delta", "model.output.completed", "model.usage.reported", "agent.compaction.committed", "budget.exceeded", "tool.call.requested", "tool.result.received", "tool.approval.requested", "tool.approval.resolved", "permission.ask.requested", "permission.ask.resolved", "steering.received", "state.updated", "state.deleted", "inbox.enqueued", "inbox.drained", "entity.created", "entity.destroyed", "envelope.accepted", "envelope.routed", "envelope.ready", "delivery.attempt", "wait.created", "wait.woken", "wait.timed_out", "wait.cancelled", "child_run.spawned", "child_run.event", "child_fan_out.created", "child_fan_out.member.admitted", "child_fan_out.member.terminal", "child_fan_out.terminal", "workspace.lease.planned", "workspace.lease.acquired", "workspace.suspended", "workspace.resumed", "workspace.snapshot.created", "workspace.lease.released", "workspace.lease.failed"]>;
+        readonly type: Schema.Literals<readonly ["execution.accepted", "execution.started", "execution.completed", "execution.failed", "execution.cancelled", "model.input.prepared", "model.output.delta", "model.reasoning.delta", "model.toolcall.delta", "model.output.completed", "model.usage.reported", "agent.compaction.committed", "budget.exceeded", "tool.call.requested", "tool.result.received", "tool.approval.requested", "tool.approval.resolved", "permission.ask.requested", "permission.ask.resolved", "steering.received", "state.updated", "state.deleted", "inbox.enqueued", "inbox.drained", "resident.created", "resident.destroyed", "envelope.accepted", "envelope.routed", "envelope.ready", "delivery.attempt", "wait.created", "wait.woken", "wait.timed_out", "wait.cancelled", "child_run.spawned", "child_run.event", "child_fan_out.created", "child_fan_out.member.admitted", "child_fan_out.member.terminal", "child_fan_out.terminal", "workspace.lease.planned", "workspace.lease.acquired", "workspace.suspended", "workspace.resumed", "workspace.snapshot.created", "workspace.lease.released", "workspace.lease.failed"]>;
         readonly sequence: Schema.Int;
         readonly cursor: Schema.String;
         readonly content: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{

package/dist/types/relay/sqlite-migrations.d.ts

@@ -55,5 +55,10 @@ export declare const migrations: readonly [{
     readonly name: "execution_scoped_tool_calls";
     readonly file: "0011_execution_scoped_tool_calls.sql";
     readonly source: string;
+}, {
+    readonly id: 12;
+    readonly name: "rename_entity_to_resident";
+    readonly file: "0012_rename_entity_to_resident.sql";
+    readonly source: string;
 }];
-export declare const loader: Effect.Effect<(readonly [1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11, "baseline" | "child_fan_out" | "durable_entities" | "durable_inbox" | "durable_tool_placement" | "ephemeral_presence" | "execution_scoped_tool_calls" | "execution_state" | "topic_subscriptions" | "workflow_definitions" | "workflow_runtime", Effect.Effect<Effect.Effect<void, import("effect/unstable/sql/SqlError").SqlError, SqlClient>, never, never>])[], never, never>;
+export declare const loader: Effect.Effect<(readonly [1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12, "baseline" | "child_fan_out" | "durable_entities" | "durable_inbox" | "durable_tool_placement" | "ephemeral_presence" | "execution_scoped_tool_calls" | "execution_state" | "rename_entity_to_resident" | "topic_subscriptions" | "workflow_definitions" | "workflow_runtime", Effect.Effect<Effect.Effect<void, import("effect/unstable/sql/SqlError").SqlError, SqlClient>, never, never>])[], never, never>;

package/dist/types/runtime/address/address-resolution-service.d.ts

@@ -86,6 +86,9 @@ export declare const LocalAgentTarget: Schema.Struct<{
             readonly fallback?: "allow" | "ask" | "deny";
         };
         readonly turn_policy?: Agent.TurnPolicySnapshot;
+        readonly tool_execution?: Schema.Struct.ReadonlySide<{
+            readonly concurrency: Schema.Finite;
+        }, "Encoded">;
         readonly compaction_policy?: {
             readonly context_window: number;
             readonly reserve_tokens: number;

package/dist/types/runtime/agent/agent-loop-events.d.ts

@@ -0,0 +1,24 @@
+import { Content, Execution, Shared, Tool } from "../../schema/index";
+import type { Response } from "effect/unstable/ai";
+import type { RunInput } from "./agent-loop-service";
+declare const inputPreparedEvent: (input: RunInput, definitions: ReadonlyArray<Tool.Definition>) => Execution.ExecutionEvent;
+declare const usageReportedEvent: (input: RunInput, part: Response.FinishPart, sequence: Execution.ExecutionEventSequence) => Execution.ExecutionEvent;
+declare const budgetExceededEvent: (input: RunInput, tokensUsed: number, tokenBudget: number, sequence: Execution.ExecutionEventSequence) => Execution.ExecutionEvent;
+declare const outputDeltaEvent: (input: RunInput, part: Response.TextDeltaPart, deltaIndex: number) => Execution.ExecutionEvent;
+declare const reasoningDeltaEvent: (input: RunInput, part: Response.ReasoningPart | Response.ReasoningDeltaPart, deltaIndex: number) => Execution.ExecutionEvent;
+declare const toolCallDeltaEvent: (input: RunInput, part: Response.ToolParamsDeltaPart, toolCallName: string | undefined, sequence: Execution.ExecutionEventSequence, deltaIndex: number) => Execution.ExecutionEvent;
+declare const outputCompletedEvent: (input: RunInput, content: ReadonlyArray<Content.Part>, outputText: string, sequence: Execution.ExecutionEventSequence, structuredOutput?: Shared.JsonValue) => Execution.ExecutionEvent;
+declare const completedContent: (outputText: string) => ReadonlyArray<Content.Part>;
+declare const modelOutputMetadata: (event: Execution.ExecutionEvent) => Shared.Metadata;
+export declare const AgentLoopEvents: {
+    budgetExceededEvent: typeof budgetExceededEvent;
+    completedContent: typeof completedContent;
+    inputPreparedEvent: typeof inputPreparedEvent;
+    modelOutputMetadata: typeof modelOutputMetadata;
+    outputCompletedEvent: typeof outputCompletedEvent;
+    outputDeltaEvent: typeof outputDeltaEvent;
+    reasoningDeltaEvent: typeof reasoningDeltaEvent;
+    toolCallDeltaEvent: typeof toolCallDeltaEvent;
+    usageReportedEvent: typeof usageReportedEvent;
+};
+export {};