@relayfx/sdk 0.0.6 → 0.0.7

package/dist/types/store-sql/session/context-epoch-repository.d.ts

@@ -0,0 +1,33 @@
+import { Ids } from "../../schema/index";
+import { Context, Effect, Layer, Schema } from "effect";
+import * as Database from "../database/database-service";
+declare const ContextEpochRepositoryError_base: Schema.Class<ContextEpochRepositoryError, Schema.TaggedStruct<"ContextEpochRepositoryError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class ContextEpochRepositoryError extends ContextEpochRepositoryError_base {
+}
+export interface ContextEpochRecord {
+    readonly executionId: Ids.ExecutionId;
+    readonly baseline: string;
+    readonly dynamicSourceIds: ReadonlyArray<string>;
+    readonly openedAt: number;
+}
+export interface SaveInput {
+    readonly executionId: Ids.ExecutionId;
+    readonly baseline: string;
+    readonly dynamicSourceIds: ReadonlyArray<string>;
+    readonly openedAt: number;
+}
+export interface Interface {
+    readonly save: (input: SaveInput) => Effect.Effect<ContextEpochRecord, ContextEpochRepositoryError>;
+    readonly get: (executionId: Ids.ExecutionId) => Effect.Effect<ContextEpochRecord | undefined, ContextEpochRepositoryError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/ContextEpochRepository", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const layer: Layer.Layer<Service, never, Database.Service>;
+export declare const memoryLayer: Layer.Layer<Service, never, never>;
+export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
+export declare const save: (input: SaveInput) => Effect.Effect<ContextEpochRecord, ContextEpochRepositoryError, Service>;
+export declare const get: (executionId: string & import("effect/Brand").Brand<"Relay.ExecutionId">) => Effect.Effect<ContextEpochRecord | undefined, ContextEpochRepositoryError, Service>;
+export {};

package/dist/types/store-sql/session/session-repository.d.ts

@@ -0,0 +1,138 @@
+import { Ids, Shared } from "../../schema/index";
+import { Context, Effect, Layer, Schema } from "effect";
+import type * as Ai from "effect/unstable/ai";
+import * as Database from "../database/database-service";
+declare const SessionRepositoryError_base: Schema.Class<SessionRepositoryError, Schema.TaggedStruct<"SessionRepositoryError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class SessionRepositoryError extends SessionRepositoryError_base {
+}
+declare const DuplicateSession_base: Schema.Class<DuplicateSession, Schema.TaggedStruct<"DuplicateSession", {
+    readonly id: Schema.brand<Schema.String, "Relay.SessionId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.SessionId">;
+    };
+}>, import("effect/Cause").YieldableError>;
+export declare class DuplicateSession extends DuplicateSession_base {
+}
+export interface SessionRecord {
+    readonly id: Ids.SessionId;
+    readonly rootAddressId: Ids.AddressId;
+    readonly leafEntryId?: Ids.SessionEntryId;
+    readonly metadata: Shared.Metadata;
+    readonly createdAt: number;
+    readonly updatedAt: number;
+}
+export interface CreateSessionInput {
+    readonly id: Ids.SessionId;
+    readonly rootAddressId: Ids.AddressId;
+    readonly metadata?: Shared.Metadata;
+    readonly createdAt: number;
+}
+export interface EnsureSessionInput {
+    readonly id: Ids.SessionId;
+    readonly rootAddressId: Ids.AddressId;
+    readonly metadata?: Shared.Metadata;
+    readonly now: number;
+}
+export interface TouchSessionInput {
+    readonly id: Ids.SessionId;
+    readonly updatedAt: number;
+}
+export interface SessionCursor {
+    readonly updatedAt: number;
+    readonly id: Ids.SessionId;
+}
+export interface ListSessionsInput {
+    readonly rootAddressId?: Ids.AddressId;
+    readonly limit?: number;
+    readonly cursor?: SessionCursor;
+}
+export interface ListSessionsResult {
+    readonly records: ReadonlyArray<SessionRecord>;
+    readonly nextCursor?: SessionCursor;
+}
+export type AppendSessionEntryInput = {
+    readonly _tag: "Message";
+    readonly message: Ai.Prompt.Message;
+    readonly metadata?: Shared.Metadata;
+} | {
+    readonly _tag: "Compaction";
+    readonly summary: string;
+    readonly firstKeptEntryId: Ids.SessionEntryId;
+    readonly metadata?: Shared.Metadata;
+} | {
+    readonly _tag: "BranchSummary";
+    readonly summary: string;
+    readonly metadata?: Shared.Metadata;
+};
+export type SessionEntryRecord = {
+    readonly id: Ids.SessionEntryId;
+    readonly sessionId: Ids.SessionId;
+    readonly parentId: Ids.SessionEntryId | null;
+    readonly _tag: "Message";
+    readonly message: Ai.Prompt.Message;
+    readonly metadata?: Shared.Metadata;
+    readonly createdAt: number;
+} | {
+    readonly id: Ids.SessionEntryId;
+    readonly sessionId: Ids.SessionId;
+    readonly parentId: Ids.SessionEntryId | null;
+    readonly _tag: "Compaction";
+    readonly summary: string;
+    readonly firstKeptEntryId: Ids.SessionEntryId;
+    readonly metadata?: Shared.Metadata;
+    readonly createdAt: number;
+} | {
+    readonly id: Ids.SessionEntryId;
+    readonly sessionId: Ids.SessionId;
+    readonly parentId: Ids.SessionEntryId | null;
+    readonly _tag: "BranchSummary";
+    readonly summary: string;
+    readonly metadata?: Shared.Metadata;
+    readonly createdAt: number;
+};
+export interface AppendEntryInput {
+    readonly id: Ids.SessionEntryId;
+    readonly sessionId: Ids.SessionId;
+    readonly parentId: Ids.SessionEntryId | null;
+    readonly input: AppendSessionEntryInput;
+    readonly createdAt: number;
+}
+export interface PathInput {
+    readonly sessionId: Ids.SessionId;
+    readonly leafId?: Ids.SessionEntryId;
+}
+export interface SetLeafInput {
+    readonly sessionId: Ids.SessionId;
+    readonly id: Ids.SessionEntryId | null;
+    readonly updatedAt: number;
+}
+export interface Interface {
+    readonly create: (input: CreateSessionInput) => Effect.Effect<SessionRecord, DuplicateSession | SessionRepositoryError>;
+    readonly ensure: (input: EnsureSessionInput) => Effect.Effect<SessionRecord, SessionRepositoryError>;
+    readonly get: (id: Ids.SessionId) => Effect.Effect<SessionRecord | undefined, SessionRepositoryError>;
+    readonly list: (input: ListSessionsInput) => Effect.Effect<ListSessionsResult, SessionRepositoryError>;
+    readonly touch: (input: TouchSessionInput) => Effect.Effect<SessionRecord, SessionRepositoryError>;
+    readonly appendEntry: (input: AppendEntryInput) => Effect.Effect<SessionEntryRecord, SessionRepositoryError>;
+    readonly countEntries: (sessionId: Ids.SessionId) => Effect.Effect<number, SessionRepositoryError>;
+    readonly path: (input: PathInput) => Effect.Effect<ReadonlyArray<SessionEntryRecord>, SessionRepositoryError>;
+    readonly setLeaf: (input: SetLeafInput) => Effect.Effect<void, SessionRepositoryError>;
+    readonly leaf: (sessionId: Ids.SessionId) => Effect.Effect<Ids.SessionEntryId | null, SessionRepositoryError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/SessionRepository", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const layer: Layer.Layer<Service, never, Database.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: CreateSessionInput) => Effect.Effect<SessionRecord, SessionRepositoryError | DuplicateSession, Service>;
+export declare const ensure: (input: EnsureSessionInput) => Effect.Effect<SessionRecord, SessionRepositoryError, Service>;
+export declare const get: (id: string & import("effect/Brand").Brand<"Relay.SessionId">) => Effect.Effect<SessionRecord | undefined, SessionRepositoryError, Service>;
+export declare const list: (input: ListSessionsInput) => Effect.Effect<ListSessionsResult, SessionRepositoryError, Service>;
+export declare const touch: (input: TouchSessionInput) => Effect.Effect<SessionRecord, SessionRepositoryError, Service>;
+export declare const appendEntry: (input: AppendEntryInput) => Effect.Effect<SessionEntryRecord, SessionRepositoryError, Service>;
+export declare const countEntries: (sessionId: string & import("effect/Brand").Brand<"Relay.SessionId">) => Effect.Effect<number, SessionRepositoryError, Service>;
+export declare const path: (input: PathInput) => Effect.Effect<readonly SessionEntryRecord[], SessionRepositoryError, Service>;
+export declare const setLeaf: (input: SetLeafInput) => Effect.Effect<void, SessionRepositoryError, Service>;
+export declare const leaf: (sessionId: string & import("effect/Brand").Brand<"Relay.SessionId">) => Effect.Effect<(string & import("effect/Brand").Brand<"Relay.SessionEntryId">) | null, SessionRepositoryError, Service>;
+export {};

package/dist/types/store-sql/skill/skill-definition-repository.d.ts

@@ -0,0 +1,71 @@
+import { Ids, Skill } from "../../schema/index";
+import { Context, Effect, Layer, Schema } from "effect";
+import * as Database from "../database/database-service";
+declare const SkillDefinitionRepositoryError_base: Schema.Class<SkillDefinitionRepositoryError, Schema.TaggedStruct<"SkillDefinitionRepositoryError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class SkillDefinitionRepositoryError extends SkillDefinitionRepositoryError_base {
+}
+export interface SkillDefinitionRecord {
+    readonly id: Ids.SkillDefinitionId;
+    readonly currentRevision: Skill.DefinitionRevision;
+    readonly definition: Skill.Definition;
+    readonly createdAt: number;
+    readonly updatedAt: number;
+}
+export interface SkillDefinitionRevisionRecord {
+    readonly id: Ids.SkillDefinitionId;
+    readonly revision: Skill.DefinitionRevision;
+    readonly definition: Skill.Definition;
+    readonly createdAt: number;
+}
+export interface ExecutionSkillPinRecord {
+    readonly executionId: Ids.ExecutionId;
+    readonly skillDefinitionId: Ids.SkillDefinitionId;
+    readonly skillDefinitionRevision: Skill.DefinitionRevision;
+    readonly skillDefinitionSnapshot: Skill.Definition;
+    readonly createdAt: number;
+}
+export interface PutSkillDefinitionInput {
+    readonly id: Ids.SkillDefinitionId;
+    readonly definition: Skill.Definition;
+    readonly now: number;
+}
+export interface GetSkillDefinitionRevisionInput {
+    readonly id: Ids.SkillDefinitionId;
+    readonly revision: Skill.DefinitionRevision;
+}
+export interface PinExecutionSkillsInput {
+    readonly executionId: Ids.ExecutionId;
+    readonly skillDefinitionIds: ReadonlyArray<Ids.SkillDefinitionId>;
+    readonly now: number;
+}
+export interface GetPinnedSkillInput {
+    readonly executionId: Ids.ExecutionId;
+    readonly skillDefinitionId: Ids.SkillDefinitionId;
+}
+export interface Interface {
+    readonly put: (input: PutSkillDefinitionInput) => Effect.Effect<SkillDefinitionRecord, SkillDefinitionRepositoryError>;
+    readonly get: (id: Ids.SkillDefinitionId) => Effect.Effect<SkillDefinitionRecord | undefined, SkillDefinitionRepositoryError>;
+    readonly getRevision: (input: GetSkillDefinitionRevisionInput) => Effect.Effect<SkillDefinitionRevisionRecord | undefined, SkillDefinitionRepositoryError>;
+    readonly list: () => Effect.Effect<ReadonlyArray<SkillDefinitionRecord>, SkillDefinitionRepositoryError>;
+    readonly listRevisions: (id: Ids.SkillDefinitionId) => Effect.Effect<ReadonlyArray<SkillDefinitionRevisionRecord>, SkillDefinitionRepositoryError>;
+    readonly pinExecution: (input: PinExecutionSkillsInput) => Effect.Effect<ReadonlyArray<ExecutionSkillPinRecord>, SkillDefinitionRepositoryError>;
+    readonly listPins: (executionId: Ids.ExecutionId) => Effect.Effect<ReadonlyArray<ExecutionSkillPinRecord>, SkillDefinitionRepositoryError>;
+    readonly getPinned: (input: GetPinnedSkillInput) => Effect.Effect<ExecutionSkillPinRecord | undefined, SkillDefinitionRepositoryError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/SkillDefinitionRepository", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const layer: Layer.Layer<Service, never, Database.Service>;
+export declare const memoryLayer: Layer.Layer<Service, never, never>;
+export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
+export declare const put: (input: PutSkillDefinitionInput) => Effect.Effect<SkillDefinitionRecord, SkillDefinitionRepositoryError, Service>;
+export declare const get: (id: string & import("effect/Brand").Brand<"Relay.SkillDefinitionId">) => Effect.Effect<SkillDefinitionRecord | undefined, SkillDefinitionRepositoryError, Service>;
+export declare const getRevision: (input: GetSkillDefinitionRevisionInput) => Effect.Effect<SkillDefinitionRevisionRecord | undefined, SkillDefinitionRepositoryError, Service>;
+export declare const list: () => Effect.Effect<readonly SkillDefinitionRecord[], SkillDefinitionRepositoryError, Service>;
+export declare const listRevisions: (id: string & import("effect/Brand").Brand<"Relay.SkillDefinitionId">) => Effect.Effect<readonly SkillDefinitionRevisionRecord[], SkillDefinitionRepositoryError, Service>;
+export declare const pinExecution: (input: PinExecutionSkillsInput) => Effect.Effect<readonly ExecutionSkillPinRecord[], SkillDefinitionRepositoryError, Service>;
+export declare const listPins: (executionId: string & import("effect/Brand").Brand<"Relay.ExecutionId">) => Effect.Effect<readonly ExecutionSkillPinRecord[], SkillDefinitionRepositoryError, Service>;
+export declare const getPinned: (input: GetPinnedSkillInput) => Effect.Effect<ExecutionSkillPinRecord | undefined, SkillDefinitionRepositoryError, Service>;
+export {};

package/dist/types/store-sql/steering/steering-repository.d.ts

@@ -0,0 +1,59 @@
+import { Content, Ids } from "../../schema/index";
+import { Context, Effect, Layer, Schema } from "effect";
+import * as Database from "../database/database-service";
+export type SteeringKind = "steering" | "follow_up";
+export type DrainMode = "all" | "one-at-a-time";
+declare const SteeringRepositoryError_base: Schema.Class<SteeringRepositoryError, Schema.TaggedStruct<"SteeringRepositoryError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class SteeringRepositoryError extends SteeringRepositoryError_base {
+}
+export interface SteeringMessageRecord {
+    readonly executionId: Ids.ExecutionId;
+    readonly kind: SteeringKind;
+    readonly sequence: number;
+    readonly content: ReadonlyArray<Content.Part>;
+    readonly drainId?: string;
+    readonly consumedAt?: number;
+    readonly createdAt: number;
+}
+export interface SteeringDrainRecord {
+    readonly executionId: Ids.ExecutionId;
+    readonly kind: SteeringKind;
+    readonly drainId: string;
+    readonly messageSequences: ReadonlyArray<number>;
+    readonly createdAt: number;
+}
+export interface AppendInput {
+    readonly executionId: Ids.ExecutionId;
+    readonly kind: SteeringKind;
+    readonly content: ReadonlyArray<Content.Part>;
+    readonly createdAt: number;
+}
+export interface DrainInput {
+    readonly executionId: Ids.ExecutionId;
+    readonly kind: SteeringKind;
+    readonly drainId: string;
+    readonly mode: DrainMode;
+    readonly consumedAt: number;
+    readonly createdAt: number;
+}
+export interface DrainResult {
+    readonly drain: SteeringDrainRecord;
+    readonly messages: ReadonlyArray<SteeringMessageRecord>;
+}
+export interface Interface {
+    readonly append: (input: AppendInput) => Effect.Effect<SteeringMessageRecord, SteeringRepositoryError>;
+    readonly appendForRunning: (input: AppendInput) => Effect.Effect<SteeringMessageRecord, SteeringRepositoryError>;
+    readonly drainUnconsumed: (input: DrainInput) => Effect.Effect<DrainResult, SteeringRepositoryError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/SteeringRepository", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const layer: Layer.Layer<Service, never, Database.Service>;
+export declare const memoryLayer: Layer.Layer<Service, never, never>;
+export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
+export declare const append: (input: AppendInput) => Effect.Effect<SteeringMessageRecord, SteeringRepositoryError, Service>;
+export declare const appendForRunning: (input: AppendInput) => Effect.Effect<SteeringMessageRecord, SteeringRepositoryError, Service>;
+export declare const drainUnconsumed: (input: DrainInput) => Effect.Effect<DrainResult, SteeringRepositoryError, Service>;
+export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@relayfx/sdk",
-  "version": "0.0.6",
+  "version": "0.0.7",
   "type": "module",
   "exports": {
     ".": {
@@ -21,8 +21,8 @@
     "typecheck": "bun tsc --noEmit"
   },
   "dependencies": {
-    "@batonfx/core": "0.1.0",
-    "@batonfx/providers": "0.1.0",
+    "@batonfx/core": "0.1.1",
+    "@batonfx/providers": "0.1.1",
     "@effect/ai-anthropic": "4.0.0-beta.93",
     "@effect/ai-openai": "4.0.0-beta.93",
     "@effect/ai-openai-compat": "4.0.0-beta.93",