@relayfx/sdk 0.3.6 → 0.4.0

package/dist/sqlite.js

@@ -2,7 +2,7 @@
 import {
   database,
   normalizeMigrationCause
-} from "./index-2vsf6dks.js";
+} from "./index-cs3be24t.js";
 import {
   DatabaseAlreadyOwned,
   RuntimeConfigurationError,
@@ -12,9 +12,9 @@ import {
   make,
   makeDatabaseIdentity,
   runtimeLayer
-} from "./index-e02krw55.js";
-import"./index-8fpd6kvj.js";
-import"./index-mtvz1bjn.js";
+} from "./index-p43mg4kt.js";
+import"./index-x32kbvxv.js";
+import"./index-3w6txjtg.js";
 import"./index-nb39b5ae.js";
 
 // src/sqlite-runtime.ts
@@ -658,6 +658,16 @@ CREATE UNIQUE INDEX "uq_relay_tool_attempts_number" ON "relay_tool_attempts" ("t
 CREATE INDEX "idx_relay_tool_attempts_call" ON "relay_tool_attempts" ("tenant_id", "execution_id", "tool_call_id", "attempt_number");
 `;
 
+// ../../migrations/sqlite/0012_rename_entity_to_resident.sql
+var _0012_rename_entity_to_resident_default = `ALTER TABLE relay_entity_kinds RENAME TO relay_resident_kinds;
+--> statement-breakpoint
+ALTER TABLE relay_entity_instances RENAME TO relay_resident_instances;
+--> statement-breakpoint
+DROP INDEX idx_relay_entity_instances_kind_status;
+--> statement-breakpoint
+CREATE INDEX idx_relay_resident_instances_kind_status ON relay_resident_instances (tenant_id, kind, status);
+`;
+
 // src/sqlite-migrations.ts
 import { Effect } from "effect";
 import { SqlClient } from "effect/unstable/sql/SqlClient";
@@ -679,7 +689,8 @@ var migrations = [
   { id: 8, name: "child_fan_out", file: "0008_child_fan_out.sql", source: _0008_child_fan_out_default },
   { id: 9, name: "workflow_definitions", file: "0009_workflow_definitions.sql", source: _0009_workflow_definitions_default },
   { id: 10, name: "workflow_runtime", file: "0010_workflow_runtime.sql", source: _0010_workflow_runtime_default },
-  { id: 11, name: "execution_scoped_tool_calls", file: "0011_execution_scoped_tool_calls.sql", source: _0011_execution_scoped_tool_calls_default }
+  { id: 11, name: "execution_scoped_tool_calls", file: "0011_execution_scoped_tool_calls.sql", source: _0011_execution_scoped_tool_calls_default },
+  { id: 12, name: "rename_entity_to_resident", file: "0012_rename_entity_to_resident.sql", source: _0012_rename_entity_to_resident_default }
 ];
 var loader = Effect.succeed(migrations.map(({ id, name, source }) => [id, name, Effect.succeed(execute(source))]));
 

package/dist/types/relay/client-baton-agent.d.ts

@@ -0,0 +1,30 @@
+import type { Agent as BatonAgent } from "@batonfx/core";
+import { Agent } from "../schema/index";
+import { Effect, Schema } from "effect";
+import type { Tool as BatonTool } from "effect/unstable/ai";
+import { ClientError, type RegisterAgentInput, type RegisterBatonAgentInput } from "./client-public";
+export declare const isRegisterBatonAgentInput: <Tools extends Record<string, BatonTool.Any>, Requirements>(input: RegisterAgentInput<Tools, Requirements>) => input is RegisterBatonAgentInput<Tools, Requirements>;
+export declare const toolRefsFromBatonAgent: <Tools extends Record<string, BatonTool.Any>, Requirements>(agent: BatonAgent.Agent<Tools, Requirements>) => ReadonlyArray<Agent.ToolRef>;
+export declare const modelSelectionFromBatonAgent: <Tools extends Record<string, BatonTool.Any>, Requirements>(selection: NonNullable<BatonAgent.Agent<Tools, Requirements>["model"]>) => Agent.ModelSelection;
+export declare const decodeBatonAgentName: (name: string) => Effect.Effect<string, ClientError, never>;
+export declare const decodeBatonAgentMetadata: (metadata: Readonly<Record<string, unknown>> | undefined) => Effect.Effect<void, never, never> | Effect.Effect<{
+    readonly [x: string]: Schema.Json;
+}, ClientError, never>;
+export declare const decodeBatonMemorySubject: (subject: string) => Effect.Effect<string & import("effect/Brand").Brand<"Relay.MemorySubjectId">, ClientError, never>;
+export declare const metadataFromBatonAgent: <Tools extends Record<string, BatonTool.Any>, Requirements>(input: RegisterBatonAgentInput<Tools, Requirements>) => Effect.Effect<{
+    readonly [x: string]: Schema.Json;
+} | undefined, ClientError, never>;
+export declare const modelSelectionFromRegisterInput: <Tools extends Record<string, BatonTool.Any>, Requirements>(input: RegisterBatonAgentInput<Tools, Requirements>) => Effect.Effect<never, ClientError, never> | Effect.Effect<Agent.ModelSelection, never, never>;
+export declare const batonTurnPolicyInvalid: (detail: string) => ClientError;
+export declare const turnPolicySnapshotFromBaton: (snapshot: unknown) => Effect.Effect<Agent.TurnPolicySnapshot, ClientError, never>;
+export declare const turnPolicyFieldsFromRegisterInput: <Tools extends Record<string, BatonTool.Any>, Requirements>(input: RegisterBatonAgentInput<Tools, Requirements>) => Effect.Effect<{
+    max_tool_turns: number;
+    turn_policy?: never;
+} | {
+    max_tool_turns?: never;
+    turn_policy?: never;
+} | {
+    max_tool_turns?: never;
+    turn_policy: Agent.BothTurnPolicySnapshot | Agent.RecursTurnPolicySnapshot | Agent.UntilToolCallTurnPolicySnapshot;
+}, ClientError, never>;
+export declare const registerAgentPayload: <Tools extends Record<string, BatonTool.Any>, Requirements>(input: RegisterAgentInput<Tools, Requirements>) => Effect.Effect<Agent.RegisterDefinitionPayload, ClientError, never>;

package/dist/types/relay/client-child-runs.d.ts

@@ -0,0 +1,35 @@
+import type { Interface as EventLogInterface } from "../runtime/execution/event-log-service";
+import type { Interface as WaitServiceInterface } from "../runtime/wait/wait-service";
+import { Agent, Execution, Ids } from "../schema/index";
+import { ChildExecutionRepository, ExecutionRepository } from "../store-sql/portable";
+import { Effect } from "effect";
+import { ClientError } from "./client-public";
+import type { SpawnChildRunInput, StartExecutionInput } from "./operation";
+export interface ParentDefinitionPin {
+    readonly agentId: Ids.AgentId;
+    readonly agentRevision: Agent.DefinitionRevision;
+    readonly agentSnapshot: Agent.Definition;
+    readonly agentToolInputSchemaDigests?: Agent.ToolInputSchemaDigests;
+}
+declare const internalSpawnChildRunInput: (input: SpawnChildRunInput, pin: ParentDefinitionPin, createdAt: number) => Execution.SpawnChildRunInput;
+export declare const createChildJoinWait: (waits: WaitServiceInterface, eventLog: EventLogInterface, input: Execution.SpawnChildRunInput, accepted: Execution.ChildRunAccepted, createdAt: number) => Effect.Effect<string & import("effect/Brand").Brand<"Relay.WaitId">, ClientError, never>;
+export declare const reconcileExistingChildSpawn: (childExecutions: ChildExecutionRepository.Interface, waits: WaitServiceInterface, eventLog: EventLogInterface, input: SpawnChildRunInput) => Effect.Effect<{
+    accepted: {
+        child_execution_id: string & import("effect/Brand").Brand<"Relay.ChildExecutionId">;
+        execution_id: string & import("effect/Brand").Brand<"Relay.ExecutionId">;
+    };
+    createdAt: number;
+    parentWaitId: (string & import("effect/Brand").Brand<"Relay.WaitId">) | undefined;
+} | undefined, ClientError, never>;
+export declare const parentDefinitionPin: (executionRepository: ExecutionRepository.Interface, executionId: string & import("effect/Brand").Brand<"Relay.ExecutionId">) => Effect.Effect<{
+    agentId: string & import("effect/Brand").Brand<"Relay.AgentId">;
+    agentRevision: number;
+    agentSnapshot: Agent.Definition;
+    agentToolInputSchemaDigests?: Agent.ToolInputSchemaDigests;
+}, ClientError, never>;
+declare const childStartInput: (input: Execution.SpawnChildRunInput, accepted: Execution.ChildRunAccepted, pin: ParentDefinitionPin, definition: Agent.Definition, createdAt: number, parentWaitId: Ids.WaitId | undefined) => StartExecutionInput;
+export declare const childRunInternals: {
+    childStartInput: typeof childStartInput;
+    internalSpawnChildRunInput: typeof internalSpawnChildRunInput;
+};
+export {};

package/dist/types/relay/client-error-mapping.d.ts

@@ -0,0 +1,5 @@
+import { EventLogCursorNotFound } from "./operation";
+import { ClientError } from "./client-public";
+export declare const errorMessage: (error: unknown) => string;
+export declare const toClientError: (error: unknown) => ClientError;
+export declare const toStreamError: (error: unknown) => ClientError | EventLogCursorNotFound;

package/dist/types/relay/client-event-sequence.d.ts

@@ -0,0 +1,3 @@
+import type { Interface as EventLogInterface } from "../runtime/execution/event-log-service";
+import { Effect } from "effect";
+export declare const nextEventSequence: (eventLog: EventLogInterface, executionId: string & import("effect/Brand").Brand<"Relay.ExecutionId">) => Effect.Effect<number, import("./client-public").ClientError, never>;

package/dist/types/relay/client-execution-payloads.d.ts

@@ -0,0 +1,12 @@
+import { Agent } from "../schema/index";
+import { ExecutionRepository } from "../store-sql/portable";
+import { Effect } from "effect";
+import type { StartExecutionInput } from "./operation";
+import type { StartExecutionByAddressInput, StartExecutionByAgentDefinitionInput } from "./client-public";
+export declare const encodeExecutionCursor: (cursor: ExecutionRepository.ExecutionCursor) => Effect.Effect<string, import("./client-public").ClientError, never>;
+export declare const startExecutionByAddressPayload: (input: StartExecutionByAddressInput) => StartExecutionInput;
+declare const startExecutionByAgentDefinitionPayload: (input: StartExecutionByAgentDefinitionInput, definition: Agent.DefinitionRevisionRecord) => StartExecutionInput;
+export declare const executionPayloadInternals: {
+    startExecutionByAgentDefinitionPayload: typeof startExecutionByAgentDefinitionPayload;
+};
+export {};

package/dist/types/relay/client-public-agents.d.ts

@@ -0,0 +1,15 @@
+import type { Tool as BatonTool } from "effect/unstable/ai";
+import { Agent, Ids, Skill } from "../schema/index";
+import { Effect } from "effect";
+import type { ClientError, RegisterBatonAgentInput, RegisterDefinedAgentInput } from "./client-public";
+import { Service } from "./client-public";
+export declare const registerAgentDefinition: (input: Agent.RegisterDefinitionPayload) => Effect.Effect<Agent.DefinitionRegistered, ClientError, Service>;
+export declare function registerAgent<Tools extends Record<string, BatonTool.Any>, Requirements>(input: RegisterBatonAgentInput<Tools, Requirements>): Effect.Effect<Agent.DefinitionRegistered, ClientError, Service>;
+export declare function registerAgent(input: RegisterDefinedAgentInput): Effect.Effect<Agent.DefinitionRegistered, ClientError, Service>;
+export declare const getAgentDefinition: (id: string & import("effect/Brand").Brand<"Relay.AgentId">) => Effect.Effect<Agent.DefinitionRecord | undefined, ClientError, Service>;
+export declare const listAgentDefinitions: () => Effect.Effect<Agent.DefinitionList, ClientError, Service>;
+export declare const listAgentDefinitionRevisions: (id: string & import("effect/Brand").Brand<"Relay.AgentId">) => Effect.Effect<Agent.DefinitionRevisionList, ClientError, Service>;
+export declare const getSkillDefinition: (id: Ids.SkillDefinitionId) => Effect.Effect<Skill.DefinitionRecord | undefined, ClientError, Service>;
+declare const listSkillDefinitions: () => Effect.Effect<Skill.DefinitionList, ClientError, Service>;
+export declare const listSkillDefinitionRevisions: (id: Ids.SkillDefinitionId) => Effect.Effect<Skill.DefinitionRevisionList, ClientError, Service>;
+export { listSkillDefinitions };

package/dist/types/relay/client-public-child-runs.d.ts

@@ -0,0 +1,9 @@
+import { ChildOrchestration, Execution } from "../schema/index";
+import { Effect } from "effect";
+import { Service, type ClientError } from "./client-public";
+import type { RuntimeCapabilityUnavailable } from "./runtime-capability-policy";
+import type { CancelChildFanOutInput, CreateChildFanOutInput, InspectChildFanOutInput, SpawnChildRunInput } from "./operation";
+export declare const spawnChildRun: (input: SpawnChildRunInput) => Effect.Effect<Execution.ChildRunAccepted, ClientError, Service>;
+export declare const createChildFanOut: (input: CreateChildFanOutInput) => Effect.Effect<ChildOrchestration.FanOutState, ClientError | RuntimeCapabilityUnavailable, Service>;
+export declare const cancelChildFanOut: (input: CancelChildFanOutInput) => Effect.Effect<import("./operation").CancelChildFanOutResult, ClientError, Service>;
+export declare const inspectChildFanOut: (input: InspectChildFanOutInput) => Effect.Effect<import("./operation").InspectChildFanOutResult, ClientError, Service>;

package/dist/types/relay/client-public-envelope-ready.d.ts

@@ -0,0 +1,6 @@
+import { Effect } from "effect";
+import { Service } from "./client-public";
+import type { AckEnvelopeReadyInput, ClaimEnvelopeReadyInput, ReleaseEnvelopeReadyInput } from "./operation";
+export declare const claimEnvelopeReady: (input: ClaimEnvelopeReadyInput) => Effect.Effect<import("./operation").EnvelopeReadyLease | null, import("./client-public").ClientError, Service>;
+export declare const ackEnvelopeReady: (input: AckEnvelopeReadyInput) => Effect.Effect<import("./operation").EnvelopeReadyAcked, import("./client-public").ClientError, Service>;
+export declare const releaseEnvelopeReady: (input: ReleaseEnvelopeReadyInput) => Effect.Effect<import("./operation").EnvelopeReadyReleased, import("./client-public").ClientError, Service>;

package/dist/types/relay/client-public-executions.d.ts

@@ -0,0 +1,247 @@
+import { Execution, Ids } from "../schema/index";
+import { Effect, Stream } from "effect";
+import type { ClientError, EventLogCursorNotFound, StartExecutionByAddressInput, StartExecutionByAgentDefinitionInput } from "./client-public";
+import { Service } from "./client-public";
+import type { CancelExecutionInput, FollowExecutionInput, GetSessionInput, ListExecutionsInput, ListSessionsInput, ListWaitsInput, PageExecutionEventsInput, ReplayExecutionInput, StartExecutionInput, SteerInput, StreamExecutionInput, StreamSessionInput, WatchExecutionsInput } from "./operation";
+export declare const startExecution: (input: StartExecutionInput) => Effect.Effect<import("./operation").StartExecutionResult, ClientError | import("./client-public").ResidentNamespaceReserved, Service>;
+export declare const startExecutionByAddress: (input: StartExecutionByAddressInput) => Effect.Effect<import("./operation").StartExecutionResult, ClientError | import("./client-public").ResidentNamespaceReserved, Service>;
+export declare const startExecutionByAgentDefinition: (input: StartExecutionByAgentDefinitionInput) => Effect.Effect<import("./operation").StartExecutionResult, ClientError | import("./client-public").ResidentNamespaceReserved, Service>;
+export declare const cancelExecution: (input: CancelExecutionInput) => Effect.Effect<import("./operation").CancelExecutionAccepted, ClientError, Service>;
+export declare const steer: (input: SteerInput) => Effect.Effect<import("./operation").SteerAccepted, ClientError, Service>;
+export declare const getExecution: (id: Ids.ExecutionId) => Effect.Effect<Execution.Execution | undefined, ClientError, Service>;
+export declare const listExecutions: (input: ListExecutionsInput) => Effect.Effect<import("./operation").ListExecutionsResult, ClientError, Service>;
+export declare const listSessions: (input: ListSessionsInput) => Effect.Effect<import("./operation").ListSessionsResult, ClientError, Service>;
+export declare const getSession: (input: GetSessionInput) => Effect.Effect<import("./operation").GetSessionResult, ClientError, Service>;
+export declare const listWaits: (input: ListWaitsInput) => Effect.Effect<readonly import("./operation").WaitView[], ClientError, Service>;
+export declare const replayExecution: (input: ReplayExecutionInput) => Effect.Effect<import("./operation").ReplayExecutionResult, ClientError, Service>;
+export declare const pageExecutionEvents: (input: PageExecutionEventsInput) => Effect.Effect<import("./operation").PageExecutionEventsResult, ClientError | EventLogCursorNotFound, Service>;
+export declare const listRunners: () => Effect.Effect<import("./operation").ListRunnersResult, ClientError, Service>;
+export declare const routeExecution: (executionId: string & import("effect/Brand").Brand<"Relay.ExecutionId">) => Effect.Effect<import("./operation").RouteExecutionResult, ClientError, Service>;
+export declare const inspectExecution: (executionId: string & import("effect/Brand").Brand<"Relay.ExecutionId">) => Effect.Effect<import("./operation").ExecutionInspection, ClientError | import("./client-public").ExecutionNotFound, Service>;
+export declare const streamExecution: (input: StreamExecutionInput) => Stream.Stream<Execution.ExecutionEvent, EventLogCursorNotFound | ClientError, Service>;
+export declare const followExecution: (input: FollowExecutionInput) => Stream.Stream<import("effect/Schema").Struct.ReadonlySide<{
+    readonly _tag: import("effect/Schema").tag<"event">;
+    readonly event: import("effect/Schema").Struct<{
+        readonly id: import("effect/Schema").brand<import("effect/Schema").String, "Relay.EventId"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EventId">;
+        };
+        readonly execution_id: import("effect/Schema").brand<import("effect/Schema").String, "Relay.ExecutionId"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
+        };
+        readonly child_execution_id: import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/Schema").String, "Relay.ChildExecutionId"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ChildExecutionId">;
+        }>;
+        readonly type: import("effect/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: import("effect/Schema").Int;
+        readonly cursor: import("effect/Schema").String;
+        readonly content: import("effect/Schema").optionalKey<import("effect/Schema").$Array<import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+            readonly type: import("effect/Schema").Literal<"text">;
+            readonly text: import("effect/Schema").String;
+            readonly provider_options: import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>>;
+            readonly metadata: import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>>;
+        }>, import("effect/Schema").Struct<{
+            readonly type: import("effect/Schema").Literal<"structured">;
+            readonly value: import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>;
+            readonly schema_ref: import("effect/Schema").optionalKey<import("effect/Schema").String>;
+            readonly provider_options: import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>>;
+            readonly metadata: import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>>;
+        }>, import("effect/Schema").Struct<{
+            readonly type: import("effect/Schema").Literal<"blob-reference">;
+            readonly uri: import("effect/Schema").String;
+            readonly media_type: import("effect/Schema").String;
+            readonly filename: import("effect/Schema").optionalKey<import("effect/Schema").String>;
+            readonly provider_options: import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>>;
+            readonly metadata: import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>>;
+        }>, import("effect/Schema").Struct<{
+            readonly type: import("effect/Schema").Literal<"artifact-reference">;
+            readonly artifact_id: import("effect/Schema").String;
+            readonly media_type: import("effect/Schema").optionalKey<import("effect/Schema").String>;
+            readonly provider_options: import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>>;
+            readonly metadata: import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>>;
+        }>, import("effect/Schema").Struct<{
+            readonly type: import("effect/Schema").Literal<"tool-call">;
+            readonly call: import("effect/Schema").Struct<{
+                readonly id: import("effect/Schema").brand<import("effect/Schema").String, "Relay.ToolCallId"> & {
+                    make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ToolCallId">;
+                };
+                readonly name: import("effect/Schema").String;
+                readonly input: import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>;
+                readonly metadata: import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>>;
+            }>;
+            readonly provider_options: import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>>;
+            readonly metadata: import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>>;
+        }>, import("effect/Schema").Struct<{
+            readonly type: import("effect/Schema").Literal<"tool-result">;
+            readonly result: import("effect/Schema").Struct<{
+                readonly call_id: import("effect/Schema").brand<import("effect/Schema").String, "Relay.ToolCallId"> & {
+                    make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ToolCallId">;
+                };
+                readonly output: import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>;
+                readonly error: import("effect/Schema").optionalKey<import("effect/Schema").String>;
+                readonly metadata: import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>>;
+            }>;
+            readonly provider_options: import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>>;
+            readonly metadata: import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>>;
+        }>]>>>;
+        readonly data: import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>>;
+        readonly created_at: import("effect/Schema").Int;
+    }>;
+}, "Type"> | import("effect/Schema").Struct.ReadonlySide<{
+    readonly _tag: import("effect/Schema").tag<"reconnecting">;
+    readonly message: import("effect/Schema").String;
+    readonly attempt: import("effect/Schema").Int;
+}, "Type"> | import("effect/Schema").Struct.ReadonlySide<{
+    readonly _tag: import("effect/Schema").tag<"stopped">;
+    readonly reason: import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+        readonly _tag: import("effect/Schema").tag<"terminal">;
+        readonly status: import("effect/Schema").Literals<readonly ["queued", "running", "waiting", "completed", "failed", "cancelled"]>;
+    }>, import("effect/Schema").Struct<{
+        readonly _tag: import("effect/Schema").tag<"actionable_wait">;
+        readonly wait: import("effect/Schema").Struct<{
+            readonly wait_id: import("effect/Schema").brand<import("effect/Schema").String, "Relay.WaitId"> & {
+                make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WaitId">;
+            };
+            readonly execution_id: import("effect/Schema").brand<import("effect/Schema").String, "Relay.ExecutionId"> & {
+                make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
+            };
+            readonly envelope_id: import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/Schema").String, "Relay.EnvelopeId"> & {
+                make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EnvelopeId">;
+            }>;
+            readonly kind: import("effect/Schema").optionalKey<import("effect/Schema").Literals<readonly ["permission", "tool_approval", "tool_placement", "child_join", "inbox", "reply", "timer", "external"]>>;
+            readonly mode: import("effect/Schema").Literals<readonly ["reply", "event", "until", "child"]>;
+            readonly correlation_key: import("effect/Schema").optionalKey<import("effect/Schema").String>;
+            readonly state: import("effect/Schema").Literals<readonly ["open", "resolved", "timed_out", "cancelled"]>;
+            readonly metadata: import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>;
+            readonly created_at: import("effect/Schema").Int;
+            readonly resolved_at: import("effect/Schema").optionalKey<import("effect/Schema").Int>;
+        }>;
+    }>]>;
+    readonly cursor: import("effect/Schema").NullOr<import("effect/Schema").String>;
+}, "Type">, ClientError | EventLogCursorNotFound, Service>;
+export declare const streamSession: (input: StreamSessionInput) => Stream.Stream<import("effect/Schema").Struct.ReadonlySide<{
+    readonly _tag: import("effect/Schema").tag<"execution_joined">;
+    readonly execution: import("effect/Schema").Struct<{
+        readonly execution_id: import("effect/Schema").brand<import("effect/Schema").String, "Relay.ExecutionId"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
+        };
+        readonly root_address_id: import("effect/Schema").brand<import("effect/Schema").String, "Relay.AddressId"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
+        };
+        readonly session_id: import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/Schema").String, "Relay.SessionId"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.SessionId">;
+        }>;
+        readonly status: import("effect/Schema").Literals<readonly ["queued", "running", "waiting", "completed", "failed", "cancelled"]>;
+        readonly kind: import("effect/Schema").Literals<readonly ["user-agent", "agent-agent"]>;
+        readonly agent_id: import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/Schema").String, "Relay.AgentId"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentId">;
+        }>;
+        readonly metadata: import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>;
+        readonly created_at: import("effect/Schema").Int;
+        readonly updated_at: import("effect/Schema").Int;
+    }>;
+}, "Type"> | import("effect/Schema").Struct.ReadonlySide<{
+    readonly _tag: import("effect/Schema").tag<"execution_event">;
+    readonly event: import("effect/Schema").Struct<{
+        readonly id: import("effect/Schema").brand<import("effect/Schema").String, "Relay.EventId"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EventId">;
+        };
+        readonly execution_id: import("effect/Schema").brand<import("effect/Schema").String, "Relay.ExecutionId"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
+        };
+        readonly child_execution_id: import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/Schema").String, "Relay.ChildExecutionId"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ChildExecutionId">;
+        }>;
+        readonly type: import("effect/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: import("effect/Schema").Int;
+        readonly cursor: import("effect/Schema").String;
+        readonly content: import("effect/Schema").optionalKey<import("effect/Schema").$Array<import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+            readonly type: import("effect/Schema").Literal<"text">;
+            readonly text: import("effect/Schema").String;
+            readonly provider_options: import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>>;
+            readonly metadata: import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>>;
+        }>, import("effect/Schema").Struct<{
+            readonly type: import("effect/Schema").Literal<"structured">;
+            readonly value: import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>;
+            readonly schema_ref: import("effect/Schema").optionalKey<import("effect/Schema").String>;
+            readonly provider_options: import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>>;
+            readonly metadata: import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>>;
+        }>, import("effect/Schema").Struct<{
+            readonly type: import("effect/Schema").Literal<"blob-reference">;
+            readonly uri: import("effect/Schema").String;
+            readonly media_type: import("effect/Schema").String;
+            readonly filename: import("effect/Schema").optionalKey<import("effect/Schema").String>;
+            readonly provider_options: import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>>;
+            readonly metadata: import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>>;
+        }>, import("effect/Schema").Struct<{
+            readonly type: import("effect/Schema").Literal<"artifact-reference">;
+            readonly artifact_id: import("effect/Schema").String;
+            readonly media_type: import("effect/Schema").optionalKey<import("effect/Schema").String>;
+            readonly provider_options: import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>>;
+            readonly metadata: import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>>;
+        }>, import("effect/Schema").Struct<{
+            readonly type: import("effect/Schema").Literal<"tool-call">;
+            readonly call: import("effect/Schema").Struct<{
+                readonly id: import("effect/Schema").brand<import("effect/Schema").String, "Relay.ToolCallId"> & {
+                    make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ToolCallId">;
+                };
+                readonly name: import("effect/Schema").String;
+                readonly input: import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>;
+                readonly metadata: import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>>;
+            }>;
+            readonly provider_options: import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>>;
+            readonly metadata: import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>>;
+        }>, import("effect/Schema").Struct<{
+            readonly type: import("effect/Schema").Literal<"tool-result">;
+            readonly result: import("effect/Schema").Struct<{
+                readonly call_id: import("effect/Schema").brand<import("effect/Schema").String, "Relay.ToolCallId"> & {
+                    make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ToolCallId">;
+                };
+                readonly output: import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>;
+                readonly error: import("effect/Schema").optionalKey<import("effect/Schema").String>;
+                readonly metadata: import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>>;
+            }>;
+            readonly provider_options: import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>>;
+            readonly metadata: import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>>;
+        }>]>>>;
+        readonly data: import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>>;
+        readonly created_at: import("effect/Schema").Int;
+    }>;
+}, "Type">, ClientError | EventLogCursorNotFound, Service>;
+export declare const watchExecutions: (input: WatchExecutionsInput) => Stream.Stream<import("effect/Schema").Struct.ReadonlySide<{
+    readonly _tag: import("effect/Schema").tag<"upsert">;
+    readonly record: import("effect/Schema").Struct<{
+        readonly execution_id: import("effect/Schema").brand<import("effect/Schema").String, "Relay.ExecutionId"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
+        };
+        readonly root_address_id: import("effect/Schema").brand<import("effect/Schema").String, "Relay.AddressId"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
+        };
+        readonly session_id: import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/Schema").String, "Relay.SessionId"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.SessionId">;
+        }>;
+        readonly status: import("effect/Schema").Literals<readonly ["queued", "running", "waiting", "completed", "failed", "cancelled"]>;
+        readonly kind: import("effect/Schema").Literals<readonly ["user-agent", "agent-agent"]>;
+        readonly agent_id: import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/Schema").String, "Relay.AgentId"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentId">;
+        }>;
+        readonly metadata: import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>;
+        readonly created_at: import("effect/Schema").Int;
+        readonly updated_at: import("effect/Schema").Int;
+    }>;
+}, "Type"> | {
+    readonly _tag: "snapshot";
+    readonly records: readonly {
+        readonly execution_id: string & import("effect/Brand").Brand<"Relay.ExecutionId">;
+        readonly root_address_id: string & import("effect/Brand").Brand<"Relay.AddressId">;
+        readonly session_id?: string & import("effect/Brand").Brand<"Relay.SessionId">;
+        readonly status: "cancelled" | "completed" | "failed" | "queued" | "running" | "waiting";
+        readonly kind: "agent-agent" | "user-agent";
+        readonly agent_id?: string & import("effect/Brand").Brand<"Relay.AgentId">;
+        readonly metadata: {
+            readonly [x: string]: import("effect/Schema").Json;
+        };
+        readonly created_at: number;
+        readonly updated_at: number;
+    }[];
+    readonly next_cursor?: string;
+}, ClientError, Service>;

package/dist/types/relay/client-public-messaging.d.ts

@@ -0,0 +1,18 @@
+import { Address, Envelope, Inbox, Presence } from "../schema/index";
+import { Effect, Stream } from "effect";
+import { Service, type ClientError } from "./client-public";
+import type { AwaitWaitInput, ListInboxMessagesInput, ListTopicSubscriptionsInput, PublishTopicInput, SubmitInboundEnvelopeInput, SubscribeTopicInput, UnsubscribeTopicInput, WakeInput } from "./operation";
+export declare const registerAddressBookRoute: (input: Address.RegisterRoutePayload) => Effect.Effect<Address.RouteRegistered, ClientError | import("./client-public").ResidentNamespaceReserved, Service>;
+export declare const getAddressBookRoute: (id: string & import("effect/Brand").Brand<"Relay.AddressId">) => Effect.Effect<Address.RouteRecord | undefined, ClientError, Service>;
+export declare const listAddressBookRoutes: () => Effect.Effect<Address.RouteList, ClientError, Service>;
+export declare const subscribeTopic: (input: SubscribeTopicInput) => Effect.Effect<import("./operation").TopicSubscription, ClientError, Service>;
+export declare const unsubscribeTopic: (input: UnsubscribeTopicInput) => Effect.Effect<void, ClientError, Service>;
+export declare const publishTopic: (input: PublishTopicInput) => Effect.Effect<import("./operation").TopicPublishAccepted, ClientError, Service>;
+export declare const listTopicSubscriptions: (input: ListTopicSubscriptionsInput) => Effect.Effect<readonly import("./operation").TopicSubscription[], ClientError, Service>;
+export declare const listInboxMessages: (input: ListInboxMessagesInput) => Effect.Effect<ReadonlyArray<Inbox.Message>, ClientError, Service>;
+export declare const send: (input: Envelope.SendInput) => Effect.Effect<Envelope.EnvelopeAccepted, ClientError, Service>;
+export declare const getPresence: (scope: Presence.Scope) => Effect.Effect<Presence.View, ClientError, Service>;
+export declare const watchPresence: (scope: Presence.Scope) => Stream.Stream<Presence.View, ClientError, Service>;
+export declare const wake: (input: WakeInput) => Effect.Effect<import("./operation").WakeAccepted, ClientError | import("./client-public").WaitKindMismatch, Service>;
+export declare const submitInboundEnvelope: (input: SubmitInboundEnvelopeInput) => Effect.Effect<import("./operation").SubmitInboundEnvelopeAccepted, ClientError | import("./client-public").WaitKindMismatch, Service>;
+export declare const awaitWait: (input: AwaitWaitInput) => Effect.Effect<import("./operation").WaitOutcome, ClientError, Service>;

package/dist/types/relay/client-public-residents.d.ts

@@ -0,0 +1,14 @@
+import { Resident } from "../schema/index";
+import { Effect, Schema } from "effect";
+import { Service, type AskResidentInput, type FlatInterface, type PublicOperation } from "./client-public";
+import type { DestroyResidentInput, GetResidentInput, ListResidentsInput, SpawnResidentInput } from "./operation";
+export declare const registerResidentKind: (input: Resident.KindDefinition) => Effect.Effect<Resident.KindDefinition, import("./client-public").ClientError, Service>;
+export declare const spawnResident: (input: SpawnResidentInput) => Effect.Effect<Resident.Instance, import("./client-public").ClientError, Service>;
+export declare const getResident: (input: GetResidentInput) => Effect.Effect<Resident.Instance | undefined, import("./client-public").ClientError, Service>;
+export declare const destroyResident: (input: DestroyResidentInput) => Effect.Effect<Resident.Instance, import("./client-public").ClientError, Service>;
+export declare const listResidents: (input: ListResidentsInput) => Effect.Effect<readonly Resident.Instance[], import("./client-public").ClientError, Service>;
+export declare const askResident: <Name extends string, I extends Schema.Top, O extends Schema.Top>(input: AskResidentInput<Name, I, O>) => Effect.Effect<O["Type"], import("./client-public").ClientError | import("./command").CommandReplyInvalid | import("./command").CommandTimedOut | import("./command").ResidentNotFound, Service | I["EncodingServices"] | O["DecodingServices"]>;
+export declare const getResidentState: PublicOperation<FlatInterface["getResidentState"]>;
+export declare const putResidentState: PublicOperation<FlatInterface["putResidentState"]>;
+export declare const deleteResidentState: PublicOperation<FlatInterface["deleteResidentState"]>;
+export declare const listResidentState: PublicOperation<FlatInterface["listResidentState"]>;

package/dist/types/relay/client-public-schedules.d.ts

@@ -0,0 +1,6 @@
+import { Effect } from "effect";
+import { Service } from "./client-public";
+import type { CancelScheduleInput, CreateScheduleInput, ListSchedulesInput } from "./operation";
+export declare const createSchedule: (input: CreateScheduleInput) => Effect.Effect<import("./operation").CreateScheduleResult, import("./client-public").ClientError, Service>;
+export declare const cancelSchedule: (input: CancelScheduleInput) => Effect.Effect<import("./operation").CancelScheduleResult, import("./client-public").ClientError, Service>;
+export declare const listSchedules: (input: ListSchedulesInput) => Effect.Effect<import("./operation").ListSchedulesResult, import("./client-public").ClientError, Service>;

package/dist/types/relay/client-public-tools.d.ts

@@ -0,0 +1,12 @@
+import { Effect } from "effect";
+import { Service } from "./client-public";
+import type { ClaimToolWorkInput, CompleteToolWorkInput, FulfillToolCallInput, ListPendingApprovalsInput, ListPendingToolCallsInput, ListToolAttemptsInput, ReleaseToolWorkInput, ResolvePermissionInput, ResolveToolApprovalInput } from "./operation";
+export declare const listPendingApprovals: (input: ListPendingApprovalsInput) => Effect.Effect<import("./operation").PendingToolApprovalList, import("./client-public").ClientError, Service>;
+export declare const resolveToolApproval: (input: ResolveToolApprovalInput) => Effect.Effect<import("./operation").WakeAccepted, import("./client-public").ClientError | import("./client-public").WaitKindMismatch, Service>;
+export declare const resolvePermission: (input: ResolvePermissionInput) => Effect.Effect<import("./operation").WakeAccepted, import("./client-public").ClientError | import("./client-public").WaitKindMismatch, Service>;
+export declare const listPendingToolCalls: (input: ListPendingToolCallsInput) => Effect.Effect<import("./operation").PendingToolCallList, import("./client-public").ClientError, Service>;
+export declare const fulfillToolCall: (input: FulfillToolCallInput) => Effect.Effect<import("./operation").ToolOutcomeAccepted, import("./client-public").ClientError, Service>;
+export declare const claimToolWork: (input: ClaimToolWorkInput) => Effect.Effect<import("./operation").ToolWorkLease | null, import("./client-public").ClientError, Service>;
+export declare const completeToolWork: (input: CompleteToolWorkInput) => Effect.Effect<import("./operation").ToolOutcomeAccepted, import("./client-public").ClientError, Service>;
+export declare const releaseToolWork: (input: ReleaseToolWorkInput) => Effect.Effect<import("./operation").ToolWorkReleased, import("./client-public").ClientError, Service>;
+export declare const listToolAttempts: (input: ListToolAttemptsInput) => Effect.Effect<import("./operation").ToolAttemptList, import("./client-public").ClientError, Service>;

package/dist/types/relay/client-public-workflows.d.ts

@@ -0,0 +1,10 @@
+import { Workflow } from "../schema/index";
+import { Effect } from "effect";
+import { Service } from "./client-public";
+export declare const registerWorkflowDefinition: (input: Workflow.RegisterDefinitionPayload) => Effect.Effect<Workflow.DefinitionRegistered, import("./client-public").ClientError, Service>;
+export declare const getWorkflowDefinitionRevision: (id: string & import("effect/Brand").Brand<"Relay.WorkflowDefinitionId">, revision?: number | undefined) => Effect.Effect<Workflow.DefinitionRevisionRecord | undefined, import("./client-public").ClientError, Service>;
+export declare const listWorkflowDefinitionRevisions: (id: string & import("effect/Brand").Brand<"Relay.WorkflowDefinitionId">) => Effect.Effect<Workflow.DefinitionRevisionList, import("./client-public").ClientError, Service>;
+export declare const startWorkflowRun: (input: Workflow.StartRunPayload) => Effect.Effect<Workflow.RunRecord, import("./client-public").ClientError | import("./runtime-capability-policy").RuntimeCapabilityUnavailable, Service>;
+export declare const cancelWorkflowRun: (id: string & import("effect/Brand").Brand<"Relay.ExecutionId">) => Effect.Effect<Workflow.RunRecord | undefined, import("./client-public").ClientError, Service>;
+export declare const replayWorkflowRun: (id: string & import("effect/Brand").Brand<"Relay.ExecutionId">) => Effect.Effect<readonly Workflow.LifecycleEvent[], import("./client-public").ClientError, Service>;
+export declare const inspectWorkflowRun: (id: string & import("effect/Brand").Brand<"Relay.ExecutionId">) => Effect.Effect<Workflow.RunRecord | undefined, import("./client-public").ClientError, Service>;