@relayfx/sdk 0.0.1

package/dist/types/runtime/wait/wait-service.d.ts

@@ -0,0 +1,80 @@
+import { Envelope, Execution, Ids, Shared } from "../../schema/index";
+import { EnvelopeRepository, ScheduleRepository } from "../../store-sql/index";
+import { Context, Effect, Layer, Schema } from "effect";
+import * as EventLog from "../execution/event-log-service";
+declare const WaitNotFound_base: Schema.Class<WaitNotFound, Schema.TaggedStruct<"WaitNotFound", {
+    readonly wait_id: Schema.brand<Schema.String, "Relay.WaitId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WaitId">;
+    };
+}>, import("effect/Cause").YieldableError>;
+export declare class WaitNotFound extends WaitNotFound_base {
+}
+declare const WaitDefinitionMissing_base: Schema.Class<WaitDefinitionMissing, Schema.TaggedStruct<"WaitDefinitionMissing", {
+    readonly envelope_id: Schema.brand<Schema.String, "Relay.EnvelopeId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EnvelopeId">;
+    };
+}>, import("effect/Cause").YieldableError>;
+export declare class WaitDefinitionMissing extends WaitDefinitionMissing_base {
+}
+declare const WaitServiceError_base: Schema.Class<WaitServiceError, Schema.TaggedStruct<"WaitServiceError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class WaitServiceError extends WaitServiceError_base {
+}
+export interface CreateWaitInput {
+    readonly waitId: Ids.WaitId;
+    readonly envelope: Envelope.Envelope;
+    readonly eventSequence: Execution.ExecutionEventSequence;
+}
+export interface CreateDetachedWaitInput {
+    readonly waitId: Ids.WaitId;
+    readonly executionId: Ids.ExecutionId;
+    readonly mode: Envelope.WaitMode;
+    readonly correlationKey?: string;
+    readonly metadata?: Shared.Metadata;
+    readonly eventSequence: Execution.ExecutionEventSequence;
+    readonly createdAt: number;
+}
+export interface WakeInput {
+    readonly waitId: Ids.WaitId;
+    readonly resolvedAt: number;
+    readonly eventSequence: Execution.ExecutionEventSequence;
+    readonly metadata?: Shared.Metadata;
+}
+export interface TimeoutInput {
+    readonly waitId: Ids.WaitId;
+    readonly timedOutAt: number;
+    readonly eventSequence: Execution.ExecutionEventSequence;
+    readonly metadata?: Shared.Metadata;
+}
+export interface CancelWaitInput {
+    readonly waitId: Ids.WaitId;
+    readonly cancelledAt: number;
+    readonly eventSequence: Execution.ExecutionEventSequence;
+    readonly metadata?: Shared.Metadata;
+}
+export interface WaitTransition {
+    readonly wait: EnvelopeRepository.WaitRecord;
+    readonly transitioned: boolean;
+}
+export interface Interface {
+    readonly create: (input: CreateWaitInput) => Effect.Effect<EnvelopeRepository.WaitRecord, WaitDefinitionMissing | WaitServiceError>;
+    readonly createDetached: (input: CreateDetachedWaitInput) => Effect.Effect<EnvelopeRepository.WaitRecord, WaitServiceError>;
+    readonly get: (id: Ids.WaitId) => Effect.Effect<EnvelopeRepository.WaitRecord | undefined, WaitServiceError>;
+    readonly wake: (input: WakeInput) => Effect.Effect<WaitTransition, WaitNotFound | WaitServiceError>;
+    readonly timeout: (input: TimeoutInput) => Effect.Effect<WaitTransition, WaitNotFound | WaitServiceError>;
+    readonly cancel: (input: CancelWaitInput) => Effect.Effect<WaitTransition, WaitNotFound | WaitServiceError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/WaitService", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const layer: Layer.Layer<Service, never, EnvelopeRepository.Service | ScheduleRepository.Service | EventLog.Service>;
+export declare const memoryLayer: Layer.Layer<Service, never, never>;
+export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
+export declare const create: (input: CreateWaitInput) => Effect.Effect<EnvelopeRepository.WaitRecord, WaitDefinitionMissing | WaitServiceError, Service>;
+export declare const createDetached: (input: CreateDetachedWaitInput) => Effect.Effect<EnvelopeRepository.WaitRecord, WaitServiceError, Service>;
+export declare const get: (id: string & import("effect/Brand").Brand<"Relay.WaitId">) => Effect.Effect<EnvelopeRepository.WaitRecord | undefined, WaitServiceError, Service>;
+export declare const wake: (input: WakeInput) => Effect.Effect<WaitTransition, WaitNotFound | WaitServiceError, Service>;
+export declare const timeout: (input: TimeoutInput) => Effect.Effect<WaitTransition, WaitNotFound | WaitServiceError, Service>;
+export declare const cancel: (input: CancelWaitInput) => Effect.Effect<WaitTransition, WaitNotFound | WaitServiceError, Service>;
+export {};

package/dist/types/runtime/wait/wait-signal.d.ts

@@ -0,0 +1,15 @@
+import { Ids } from "../../schema/index";
+import { Effect } from "effect";
+import * as ExecutionWorkflow from "../workflow/execution-workflow";
+export interface ExecutionSignalClient {
+    readonly signalWait: (input: ExecutionWorkflow.SignalWaitInput) => Effect.Effect<void, unknown>;
+}
+export type ExecutionClientFactory = (executionId: Ids.ExecutionId) => ExecutionSignalClient;
+export interface SignalWorkflowWaitInput {
+    readonly makeExecutionClient: ExecutionClientFactory;
+    readonly executionId: Ids.ExecutionId;
+    readonly waitId: Ids.WaitId;
+    readonly state: ExecutionWorkflow.WaitSignalState;
+    readonly signaledAt: number;
+}
+export declare const signalWorkflowWait: (input: SignalWorkflowWaitInput) => Effect.Effect<void, unknown, never>;

package/dist/types/runtime/workflow/execution-workflow.d.ts

@@ -0,0 +1,335 @@
+import { Ids } from "../../schema/index";
+import { ExecutionRepository } from "../../store-sql/index";
+import { Workflow } from "effect/unstable/workflow";
+import { Effect, Layer, Option, Schema } from "effect";
+import * as AddressResolution from "../address/address-resolution-service";
+import * as AgentLoop from "../agent/agent-loop-service";
+import * as EventLog from "../execution/event-log-service";
+import * as ExecutionService from "../execution/execution-service";
+import * as ToolRuntime from "../tool/tool-runtime-service";
+import * as WaitService from "../wait/wait-service";
+import * as WorkspacePlanner from "../workspace/workspace-planner-service";
+declare const ExecutionWorkflowFailed_base: Schema.Class<ExecutionWorkflowFailed, Schema.TaggedStruct<"ExecutionWorkflowFailed", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class ExecutionWorkflowFailed extends ExecutionWorkflowFailed_base {
+}
+export declare const StartInput: 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 root_address_id: Schema.brand<Schema.String, "Relay.AddressId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
+    };
+    readonly input: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"text">;
+        readonly text: Schema.String;
+        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"structured">;
+        readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly schema_ref: Schema.optionalKey<Schema.String>;
+        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"blob-reference">;
+        readonly uri: Schema.String;
+        readonly media_type: Schema.String;
+        readonly filename: Schema.optionalKey<Schema.String>;
+        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"artifact-reference">;
+        readonly artifact_id: Schema.String;
+        readonly media_type: Schema.optionalKey<Schema.String>;
+        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"tool-call">;
+        readonly call: Schema.Struct<{
+            readonly id: Schema.brand<Schema.String, "Relay.ToolCallId"> & {
+                make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ToolCallId">;
+            };
+            readonly name: Schema.String;
+            readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        }>;
+        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"tool-result">;
+        readonly result: Schema.Struct<{
+            readonly call_id: Schema.brand<Schema.String, "Relay.ToolCallId"> & {
+                make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ToolCallId">;
+            };
+            readonly output: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly error: Schema.optionalKey<Schema.String>;
+            readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        }>;
+        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    }>]>>>;
+    readonly event_sequence: Schema.Int;
+    readonly started_at: Schema.Int;
+    readonly completed_at: Schema.Int;
+    readonly agent_definition_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.AgentDefinitionId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentDefinitionId">;
+    }>;
+    readonly agent_definition_revision: Schema.optionalKey<Schema.Int>;
+    readonly agent_definition_snapshot: Schema.optionalKey<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly instructions: Schema.optionalKey<Schema.String>;
+        readonly model: Schema.Struct<{
+            readonly provider: Schema.String;
+            readonly model: Schema.String;
+            readonly registration_key: Schema.optionalKey<Schema.String>;
+            readonly request_options: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+            readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        }>;
+        readonly tool_names: Schema.$Array<Schema.String>;
+        readonly permissions: Schema.$Array<Schema.Struct<{
+            readonly name: Schema.String;
+            readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        }>>;
+        readonly child_run_presets: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Struct<{
+            readonly instructions: Schema.optionalKey<Schema.String>;
+            readonly model: Schema.optionalKey<Schema.Struct<{
+                readonly provider: Schema.String;
+                readonly model: Schema.String;
+                readonly registration_key: Schema.optionalKey<Schema.String>;
+                readonly request_options: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+                readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+            }>>;
+            readonly tool_names: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            readonly permissions: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            readonly workspace_policy: Schema.optionalKey<Schema.Struct<{
+                readonly mode: Schema.Literals<readonly ["share", "fork"]>;
+                readonly fallback: Schema.optionalKey<Schema.Literals<readonly ["fail", "fresh"]>>;
+            }>>;
+            readonly output_schema_ref: Schema.optionalKey<Schema.String>;
+            readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        }>>>;
+        readonly output_schema_ref: Schema.optionalKey<Schema.String>;
+        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    }>>;
+    readonly wait_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.WaitId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WaitId">;
+    }>;
+    readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+}>;
+export interface StartInput extends Schema.Schema.Type<typeof StartInput> {
+}
+export declare const WaitSignalState: Schema.Literals<readonly ["resolved", "timed_out", "cancelled"]>;
+export type WaitSignalState = typeof WaitSignalState.Type;
+export declare const WaitSignal: Schema.Struct<{
+    readonly wait_id: Schema.brand<Schema.String, "Relay.WaitId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WaitId">;
+    };
+    readonly state: Schema.Literals<readonly ["resolved", "timed_out", "cancelled"]>;
+    readonly signaled_at: Schema.Int;
+}>;
+export interface WaitSignal extends Schema.Schema.Type<typeof WaitSignal> {
+}
+export declare const SignalWaitInput: Schema.Struct<{
+    readonly workflow_execution_id: Schema.String;
+    readonly wait_id: Schema.brand<Schema.String, "Relay.WaitId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WaitId">;
+    };
+    readonly state: Schema.Literals<readonly ["resolved", "timed_out", "cancelled"]>;
+    readonly signaled_at: Schema.Int;
+}>;
+export interface SignalWaitInput extends Schema.Schema.Type<typeof SignalWaitInput> {
+}
+export declare const CancelExecutionInput: 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 cancelled_at: Schema.Int;
+    readonly reason: Schema.optionalKey<Schema.String>;
+}>;
+export interface CancelExecutionInput extends Schema.Schema.Type<typeof CancelExecutionInput> {
+}
+export declare const CancelExecutionResult: 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 status: Schema.Literals<readonly ["queued", "running", "waiting", "completed", "failed", "cancelled"]>;
+}>;
+export interface CancelExecutionResult extends Schema.Schema.Type<typeof CancelExecutionResult> {
+}
+export declare const WaitSnapshot: Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Relay.WaitId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WaitId">;
+    };
+    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 envelope_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.EnvelopeId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EnvelopeId">;
+    }>;
+    readonly mode: Schema.Literals<readonly ["reply", "event", "until", "child"]>;
+    readonly correlation_key: Schema.optionalKey<Schema.String>;
+    readonly state: Schema.Literals<readonly ["open", "resolved", "timed_out", "cancelled"]>;
+    readonly metadata: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    readonly created_at: Schema.Int;
+    readonly resolved_at: Schema.optionalKey<Schema.Int>;
+}>;
+export interface WaitSnapshot extends Schema.Schema.Type<typeof WaitSnapshot> {
+}
+export declare const StartResult: 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 status: Schema.Literals<readonly ["queued", "running", "waiting", "completed", "failed", "cancelled"]>;
+    readonly wait_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.WaitId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WaitId">;
+    }>;
+    readonly wait_state: Schema.optionalKey<Schema.Literals<readonly ["resolved", "timed_out", "cancelled"]>>;
+    readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+}>;
+export interface StartResult extends Schema.Schema.Type<typeof StartResult> {
+}
+export declare const StartExecutionWorkflow: Workflow.Workflow<"Relay/Execution/Start", 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 root_address_id: Schema.brand<Schema.String, "Relay.AddressId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
+    };
+    readonly input: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"text">;
+        readonly text: Schema.String;
+        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"structured">;
+        readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly schema_ref: Schema.optionalKey<Schema.String>;
+        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"blob-reference">;
+        readonly uri: Schema.String;
+        readonly media_type: Schema.String;
+        readonly filename: Schema.optionalKey<Schema.String>;
+        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"artifact-reference">;
+        readonly artifact_id: Schema.String;
+        readonly media_type: Schema.optionalKey<Schema.String>;
+        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"tool-call">;
+        readonly call: Schema.Struct<{
+            readonly id: Schema.brand<Schema.String, "Relay.ToolCallId"> & {
+                make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ToolCallId">;
+            };
+            readonly name: Schema.String;
+            readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        }>;
+        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"tool-result">;
+        readonly result: Schema.Struct<{
+            readonly call_id: Schema.brand<Schema.String, "Relay.ToolCallId"> & {
+                make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ToolCallId">;
+            };
+            readonly output: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly error: Schema.optionalKey<Schema.String>;
+            readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        }>;
+        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    }>]>>>;
+    readonly event_sequence: Schema.Int;
+    readonly started_at: Schema.Int;
+    readonly completed_at: Schema.Int;
+    readonly agent_definition_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.AgentDefinitionId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentDefinitionId">;
+    }>;
+    readonly agent_definition_revision: Schema.optionalKey<Schema.Int>;
+    readonly agent_definition_snapshot: Schema.optionalKey<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly instructions: Schema.optionalKey<Schema.String>;
+        readonly model: Schema.Struct<{
+            readonly provider: Schema.String;
+            readonly model: Schema.String;
+            readonly registration_key: Schema.optionalKey<Schema.String>;
+            readonly request_options: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+            readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        }>;
+        readonly tool_names: Schema.$Array<Schema.String>;
+        readonly permissions: Schema.$Array<Schema.Struct<{
+            readonly name: Schema.String;
+            readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        }>>;
+        readonly child_run_presets: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Struct<{
+            readonly instructions: Schema.optionalKey<Schema.String>;
+            readonly model: Schema.optionalKey<Schema.Struct<{
+                readonly provider: Schema.String;
+                readonly model: Schema.String;
+                readonly registration_key: Schema.optionalKey<Schema.String>;
+                readonly request_options: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+                readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+            }>>;
+            readonly tool_names: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            readonly permissions: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            readonly workspace_policy: Schema.optionalKey<Schema.Struct<{
+                readonly mode: Schema.Literals<readonly ["share", "fork"]>;
+                readonly fallback: Schema.optionalKey<Schema.Literals<readonly ["fail", "fresh"]>>;
+            }>>;
+            readonly output_schema_ref: Schema.optionalKey<Schema.String>;
+            readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        }>>>;
+        readonly output_schema_ref: Schema.optionalKey<Schema.String>;
+        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    }>>;
+    readonly wait_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.WaitId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WaitId">;
+    }>;
+    readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+}>, 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 status: Schema.Literals<readonly ["queued", "running", "waiting", "completed", "failed", "cancelled"]>;
+    readonly wait_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.WaitId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WaitId">;
+    }>;
+    readonly wait_state: Schema.optionalKey<Schema.Literals<readonly ["resolved", "timed_out", "cancelled"]>>;
+    readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+}>, typeof ExecutionWorkflowFailed>;
+export declare const layer: Layer.Layer<never, never, ExecutionRepository.Service | AddressResolution.Service | EventLog.Service | WaitService.Service | ToolRuntime.Service | AgentLoop.Service | ExecutionService.Service | WorkspacePlanner.Service | import("effect/unstable/workflow/WorkflowEngine").WorkflowEngine>;
+export declare const start: <const Discard extends boolean = false>(input: StartInput, options?: {
+    readonly discard?: Discard;
+}) => Effect.Effect<Discard extends true ? string : {
+    readonly execution_id: string & import("effect/Brand").Brand<"Relay.ExecutionId">;
+    readonly status: "queued" | "running" | "waiting" | "completed" | "failed" | "cancelled";
+    readonly metadata?: {
+        readonly [x: string]: Schema.Json;
+    };
+    readonly wait_id?: string & import("effect/Brand").Brand<"Relay.WaitId">;
+    readonly wait_state?: "cancelled" | "resolved" | "timed_out";
+}, Discard extends true ? never : ExecutionWorkflowFailed, import("effect/unstable/workflow/WorkflowEngine").WorkflowEngine>;
+export declare const startRequest: (input: StartInput) => Effect.Effect<{
+    readonly execution_id: string & import("effect/Brand").Brand<"Relay.ExecutionId">;
+    readonly status: "queued" | "running" | "waiting" | "completed" | "failed" | "cancelled";
+    readonly metadata?: {
+        readonly [x: string]: Schema.Json;
+    };
+    readonly wait_id?: string & import("effect/Brand").Brand<"Relay.WaitId">;
+    readonly wait_state?: "cancelled" | "resolved" | "timed_out";
+}, ExecutionWorkflowFailed, import("effect/unstable/workflow/WorkflowEngine").WorkflowEngine>;
+export declare const cancelRequest: (input: CancelExecutionInput) => Effect.Effect<{
+    execution_id: string & import("effect/Brand").Brand<"Relay.ExecutionId">;
+    status: "queued" | "running" | "waiting" | "completed" | "failed" | "cancelled";
+}, ExecutionWorkflowFailed, ExecutionRepository.Service | EventLog.Service | WaitService.Service | import("effect/unstable/workflow/WorkflowEngine").WorkflowEngine>;
+export declare const poll: (executionId: string) => Effect.Effect<Option.Option<Workflow.Result<{
+    readonly execution_id: string & import("effect/Brand").Brand<"Relay.ExecutionId">;
+    readonly status: "queued" | "running" | "waiting" | "completed" | "failed" | "cancelled";
+    readonly metadata?: {
+        readonly [x: string]: Schema.Json;
+    };
+    readonly wait_id?: string & import("effect/Brand").Brand<"Relay.WaitId">;
+    readonly wait_state?: "cancelled" | "resolved" | "timed_out";
+}, ExecutionWorkflowFailed>>, never, import("effect/unstable/workflow/WorkflowEngine").WorkflowEngine>;
+export declare const resume: (executionId: string) => Effect.Effect<void, never, import("effect/unstable/workflow/WorkflowEngine").WorkflowEngine>;
+export declare const workflowExecutionId: (input: StartInput) => Effect.Effect<string, never, never>;
+export declare const workflowExecutionIdForExecution: (executionId: Ids.ExecutionId) => Effect.Effect<string, never, never>;
+export declare const signalWait: (input: SignalWaitInput) => Effect.Effect<void, never, import("effect/unstable/workflow/WorkflowEngine").WorkflowEngine>;
+export {};

package/dist/types/runtime/workspace/workspace-planner-service.d.ts

@@ -0,0 +1,63 @@
+import { Agent, Ids, Shared, Tool, Workspace } from "../../schema/index";
+import { WorkspaceLeaseRepository } from "../../store-sql/index";
+import { Context, Effect, Layer, Schema } from "effect";
+import * as EventLog from "../execution/event-log-service";
+import * as WorkspaceProvider from "./workspace-provider-service";
+import * as WorkspaceRuntime from "./workspace-runtime-service";
+declare const WorkspaceRuntimeMissing_base: Schema.Class<WorkspaceRuntimeMissing, Schema.TaggedStruct<"WorkspaceRuntimeMissing", {
+    readonly execution_id: Schema.brand<Schema.String, "Relay.ExecutionId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
+    };
+}>, import("effect/Cause").YieldableError>;
+export declare class WorkspaceRuntimeMissing extends WorkspaceRuntimeMissing_base {
+}
+declare const WorkspaceLeaseMissingRef_base: Schema.Class<WorkspaceLeaseMissingRef, Schema.TaggedStruct<"WorkspaceLeaseMissingRef", {
+    readonly execution_id: Schema.brand<Schema.String, "Relay.ExecutionId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
+    };
+}>, import("effect/Cause").YieldableError>;
+export declare class WorkspaceLeaseMissingRef extends WorkspaceLeaseMissingRef_base {
+}
+declare const WorkspacePlannerError_base: Schema.Class<WorkspacePlannerError, Schema.TaggedStruct<"WorkspacePlannerError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class WorkspacePlannerError extends WorkspacePlannerError_base {
+}
+export interface EnsureInput {
+    readonly executionId: Ids.ExecutionId;
+    readonly agent: Agent.Definition;
+    readonly toolDefinitions: ReadonlyArray<Tool.Definition>;
+    readonly request?: Workspace.WorkspaceRequest;
+    readonly now: number;
+}
+export interface WorkspacePlan {
+    readonly lease: Workspace.WorkspaceLeaseRecord;
+    readonly runtimeLayer: Layer.Layer<WorkspaceRuntime.Service>;
+}
+export interface LifecycleInput {
+    readonly executionId: Ids.ExecutionId;
+    readonly now: number;
+}
+export interface FailureInput extends LifecycleInput {
+    readonly metadata?: Shared.Metadata;
+}
+export interface Interface {
+    readonly ensure: (input: EnsureInput) => Effect.Effect<WorkspacePlan | undefined, WorkspaceRuntimeMissing | WorkspaceLeaseMissingRef | WorkspacePlannerError | WorkspaceProvider.WorkspaceNotFound | WorkspaceProvider.WorkspaceUnavailable | WorkspaceProvider.WorkspaceProviderError>;
+    readonly suspend: (input: LifecycleInput) => Effect.Effect<Workspace.WorkspaceLeaseRecord | undefined, WorkspaceRuntimeMissing | WorkspaceLeaseMissingRef | WorkspacePlannerError | WorkspaceProvider.WorkspaceNotFound | WorkspaceProvider.WorkspaceCapabilityUnsupported | WorkspaceProvider.WorkspaceProviderError>;
+    readonly resume: (input: LifecycleInput) => Effect.Effect<WorkspacePlan | undefined, WorkspaceRuntimeMissing | WorkspaceLeaseMissingRef | WorkspacePlannerError | WorkspaceProvider.WorkspaceNotFound | WorkspaceProvider.WorkspaceUnavailable | WorkspaceProvider.WorkspaceProviderError>;
+    readonly attach: (input: LifecycleInput) => Effect.Effect<WorkspacePlan | undefined, WorkspaceRuntimeMissing | WorkspaceLeaseMissingRef | WorkspacePlannerError | WorkspaceProvider.WorkspaceNotFound | WorkspaceProvider.WorkspaceUnavailable | WorkspaceProvider.WorkspaceProviderError>;
+    readonly release: (input: LifecycleInput) => Effect.Effect<Workspace.WorkspaceLeaseRecord | undefined, WorkspaceRuntimeMissing | WorkspaceLeaseMissingRef | WorkspacePlannerError | WorkspaceProvider.WorkspaceProviderError>;
+    readonly fail: (input: FailureInput) => Effect.Effect<Workspace.WorkspaceLeaseRecord | undefined, WorkspacePlannerError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/WorkspacePlanner", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const layer: Layer.Layer<Service, never, WorkspaceLeaseRepository.Service | EventLog.Service>;
+export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
+export declare const ensure: (input: EnsureInput) => Effect.Effect<WorkspacePlan | undefined, WorkspaceProvider.WorkspaceNotFound | WorkspaceProvider.WorkspaceUnavailable | WorkspaceProvider.WorkspaceProviderError | WorkspaceRuntimeMissing | WorkspaceLeaseMissingRef | WorkspacePlannerError, Service>;
+export declare const suspend: (input: LifecycleInput) => Effect.Effect<Workspace.WorkspaceLeaseRecord | undefined, WorkspaceProvider.WorkspaceNotFound | WorkspaceProvider.WorkspaceCapabilityUnsupported | WorkspaceProvider.WorkspaceProviderError | WorkspaceRuntimeMissing | WorkspaceLeaseMissingRef | WorkspacePlannerError, Service>;
+export declare const resume: (input: LifecycleInput) => Effect.Effect<WorkspacePlan | undefined, WorkspaceProvider.WorkspaceNotFound | WorkspaceProvider.WorkspaceUnavailable | WorkspaceProvider.WorkspaceProviderError | WorkspaceRuntimeMissing | WorkspaceLeaseMissingRef | WorkspacePlannerError, Service>;
+export declare const attach: (input: LifecycleInput) => Effect.Effect<WorkspacePlan | undefined, WorkspaceProvider.WorkspaceNotFound | WorkspaceProvider.WorkspaceUnavailable | WorkspaceProvider.WorkspaceProviderError | WorkspaceRuntimeMissing | WorkspaceLeaseMissingRef | WorkspacePlannerError, Service>;
+export declare const release: (input: LifecycleInput) => Effect.Effect<Workspace.WorkspaceLeaseRecord | undefined, WorkspaceProvider.WorkspaceProviderError | WorkspaceRuntimeMissing | WorkspaceLeaseMissingRef | WorkspacePlannerError, Service>;
+export declare const fail: (input: FailureInput) => Effect.Effect<Workspace.WorkspaceLeaseRecord | undefined, WorkspacePlannerError, Service>;
+export {};

package/dist/types/runtime/workspace/workspace-provider-service.d.ts

@@ -0,0 +1,108 @@
+import { Ids, Workspace } from "../../schema/index";
+import { Context, Effect, Layer, Schema } from "effect";
+declare const WorkspaceNotFound_base: Schema.Class<WorkspaceNotFound, Schema.TaggedStruct<"WorkspaceNotFound", {
+    readonly sandbox_ref: Schema.brand<Schema.String, "Relay.WorkspaceRef"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WorkspaceRef">;
+    };
+}>, import("effect/Cause").YieldableError>;
+export declare class WorkspaceNotFound extends WorkspaceNotFound_base {
+}
+declare const WorkspaceUnavailable_base: Schema.Class<WorkspaceUnavailable, Schema.TaggedStruct<"WorkspaceUnavailable", {
+    readonly sandbox_ref: Schema.brand<Schema.String, "Relay.WorkspaceRef"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WorkspaceRef">;
+    };
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class WorkspaceUnavailable extends WorkspaceUnavailable_base {
+}
+declare const WorkspaceCapabilityUnsupported_base: Schema.Class<WorkspaceCapabilityUnsupported, Schema.TaggedStruct<"WorkspaceCapabilityUnsupported", {
+    readonly capability: Schema.Literals<readonly ["suspend", "snapshot", "fork"]>;
+    readonly provider_key: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class WorkspaceCapabilityUnsupported extends WorkspaceCapabilityUnsupported_base {
+}
+declare const WorkspaceProviderError_base: Schema.Class<WorkspaceProviderError, Schema.TaggedStruct<"WorkspaceProviderError", {
+    readonly provider_key: Schema.String;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class WorkspaceProviderError extends WorkspaceProviderError_base {
+}
+export interface WorkspaceCommandInput {
+    readonly command: string;
+    readonly args?: ReadonlyArray<string>;
+    readonly cwd?: string;
+    readonly input?: string;
+}
+export interface WorkspaceCommandResult {
+    readonly exitCode: number;
+    readonly stdout: string;
+    readonly stderr: string;
+}
+export interface WorkspaceSpec {
+    readonly executionId: Ids.ExecutionId;
+    readonly request?: Workspace.WorkspaceRequest;
+}
+export interface WorkspaceHandle {
+    readonly ref: Ids.WorkspaceRef;
+    readonly providerKey: Workspace.WorkspaceProviderKey;
+    readonly capabilities: Workspace.WorkspaceCapabilities;
+    readonly readFile: (path: string) => Effect.Effect<string, WorkspaceNotFound | WorkspaceProviderError>;
+    readonly writeFile: (path: string, content: string) => Effect.Effect<void, WorkspaceNotFound | WorkspaceProviderError>;
+    readonly exec: (input: WorkspaceCommandInput) => Effect.Effect<WorkspaceCommandResult, WorkspaceProviderError>;
+}
+export interface Interface {
+    readonly providerKey: Workspace.WorkspaceProviderKey;
+    readonly capabilities: Workspace.WorkspaceCapabilities;
+    readonly acquire: (spec: WorkspaceSpec) => Effect.Effect<WorkspaceHandle, WorkspaceProviderError>;
+    readonly resume: (ref: Ids.WorkspaceRef) => Effect.Effect<WorkspaceHandle, WorkspaceNotFound | WorkspaceUnavailable | WorkspaceProviderError>;
+    readonly suspend: (ref: Ids.WorkspaceRef) => Effect.Effect<Ids.WorkspaceRef, WorkspaceNotFound | WorkspaceProviderError>;
+    readonly snapshot: (ref: Ids.WorkspaceRef, name?: string) => Effect.Effect<Ids.SnapshotRef, WorkspaceNotFound | WorkspaceCapabilityUnsupported | WorkspaceProviderError>;
+    readonly fork: (ref: Ids.WorkspaceRef, spec?: Partial<WorkspaceSpec>) => Effect.Effect<Ids.WorkspaceRef, WorkspaceNotFound | WorkspaceCapabilityUnsupported | WorkspaceProviderError>;
+    readonly destroy: (ref: Ids.WorkspaceRef) => Effect.Effect<void, WorkspaceProviderError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/WorkspaceProvider", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const memoryHandle: (ref: Ids.WorkspaceRef, providerKey?: Workspace.WorkspaceProviderKey) => WorkspaceHandle;
+export declare const memoryLayer: (providerKey?: Workspace.WorkspaceProviderKey) => Layer.Layer<Service, never, never>;
+export interface DaytonaSandbox {
+    readonly id: string;
+    state?: string;
+    readonly start: () => Effect.Effect<void, WorkspaceProviderError>;
+    readonly stop: () => Effect.Effect<void, WorkspaceProviderError>;
+    readonly readFile?: (path: string) => Effect.Effect<string, WorkspaceProviderError>;
+    readonly writeFile?: (path: string, content: string) => Effect.Effect<void, WorkspaceProviderError>;
+    readonly exec?: (input: WorkspaceCommandInput) => Effect.Effect<WorkspaceCommandResult, WorkspaceProviderError>;
+    readonly createSnapshot?: (name?: string) => Effect.Effect<string, WorkspaceProviderError>;
+    readonly fork?: () => Effect.Effect<string, WorkspaceProviderError>;
+}
+export interface DaytonaClient {
+    readonly create: (options: Record<string, unknown>) => Effect.Effect<DaytonaSandbox, WorkspaceProviderError>;
+    readonly get: (ref: Ids.WorkspaceRef) => Effect.Effect<DaytonaSandbox, WorkspaceNotFound | WorkspaceProviderError>;
+    readonly delete: (ref: Ids.WorkspaceRef) => Effect.Effect<void, WorkspaceProviderError>;
+}
+export interface DaytonaLayerConfig {
+    readonly providerKey?: Workspace.WorkspaceProviderKey;
+    readonly autoArchiveInterval?: number;
+    readonly client: DaytonaClient;
+}
+export declare const daytonaLayer: (config: DaytonaLayerConfig) => Layer.Layer<Service, never, never>;
+export interface LocalDockerCommand {
+    readonly args: ReadonlyArray<string>;
+    readonly input?: string;
+}
+export interface LocalDockerLayerConfig {
+    readonly providerKey?: Workspace.WorkspaceProviderKey;
+    readonly defaultImage: string;
+    readonly volumePrefix: string;
+    readonly run: (command: LocalDockerCommand) => Effect.Effect<WorkspaceCommandResult, WorkspaceProviderError>;
+}
+export declare const localDockerLayer: (config: LocalDockerLayerConfig) => Layer.Layer<Service, never, never>;
+export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
+export declare const acquire: (spec: WorkspaceSpec) => Effect.Effect<WorkspaceHandle, WorkspaceProviderError, Service>;
+export declare const resume: (ref: string & import("effect/Brand").Brand<"Relay.WorkspaceRef">) => Effect.Effect<WorkspaceHandle, WorkspaceNotFound | WorkspaceUnavailable | WorkspaceProviderError, Service>;
+export declare const suspend: (ref: string & import("effect/Brand").Brand<"Relay.WorkspaceRef">) => Effect.Effect<string & import("effect/Brand").Brand<"Relay.WorkspaceRef">, WorkspaceNotFound | WorkspaceProviderError, Service>;
+export declare const snapshot: (ref: string & import("effect/Brand").Brand<"Relay.WorkspaceRef">, name?: string | undefined) => Effect.Effect<string & import("effect/Brand").Brand<"Relay.SnapshotRef">, WorkspaceNotFound | WorkspaceCapabilityUnsupported | WorkspaceProviderError, Service>;
+export declare const fork: (ref: string & import("effect/Brand").Brand<"Relay.WorkspaceRef">, spec?: Partial<WorkspaceSpec> | undefined) => Effect.Effect<string & import("effect/Brand").Brand<"Relay.WorkspaceRef">, WorkspaceNotFound | WorkspaceCapabilityUnsupported | WorkspaceProviderError, Service>;
+export declare const destroy: (ref: string & import("effect/Brand").Brand<"Relay.WorkspaceRef">) => Effect.Effect<void, WorkspaceProviderError, Service>;
+export {};

package/dist/types/runtime/workspace/workspace-runtime-service.d.ts

@@ -0,0 +1,21 @@
+import { Context, Effect, Layer, Schema } from "effect";
+import * as WorkspaceProvider from "./workspace-provider-service";
+declare const WorkspaceRuntimeError_base: Schema.Class<WorkspaceRuntimeError, Schema.TaggedStruct<"WorkspaceRuntimeError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class WorkspaceRuntimeError extends WorkspaceRuntimeError_base {
+}
+export interface Interface {
+    readonly readFile: (path: string) => Effect.Effect<string, WorkspaceRuntimeError>;
+    readonly writeFile: (path: string, content: string) => Effect.Effect<void, WorkspaceRuntimeError>;
+    readonly exec: (input: WorkspaceProvider.WorkspaceCommandInput) => Effect.Effect<WorkspaceProvider.WorkspaceCommandResult, WorkspaceRuntimeError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/WorkspaceRuntime", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const layerFromHandle: (handle: WorkspaceProvider.WorkspaceHandle) => Layer.Layer<Service, never, never>;
+export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
+export declare const readFile: (path: string) => Effect.Effect<string, WorkspaceRuntimeError, Service>;
+export declare const writeFile: (path: string, content: string) => Effect.Effect<void, WorkspaceRuntimeError, Service>;
+export declare const exec: (input: WorkspaceProvider.WorkspaceCommandInput) => Effect.Effect<WorkspaceProvider.WorkspaceCommandResult, WorkspaceRuntimeError, Service>;
+export {};