@relayfx/test 0.3.1 → 0.3.2

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

@@ -1,78 +0,0 @@
-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.Finite>;
-    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

@@ -1,19 +0,0 @@
-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: {
-    (options?: {
-        readonly provider?: string;
-        readonly model?: string;
-    }): (turns: ReadonlyArray<ScriptedTurn>) => Effect.Effect<CapturedModel>;
-    (turns: ReadonlyArray<ScriptedTurn>, options?: {
-        readonly provider?: string;
-        readonly model?: string;
-    }): Effect.Effect<CapturedModel>;
-};

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

@@ -1,49 +0,0 @@
-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: {
-    (turns: ReadonlyArray<ScriptedTurn>): (cursor: Ref.Ref<number>) => Effect.Effect<ScriptedTurn>;
-    (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: {
-    (options?: {
-        readonly provider?: string;
-        readonly model?: string;
-        readonly registrationKey?: string;
-    }): (turns: ReadonlyArray<ScriptedTurn>) => RegistrationInput;
-    (turns: ReadonlyArray<ScriptedTurn>, options?: {
-        readonly provider?: string;
-        readonly model?: string;
-        readonly registrationKey?: string;
-    }): RegistrationInput;
-};