@relayfx/test 0.3.1 → 0.3.3

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

@@ -1,106 +0,0 @@
-import { Schema } from "effect";
-export declare const AddressId: Schema.brand<Schema.String, "Relay.AddressId"> & {
-    make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
-};
-export type AddressId = typeof AddressId.Type;
-export declare const TenantId: Schema.brand<Schema.String, "Relay.TenantId"> & {
-    make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.TenantId">;
-};
-export type TenantId = typeof TenantId.Type;
-export declare const SystemTenantId: string & import("effect/Brand").Brand<"Relay.TenantId">;
-export declare const AddressBookEntryId: Schema.brand<Schema.String, "Relay.AddressBookEntryId"> & {
-    make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressBookEntryId">;
-};
-export type AddressBookEntryId = typeof AddressBookEntryId.Type;
-export declare const AgentId: Schema.brand<Schema.String, "Relay.AgentId"> & {
-    make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentId">;
-};
-export type AgentId = typeof AgentId.Type;
-export declare const WorkflowDefinitionId: Schema.brand<Schema.String, "Relay.WorkflowDefinitionId"> & {
-    make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WorkflowDefinitionId">;
-};
-export type WorkflowDefinitionId = typeof WorkflowDefinitionId.Type;
-export declare const WorkflowOperationId: Schema.brand<Schema.String, "Relay.WorkflowOperationId"> & {
-    make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WorkflowOperationId">;
-};
-export type WorkflowOperationId = typeof WorkflowOperationId.Type;
-export declare const EntityKindName: Schema.brand<Schema.String, "Relay.EntityKindName"> & {
-    make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EntityKindName">;
-};
-export type EntityKindName = typeof EntityKindName.Type;
-export declare const EntityKey: Schema.brand<Schema.String, "Relay.EntityKey"> & {
-    make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EntityKey">;
-};
-export type EntityKey = typeof EntityKey.Type;
-export declare const SkillDefinitionId: Schema.brand<Schema.String, "Relay.SkillDefinitionId"> & {
-    make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.SkillDefinitionId">;
-};
-export type SkillDefinitionId = typeof SkillDefinitionId.Type;
-export declare const EnvelopeId: Schema.brand<Schema.String, "Relay.EnvelopeId"> & {
-    make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EnvelopeId">;
-};
-export type EnvelopeId = typeof EnvelopeId.Type;
-export declare const EnvelopeReadyId: Schema.brand<Schema.String, "Relay.EnvelopeReadyId"> & {
-    make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EnvelopeReadyId">;
-};
-export type EnvelopeReadyId = typeof EnvelopeReadyId.Type;
-export declare const ExecutionId: Schema.brand<Schema.String, "Relay.ExecutionId"> & {
-    make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
-};
-export type ExecutionId = typeof ExecutionId.Type;
-export declare const ChildExecutionId: Schema.brand<Schema.String, "Relay.ChildExecutionId"> & {
-    make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ChildExecutionId">;
-};
-export type ChildExecutionId = typeof ChildExecutionId.Type;
-export declare const ChildFanOutId: Schema.brand<Schema.String, "Relay.ChildFanOutId"> & {
-    make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ChildFanOutId">;
-};
-export type ChildFanOutId = typeof ChildFanOutId.Type;
-export declare const MemorySubjectId: Schema.brand<Schema.String, "Relay.MemorySubjectId"> & {
-    make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.MemorySubjectId">;
-};
-export type MemorySubjectId = typeof MemorySubjectId.Type;
-export declare const SessionId: Schema.brand<Schema.String, "Relay.SessionId"> & {
-    make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.SessionId">;
-};
-export type SessionId = typeof SessionId.Type;
-export declare const SessionEntryId: Schema.brand<Schema.String, "Relay.SessionEntryId"> & {
-    make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.SessionEntryId">;
-};
-export type SessionEntryId = typeof SessionEntryId.Type;
-export declare const WorkspaceLeaseId: Schema.brand<Schema.String, "Relay.WorkspaceLeaseId"> & {
-    make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WorkspaceLeaseId">;
-};
-export type WorkspaceLeaseId = typeof WorkspaceLeaseId.Type;
-export declare const WorkspaceSnapshotId: Schema.brand<Schema.String, "Relay.WorkspaceSnapshotId"> & {
-    make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WorkspaceSnapshotId">;
-};
-export type WorkspaceSnapshotId = typeof WorkspaceSnapshotId.Type;
-export declare const WorkspaceRef: Schema.brand<Schema.String, "Relay.WorkspaceRef"> & {
-    make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WorkspaceRef">;
-};
-export type WorkspaceRef = typeof WorkspaceRef.Type;
-export declare const SnapshotRef: Schema.brand<Schema.String, "Relay.SnapshotRef"> & {
-    make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.SnapshotRef">;
-};
-export type SnapshotRef = typeof SnapshotRef.Type;
-export declare const ToolCallId: Schema.brand<Schema.String, "Relay.ToolCallId"> & {
-    make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ToolCallId">;
-};
-export type ToolCallId = typeof ToolCallId.Type;
-export declare const ToolAttemptId: Schema.brand<Schema.String, "Relay.ToolAttemptId"> & {
-    make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ToolAttemptId">;
-};
-export type ToolAttemptId = typeof ToolAttemptId.Type;
-export declare const WaitId: Schema.brand<Schema.String, "Relay.WaitId"> & {
-    make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WaitId">;
-};
-export type WaitId = typeof WaitId.Type;
-export declare const ScheduleId: Schema.brand<Schema.String, "Relay.ScheduleId"> & {
-    make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ScheduleId">;
-};
-export type ScheduleId = typeof ScheduleId.Type;
-export declare const EventId: Schema.brand<Schema.String, "Relay.EventId"> & {
-    make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EventId">;
-};
-export type EventId = typeof EventId.Type;

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

@@ -1,81 +0,0 @@
-import { Schema } from "effect";
-export declare const MessageSequence: Schema.Int;
-export type MessageSequence = typeof MessageSequence.Type;
-export declare const Message: 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 sequence: Schema.Int;
-    readonly from: Schema.brand<Schema.String, "Relay.AddressId"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
-    };
-    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 content: 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 reply_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 correlation_key: Schema.optionalKey<Schema.String>;
-    readonly idempotency_key: Schema.optionalKey<Schema.String>;
-    readonly drain_id: Schema.optionalKey<Schema.String>;
-    readonly consumed_at: Schema.optionalKey<Schema.Int>;
-    readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
-    readonly created_at: Schema.Int;
-}>;
-export interface Message extends Schema.Schema.Type<typeof Message> {
-}
-export declare const InboxPolicy: Schema.Struct<{
-    readonly drain: Schema.Literals<readonly ["all", "one"]>;
-    readonly max_batch: Schema.optionalKey<Schema.Int>;
-}>;
-export interface InboxPolicy extends Schema.Schema.Type<typeof InboxPolicy> {
-}

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

@@ -1,19 +0,0 @@
-export * as Address from "./address-schema";
-export * as Agent from "./agent-schema";
-export * as ChildOrchestration from "./child-orchestration-schema";
-export * as Content from "./content-schema";
-export * as Envelope from "./envelope-schema";
-export * as Entity from "./entity-schema";
-export * as Execution from "./execution-schema";
-export * as Ids from "./ids-schema";
-export * as Inbox from "./inbox-schema";
-export * as Presence from "./presence-schema";
-export * as Schedule from "./schedule-schema";
-export * as Shared from "./shared-schema";
-export * as Skill from "./skill-schema";
-export * as State from "./state-schema";
-export * as Tool from "./tool-schema";
-export * as Waits from "./wait-schema";
-export * as Workflow from "./workflow-schema";
-export * as Workspace from "./workspace-schema";
-export declare const schemaPackage = "./index";

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

@@ -1,28 +0,0 @@
-import { Schema } from "effect";
-export declare const Scope: Schema.Struct<{
-    readonly kind: Schema.Literals<readonly ["execution", "session"]>;
-    readonly id: Schema.String;
-}>;
-export interface Scope extends Schema.Schema.Type<typeof Scope> {
-}
-export declare const Entry: Schema.Struct<{
-    readonly id: Schema.String;
-    readonly metadata: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
-    readonly connected_at: Schema.Int;
-}>;
-export interface Entry extends Schema.Schema.Type<typeof Entry> {
-}
-export declare const View: Schema.Struct<{
-    readonly scope: Schema.Struct<{
-        readonly kind: Schema.Literals<readonly ["execution", "session"]>;
-        readonly id: Schema.String;
-    }>;
-    readonly entries: Schema.$Array<Schema.Struct<{
-        readonly id: Schema.String;
-        readonly metadata: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
-        readonly connected_at: Schema.Int;
-    }>>;
-    readonly observed_at: Schema.Int;
-}>;
-export interface View extends Schema.Schema.Type<typeof View> {
-}

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

@@ -1,79 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,260 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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> {
-}