@relayfx/test 0.1.0

package/dist/types/schema/schedule-schema.d.ts

@@ -0,0 +1,79 @@
+import { Schema } from "effect";
+export declare const ScheduleKind: Schema.Literals<readonly ["once", "cron"]>;
+export type ScheduleKind = typeof ScheduleKind.Type;
+export declare const ScheduleTargetKind: Schema.Literals<readonly ["start-execution", "wake-wait", "timeout-wait"]>;
+export type ScheduleTargetKind = typeof ScheduleTargetKind.Type;
+export declare const ScheduleState: Schema.Literals<readonly ["active", "claimed", "completed", "cancelled", "failed"]>;
+export type ScheduleState = typeof ScheduleState.Type;
+export declare const ScheduleRecord: Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Relay.ScheduleId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ScheduleId">;
+    };
+    readonly kind: Schema.Literals<readonly ["once", "cron"]>;
+    readonly target_kind: Schema.Literals<readonly ["start-execution", "wake-wait", "timeout-wait"]>;
+    readonly address_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.AddressId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
+    }>;
+    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 cron_expr: Schema.optionalKey<Schema.String>;
+    readonly input: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"text">;
+        readonly text: Schema.String;
+        readonly provider_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>>>;
+    }>, 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 provider_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>>>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"blob-reference">;
+        readonly uri: Schema.String;
+        readonly media_type: Schema.String;
+        readonly filename: Schema.optionalKey<Schema.String>;
+        readonly provider_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>>>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"artifact-reference">;
+        readonly artifact_id: Schema.String;
+        readonly media_type: Schema.optionalKey<Schema.String>;
+        readonly provider_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>>>;
+    }>, 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 provider_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>>>;
+    }>, 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 provider_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 state: Schema.Literals<readonly ["active", "claimed", "completed", "cancelled", "failed"]>;
+    readonly next_run_at: Schema.Int;
+    readonly attempt: Schema.Int;
+    readonly last_error: Schema.optionalKey<Schema.String>;
+    readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    readonly created_at: Schema.Int;
+    readonly updated_at: Schema.Int;
+}>;
+export interface ScheduleRecord extends Schema.Schema.Type<typeof ScheduleRecord> {
+}

package/dist/types/schema/shared-schema.d.ts

@@ -0,0 +1,13 @@
+import { Schema } from "effect";
+export declare const ProtocolVersion: Schema.Literal<1>;
+export type ProtocolVersion = typeof ProtocolVersion.Type;
+export declare const JsonValue: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+export type JsonValue = typeof JsonValue.Type;
+export declare const Metadata: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+export type Metadata = typeof Metadata.Type;
+export declare const TimestampMillis: Schema.Int;
+export type TimestampMillis = typeof TimestampMillis.Type;
+export declare const NonEmptyString: Schema.String;
+export type NonEmptyString = typeof NonEmptyString.Type;
+export declare const canonicalValue: (value: unknown) => unknown;
+export declare const canonicalString: (value: unknown) => string;

package/dist/types/schema/skill-schema.d.ts

@@ -0,0 +1,260 @@
+import { Schema } from "effect";
+export declare const DefinitionRevision: Schema.Int;
+export type DefinitionRevision = typeof DefinitionRevision.Type;
+export declare const Frontmatter: Schema.Struct<{
+    readonly name: Schema.String;
+    readonly description: Schema.String;
+    readonly when_to_use: Schema.optionalKey<Schema.String>;
+    readonly allowed_tools: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    readonly disable_model_invocation: Schema.optionalKey<Schema.Boolean>;
+    readonly user_invocable: Schema.optionalKey<Schema.Boolean>;
+    readonly context_fork: Schema.optionalKey<Schema.Boolean>;
+    readonly agent: Schema.optionalKey<Schema.String>;
+    readonly model: Schema.optionalKey<Schema.String>;
+    readonly paths: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+}>;
+export interface Frontmatter extends Schema.Schema.Type<typeof Frontmatter> {
+}
+export declare const Definition: Schema.Struct<{
+    readonly frontmatter: Schema.Struct<{
+        readonly name: Schema.String;
+        readonly description: Schema.String;
+        readonly when_to_use: Schema.optionalKey<Schema.String>;
+        readonly allowed_tools: Schema.optionalKey<Schema.$Array<Schema.String>>;
+        readonly disable_model_invocation: Schema.optionalKey<Schema.Boolean>;
+        readonly user_invocable: Schema.optionalKey<Schema.Boolean>;
+        readonly context_fork: Schema.optionalKey<Schema.Boolean>;
+        readonly agent: Schema.optionalKey<Schema.String>;
+        readonly model: Schema.optionalKey<Schema.String>;
+        readonly paths: Schema.optionalKey<Schema.$Array<Schema.String>>;
+        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    }>;
+    readonly body: Schema.String;
+    readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+}>;
+export interface Definition extends Schema.Schema.Type<typeof Definition> {
+}
+export declare const DefinitionRecord: Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Relay.SkillDefinitionId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.SkillDefinitionId">;
+    };
+    readonly current_revision: Schema.Int;
+    readonly definition: Schema.Struct<{
+        readonly frontmatter: Schema.Struct<{
+            readonly name: Schema.String;
+            readonly description: Schema.String;
+            readonly when_to_use: Schema.optionalKey<Schema.String>;
+            readonly allowed_tools: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            readonly disable_model_invocation: Schema.optionalKey<Schema.Boolean>;
+            readonly user_invocable: Schema.optionalKey<Schema.Boolean>;
+            readonly context_fork: Schema.optionalKey<Schema.Boolean>;
+            readonly agent: Schema.optionalKey<Schema.String>;
+            readonly model: Schema.optionalKey<Schema.String>;
+            readonly paths: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        }>;
+        readonly body: Schema.String;
+        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    }>;
+    readonly created_at: Schema.Int;
+    readonly updated_at: Schema.Int;
+}>;
+export interface DefinitionRecord extends Schema.Schema.Type<typeof DefinitionRecord> {
+}
+export declare const DefinitionRevisionRecord: Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Relay.SkillDefinitionId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.SkillDefinitionId">;
+    };
+    readonly revision: Schema.Int;
+    readonly definition: Schema.Struct<{
+        readonly frontmatter: Schema.Struct<{
+            readonly name: Schema.String;
+            readonly description: Schema.String;
+            readonly when_to_use: Schema.optionalKey<Schema.String>;
+            readonly allowed_tools: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            readonly disable_model_invocation: Schema.optionalKey<Schema.Boolean>;
+            readonly user_invocable: Schema.optionalKey<Schema.Boolean>;
+            readonly context_fork: Schema.optionalKey<Schema.Boolean>;
+            readonly agent: Schema.optionalKey<Schema.String>;
+            readonly model: Schema.optionalKey<Schema.String>;
+            readonly paths: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        }>;
+        readonly body: Schema.String;
+        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    }>;
+    readonly created_at: Schema.Int;
+}>;
+export interface DefinitionRevisionRecord extends Schema.Schema.Type<typeof DefinitionRevisionRecord> {
+}
+export declare const ExecutionPinRecord: 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 skill_definition_id: Schema.brand<Schema.String, "Relay.SkillDefinitionId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.SkillDefinitionId">;
+    };
+    readonly skill_definition_revision: Schema.Int;
+    readonly skill_definition_snapshot: Schema.Struct<{
+        readonly frontmatter: Schema.Struct<{
+            readonly name: Schema.String;
+            readonly description: Schema.String;
+            readonly when_to_use: Schema.optionalKey<Schema.String>;
+            readonly allowed_tools: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            readonly disable_model_invocation: Schema.optionalKey<Schema.Boolean>;
+            readonly user_invocable: Schema.optionalKey<Schema.Boolean>;
+            readonly context_fork: Schema.optionalKey<Schema.Boolean>;
+            readonly agent: Schema.optionalKey<Schema.String>;
+            readonly model: Schema.optionalKey<Schema.String>;
+            readonly paths: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        }>;
+        readonly body: Schema.String;
+        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    }>;
+    readonly created_at: Schema.Int;
+}>;
+export interface ExecutionPinRecord extends Schema.Schema.Type<typeof ExecutionPinRecord> {
+}
+export declare const RegisterDefinitionPayload: Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Relay.SkillDefinitionId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.SkillDefinitionId">;
+    };
+    readonly definition: Schema.Struct<{
+        readonly frontmatter: Schema.Struct<{
+            readonly name: Schema.String;
+            readonly description: Schema.String;
+            readonly when_to_use: Schema.optionalKey<Schema.String>;
+            readonly allowed_tools: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            readonly disable_model_invocation: Schema.optionalKey<Schema.Boolean>;
+            readonly user_invocable: Schema.optionalKey<Schema.Boolean>;
+            readonly context_fork: Schema.optionalKey<Schema.Boolean>;
+            readonly agent: Schema.optionalKey<Schema.String>;
+            readonly model: Schema.optionalKey<Schema.String>;
+            readonly paths: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        }>;
+        readonly body: Schema.String;
+        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    }>;
+}>;
+export interface RegisterDefinitionPayload extends Schema.Schema.Type<typeof RegisterDefinitionPayload> {
+}
+export declare const DefinitionRegistered: Schema.Struct<{
+    readonly record: Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "Relay.SkillDefinitionId"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.SkillDefinitionId">;
+        };
+        readonly current_revision: Schema.Int;
+        readonly definition: Schema.Struct<{
+            readonly frontmatter: Schema.Struct<{
+                readonly name: Schema.String;
+                readonly description: Schema.String;
+                readonly when_to_use: Schema.optionalKey<Schema.String>;
+                readonly allowed_tools: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                readonly disable_model_invocation: Schema.optionalKey<Schema.Boolean>;
+                readonly user_invocable: Schema.optionalKey<Schema.Boolean>;
+                readonly context_fork: Schema.optionalKey<Schema.Boolean>;
+                readonly agent: Schema.optionalKey<Schema.String>;
+                readonly model: Schema.optionalKey<Schema.String>;
+                readonly paths: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+            }>;
+            readonly body: Schema.String;
+            readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        }>;
+        readonly created_at: Schema.Int;
+        readonly updated_at: Schema.Int;
+    }>;
+}>;
+export interface DefinitionRegistered extends Schema.Schema.Type<typeof DefinitionRegistered> {
+}
+export declare const DefinitionList: Schema.Struct<{
+    readonly records: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "Relay.SkillDefinitionId"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.SkillDefinitionId">;
+        };
+        readonly current_revision: Schema.Int;
+        readonly definition: Schema.Struct<{
+            readonly frontmatter: Schema.Struct<{
+                readonly name: Schema.String;
+                readonly description: Schema.String;
+                readonly when_to_use: Schema.optionalKey<Schema.String>;
+                readonly allowed_tools: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                readonly disable_model_invocation: Schema.optionalKey<Schema.Boolean>;
+                readonly user_invocable: Schema.optionalKey<Schema.Boolean>;
+                readonly context_fork: Schema.optionalKey<Schema.Boolean>;
+                readonly agent: Schema.optionalKey<Schema.String>;
+                readonly model: Schema.optionalKey<Schema.String>;
+                readonly paths: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+            }>;
+            readonly body: Schema.String;
+            readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        }>;
+        readonly created_at: Schema.Int;
+        readonly updated_at: Schema.Int;
+    }>>;
+}>;
+export interface DefinitionList extends Schema.Schema.Type<typeof DefinitionList> {
+}
+export declare const DefinitionRevisionList: Schema.Struct<{
+    readonly records: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "Relay.SkillDefinitionId"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.SkillDefinitionId">;
+        };
+        readonly revision: Schema.Int;
+        readonly definition: Schema.Struct<{
+            readonly frontmatter: Schema.Struct<{
+                readonly name: Schema.String;
+                readonly description: Schema.String;
+                readonly when_to_use: Schema.optionalKey<Schema.String>;
+                readonly allowed_tools: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                readonly disable_model_invocation: Schema.optionalKey<Schema.Boolean>;
+                readonly user_invocable: Schema.optionalKey<Schema.Boolean>;
+                readonly context_fork: Schema.optionalKey<Schema.Boolean>;
+                readonly agent: Schema.optionalKey<Schema.String>;
+                readonly model: Schema.optionalKey<Schema.String>;
+                readonly paths: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+            }>;
+            readonly body: Schema.String;
+            readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        }>;
+        readonly created_at: Schema.Int;
+    }>>;
+}>;
+export interface DefinitionRevisionList extends Schema.Schema.Type<typeof DefinitionRevisionList> {
+}
+export declare const ExecutionPinList: Schema.Struct<{
+    readonly records: Schema.$Array<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 skill_definition_id: Schema.brand<Schema.String, "Relay.SkillDefinitionId"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.SkillDefinitionId">;
+        };
+        readonly skill_definition_revision: Schema.Int;
+        readonly skill_definition_snapshot: Schema.Struct<{
+            readonly frontmatter: Schema.Struct<{
+                readonly name: Schema.String;
+                readonly description: Schema.String;
+                readonly when_to_use: Schema.optionalKey<Schema.String>;
+                readonly allowed_tools: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                readonly disable_model_invocation: Schema.optionalKey<Schema.Boolean>;
+                readonly user_invocable: Schema.optionalKey<Schema.Boolean>;
+                readonly context_fork: Schema.optionalKey<Schema.Boolean>;
+                readonly agent: Schema.optionalKey<Schema.String>;
+                readonly model: Schema.optionalKey<Schema.String>;
+                readonly paths: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+            }>;
+            readonly body: Schema.String;
+            readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        }>;
+        readonly created_at: Schema.Int;
+    }>>;
+}>;
+export interface ExecutionPinList extends Schema.Schema.Type<typeof ExecutionPinList> {
+}

package/dist/types/schema/state-schema.d.ts

@@ -0,0 +1,35 @@
+import { Schema } from "effect";
+export declare const StateKey: Schema.String;
+export type StateKey = typeof StateKey.Type;
+export declare const StateIdempotencyKey: Schema.String;
+export type StateIdempotencyKey = typeof StateIdempotencyKey.Type;
+export declare const StateVersion: Schema.Int;
+export type StateVersion = typeof StateVersion.Type;
+export declare const StateRecordView: Schema.Struct<{
+    readonly execution_id: Schema.brand<Schema.String, "Relay.ExecutionId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
+    };
+    readonly key: Schema.String;
+    readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly version: Schema.Int;
+    readonly created_at: Schema.Int;
+    readonly updated_at: Schema.Int;
+}>;
+export interface StateRecordView extends Schema.Schema.Type<typeof StateRecordView> {
+}
+export declare const StateUpdatedEventData: Schema.Union<readonly [Schema.Struct<{
+    readonly key: Schema.String;
+    readonly version: Schema.Int;
+    readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>, Schema.Struct<{
+    readonly key: Schema.String;
+    readonly version: Schema.Int;
+    readonly blob_ref: Schema.String;
+}>]>;
+export type StateUpdatedEventData = typeof StateUpdatedEventData.Type;
+export declare const StateDeletedEventData: Schema.Struct<{
+    readonly key: Schema.String;
+    readonly version: Schema.Int;
+}>;
+export interface StateDeletedEventData extends Schema.Schema.Type<typeof StateDeletedEventData> {
+}

package/dist/types/schema/tool-schema.d.ts

@@ -0,0 +1,84 @@
+import { Schema } from "effect";
+import { JsonValue } from "./shared-schema";
+export declare const Permission: 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>>>;
+}>;
+export interface Permission extends Schema.Schema.Type<typeof Permission> {
+}
+export declare const RuntimeRequirement: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"workspace">;
+    readonly mode: Schema.Literals<readonly ["read", "write", "exec"]>;
+}>]>;
+export interface RuntimeRequirement extends Schema.Schema.Type<typeof RuntimeRequirement> {
+}
+export declare const PlacementKey: Schema.String;
+export type PlacementKey = typeof PlacementKey.Type;
+export declare const WorkerId: Schema.String;
+export type WorkerId = typeof WorkerId.Type;
+export declare const Placement: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"local">;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"client">;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"remote">;
+    readonly queue: Schema.String;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"mcp">;
+    readonly server_id: Schema.String;
+}>]>;
+export type Placement = typeof Placement.Type;
+export declare const ExternalOutcome: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"success">;
+    readonly output: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"failure">;
+    readonly message: Schema.String;
+}>]>;
+export type ExternalOutcome = typeof ExternalOutcome.Type;
+export declare const CallState: Schema.Literals<readonly ["requested", "waiting", "running", "submitted", "completed", "failed"]>;
+export type CallState = typeof CallState.Type;
+export declare const AttemptState: Schema.Literals<readonly ["running", "completed", "failed", "released", "expired", "abandoned"]>;
+export type AttemptState = typeof AttemptState.Type;
+export declare const Definition: Schema.Struct<{
+    readonly name: Schema.String;
+    readonly description: Schema.String;
+    readonly input_schema: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly output_schema: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    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 requirements: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"workspace">;
+        readonly mode: Schema.Literals<readonly ["read", "write", "exec"]>;
+    }>]>>>;
+    readonly needs_approval: Schema.optionalKey<Schema.Boolean>;
+    readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+}>;
+export interface Definition extends Schema.Schema.Type<typeof Definition> {
+}
+export declare const 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>>>;
+}>;
+export interface Call extends Schema.Schema.Type<typeof Call> {
+}
+export declare const 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>>>;
+}>;
+export interface Result extends Schema.Schema.Type<typeof Result> {
+}
+export declare const parametersSchema: (inputSchema: JsonValue) => Schema.Top;
+export declare const resultSchema: (outputSchema: JsonValue) => Schema.Codec<unknown>;

package/dist/types/schema/workspace-schema.d.ts

@@ -0,0 +1,78 @@
+import { Schema } from "effect";
+export declare const WorkspaceProviderKey: Schema.String;
+export type WorkspaceProviderKey = typeof WorkspaceProviderKey.Type;
+export declare const WorkspaceLeaseStatus: Schema.Literals<readonly ["planned", "running", "suspended", "snapshotted", "archived", "released", "failed"]>;
+export type WorkspaceLeaseStatus = typeof WorkspaceLeaseStatus.Type;
+export declare const WorkspaceResumeStrategy: Schema.Literals<readonly ["reattach", "restore_snapshot"]>;
+export type WorkspaceResumeStrategy = typeof WorkspaceResumeStrategy.Type;
+export declare const WorkspaceCapabilities: Schema.Struct<{
+    readonly can_suspend: Schema.Boolean;
+    readonly can_snapshot: Schema.Boolean;
+    readonly can_fork: Schema.Boolean;
+    readonly persistent_by_default: Schema.Boolean;
+    readonly suspend_granularity: Schema.Literals<readonly ["memory", "filesystem", "none"]>;
+    readonly max_suspend_duration_ms: Schema.optionalKey<Schema.Number>;
+    readonly reattach_by_ref: Schema.Boolean;
+}>;
+export interface WorkspaceCapabilities extends Schema.Schema.Type<typeof WorkspaceCapabilities> {
+}
+export declare const WorkspaceRequest: Schema.Struct<{
+    readonly provider_key: Schema.optionalKey<Schema.String>;
+    readonly resume_snapshot_ref: Schema.optionalKey<Schema.brand<Schema.String, "Relay.SnapshotRef"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.SnapshotRef">;
+    }>;
+    readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+}>;
+export interface WorkspaceRequest extends Schema.Schema.Type<typeof WorkspaceRequest> {
+}
+export declare const WorkspaceLeaseRecord: Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Relay.WorkspaceLeaseId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WorkspaceLeaseId">;
+    };
+    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 provider_key: Schema.String;
+    readonly sandbox_ref: Schema.optionalKey<Schema.brand<Schema.String, "Relay.WorkspaceRef"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WorkspaceRef">;
+    }>;
+    readonly latest_snapshot_ref: Schema.optionalKey<Schema.brand<Schema.String, "Relay.SnapshotRef"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.SnapshotRef">;
+    }>;
+    readonly status: Schema.Literals<readonly ["planned", "running", "suspended", "snapshotted", "archived", "released", "failed"]>;
+    readonly resume_strategy: Schema.Literals<readonly ["reattach", "restore_snapshot"]>;
+    readonly region: Schema.optionalKey<Schema.String>;
+    readonly request: Schema.optionalKey<Schema.Struct<{
+        readonly provider_key: Schema.optionalKey<Schema.String>;
+        readonly resume_snapshot_ref: Schema.optionalKey<Schema.brand<Schema.String, "Relay.SnapshotRef"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.SnapshotRef">;
+        }>;
+        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 created_at: Schema.Int;
+    readonly updated_at: Schema.Int;
+}>;
+export interface WorkspaceLeaseRecord extends Schema.Schema.Type<typeof WorkspaceLeaseRecord> {
+}
+export declare const WorkspaceSnapshotReason: Schema.Literals<readonly ["before_wait", "before_child_fork", "on_complete", "on_failure", "manual"]>;
+export type WorkspaceSnapshotReason = typeof WorkspaceSnapshotReason.Type;
+export declare const WorkspaceSnapshotRecord: Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Relay.WorkspaceSnapshotId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WorkspaceSnapshotId">;
+    };
+    readonly lease_id: Schema.brand<Schema.String, "Relay.WorkspaceLeaseId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WorkspaceLeaseId">;
+    };
+    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 reason: Schema.Literals<readonly ["before_wait", "before_child_fork", "on_complete", "on_failure", "manual"]>;
+    readonly snapshot_ref: Schema.brand<Schema.String, "Relay.SnapshotRef"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.SnapshotRef">;
+    };
+    readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    readonly created_at: Schema.Int;
+}>;
+export interface WorkspaceSnapshotRecord extends Schema.Schema.Type<typeof WorkspaceSnapshotRecord> {
+}

package/dist/types/test/captured-model.d.ts

@@ -0,0 +1,13 @@
+import { Effect, Layer } from "effect";
+import { LanguageModel } from "effect/unstable/ai";
+import type { Prompt } from "effect/unstable/ai/Prompt";
+import type { RegistrationInput, ScriptedTurn } from "./scripted-model";
+export interface CapturedModel {
+    readonly layer: Layer.Layer<LanguageModel.LanguageModel>;
+    readonly registration: RegistrationInput;
+    readonly prompts: Effect.Effect<ReadonlyArray<Prompt>>;
+}
+export declare const make: (turns: ReadonlyArray<ScriptedTurn>, options?: {
+    readonly provider?: string;
+    readonly model?: string;
+}) => Effect.Effect<CapturedModel>;

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

@@ -0,0 +1,6 @@
+export * as ScriptedModel from "./scripted-model";
+export * as CapturedModel from "./captured-model";
+export * as TestTools from "./test-tools";
+export * as TestRuntime from "./test-runtime";
+export * as WaitTestKit from "./wait-test-kit";
+export declare const testPackage = "@relayfx/test";

package/dist/types/test/scripted-model.d.ts

@@ -0,0 +1,39 @@
+import { LanguageModelService } from "../runtime/index";
+import type { Shared } from "../schema/index";
+import { Effect, Layer, Ref } from "effect";
+import { LanguageModel } from "effect/unstable/ai";
+import type { PartEncoded, StreamPartEncoded } from "effect/unstable/ai/Response";
+export type RegistrationInput = LanguageModelService.Registration;
+export interface ScriptedTurn {
+    readonly text?: string;
+    readonly toolCalls?: ReadonlyArray<{
+        readonly id: string;
+        readonly name: string;
+        readonly params: Shared.JsonValue;
+    }>;
+}
+export declare const streamParts: (turn: ScriptedTurn) => ReadonlyArray<StreamPartEncoded>;
+export declare const responseParts: (turn: ScriptedTurn) => ReadonlyArray<PartEncoded>;
+export declare const nextTurn: (cursor: Ref.Ref<number>, turns: ReadonlyArray<ScriptedTurn>) => Effect.Effect<ScriptedTurn>;
+/**
+ * Layer producing an `Ai.LanguageModel` that plays `turns` in order; each
+ * `streamText`/`generateText` call consumes one turn. Fails with a defect if
+ * called more times than turns provided.
+ *
+ * The cursor is created once per `layer(turns)` call and shared across every
+ * build of the returned layer. This matters because the agent loop rebuilds the
+ * model layer once per model turn (`provideForAgent`); a per-build cursor would
+ * reset every turn. One `layer(turns)` value therefore drives one linear script.
+ * @experimental
+ */
+export declare const layer: (turns: ReadonlyArray<ScriptedTurn>) => Layer.Layer<LanguageModel.LanguageModel>;
+/**
+ * The same scripted model wrapped as a `LanguageModelService` registration
+ * (default provider `"test"`, model `"scripted"`).
+ * @experimental
+ */
+export declare const registration: (turns: ReadonlyArray<ScriptedTurn>, options?: {
+    readonly provider?: string;
+    readonly model?: string;
+    readonly registrationKey?: string;
+}) => RegistrationInput;

package/dist/types/test/test-runtime.d.ts

@@ -0,0 +1,9 @@
+import { RunnerRuntime, ToolRuntime } from "../runtime/index";
+import { Layer } from "effect";
+import { LanguageModel } from "effect/unstable/ai";
+import type { ScriptedTurn } from "./scripted-model";
+export declare const layer: typeof RunnerRuntime.testLayer;
+export declare const layerWith: (options: {
+    readonly model?: Layer.Layer<LanguageModel.LanguageModel> | ReadonlyArray<ScriptedTurn>;
+    readonly tools?: ReadonlyArray<ToolRuntime.RegisteredTool>;
+}) => typeof RunnerRuntime.testLayer;