@xandreed/core 0.4.0 → 0.11.0

package/README.md

@@ -1,5 +1,5 @@
 # @xandreed/core
 
-Efferent composable agent framework, 0.4.0. Bun on Linux.
+Efferent composable agent framework, 0.11.0. Node 24 or Bun.
 
 Documentation: https://github.com/xandreeddev/efferent

package/dist/conformance.entity.d.ts

@@ -0,0 +1,15 @@
+import { Schema } from "effect";
+import type { Effect } from "effect";
+declare const ConformanceFailure_base: Schema.Class<ConformanceFailure, Schema.TaggedStruct<"ConformanceFailure", {
+    readonly check: Schema.String;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** A port contract that an implementation broke. */
+export declare class ConformanceFailure extends ConformanceFailure_base {
+}
+/** One contract check of a conformance kit, runnable under any test runner. */
+export interface ConformanceCheck {
+    readonly name: string;
+    readonly run: Effect.Effect<void, ConformanceFailure>;
+}
+export {};

package/dist/conformance.entity.js

@@ -0,0 +1,7 @@
+import { Schema } from "effect";
+
+export class ConformanceFailure extends Schema.TaggedError()("ConformanceFailure", {
+  check: Schema.String,
+  message: Schema.String
+}) {
+}

package/dist/decision-record.entity.d.ts

@@ -1,31 +1,31 @@
 import { Schema } from "effect";
-export declare const DecisionId: Schema.brand<typeof Schema.NonEmptyTrimmedString, "DecisionId">;
+export declare const DecisionId: Schema.brand<Schema.Trimmed, "DecisionId">;
 export declare const DecisionRecord: Schema.Struct<{
-    version: Schema.Literal<[1]>;
-    id: Schema.brand<typeof Schema.NonEmptyTrimmedString, "DecisionId">;
-    family: typeof Schema.NonEmptyString;
-    contextHash: typeof Schema.String;
-    candidateHash: typeof Schema.String;
-    policyVersion: typeof Schema.String;
-    candidates: Schema.Array$<Schema.Struct<{
-        id: typeof Schema.String;
-        description: typeof Schema.String;
+    readonly version: Schema.Literal<1>;
+    readonly id: Schema.brand<Schema.Trimmed, "DecisionId">;
+    readonly family: Schema.NonEmptyString;
+    readonly contextHash: Schema.String;
+    readonly candidateHash: Schema.String;
+    readonly policyVersion: Schema.String;
+    readonly candidates: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly description: Schema.String;
     }>>;
-    attempts: Schema.Array$<typeof Schema.String>;
-    selection: Schema.OptionFromNullOr<typeof Schema.String>;
-    validation: Schema.Literal<["accepted", "rejected", "abstained", "failed", "cancelled", "bypassed"]>;
-    fallback: Schema.OptionFromNullOr<typeof Schema.String>;
-    applied: Schema.OptionFromNullOr<typeof Schema.String>;
-    probabilities: Schema.OptionFromNullOr<Schema.Record$<typeof Schema.String, Schema.filter<typeof Schema.Number>>>;
+    readonly attempts: Schema.$Array<Schema.String>;
+    readonly selection: Schema.OptionFromNullOr<Schema.String>;
+    readonly validation: Schema.Literals<readonly ["accepted", "rejected", "abstained", "failed", "cancelled", "bypassed"]>;
+    readonly fallback: Schema.OptionFromNullOr<Schema.String>;
+    readonly applied: Schema.OptionFromNullOr<Schema.String>;
+    readonly probabilities: Schema.OptionFromNullOr<Schema.$Record<Schema.String, Schema.Number>>;
 }>;
 export type DecisionRecord = typeof DecisionRecord.Type;
 export declare const DecisionOutcome: Schema.Struct<{
-    version: Schema.Literal<[1]>;
-    decisionId: Schema.brand<typeof Schema.NonEmptyTrimmedString, "DecisionId">;
-    runId: typeof Schema.String;
-    status: Schema.Literal<["completed", "failed", "cancelled", "incomplete"]>;
-    toolInvocations: Schema.Array$<typeof Schema.String>;
-    modelAttempts: Schema.Array$<typeof Schema.String>;
-    deliveredSequences: Schema.Array$<typeof Schema.Int>;
+    readonly version: Schema.Literal<1>;
+    readonly decisionId: Schema.brand<Schema.Trimmed, "DecisionId">;
+    readonly runId: Schema.String;
+    readonly status: Schema.Literals<readonly ["completed", "failed", "cancelled", "incomplete"]>;
+    readonly toolInvocations: Schema.$Array<Schema.String>;
+    readonly modelAttempts: Schema.$Array<Schema.String>;
+    readonly deliveredSequences: Schema.$Array<Schema.Int>;
 }>;
 export type DecisionOutcome = typeof DecisionOutcome.Type;

package/dist/decision-record.entity.functions.d.ts

@@ -0,0 +1,6 @@
+import { Effect } from "effect";
+import type { HarnessError } from "./harness/plugin.entity.js";
+import { RunContext } from "./ports/run-context.port.js";
+import type { DecisionRecord } from "./decision-record.entity.js";
+/** Journal a decision on the current turn's bus (`decision.recorded`). */
+export declare const recordDecision: (record: DecisionRecord) => Effect.Effect<void, HarnessError, RunContext>;

package/dist/decision-record.entity.functions.js

@@ -0,0 +1,3 @@
+import { Effect } from "effect";
+import { RunContext } from "./ports/run-context.port.js";
+export const recordDecision = (record) => RunContext.pipe(Effect.flatMap((run) => run.events.publish({ _tag: "decision.recorded", record })));

package/dist/decision-record.entity.js

@@ -1,5 +1,5 @@
 import { Schema } from "effect";
-export const DecisionId = Schema.NonEmptyTrimmedString.pipe(Schema.brand("DecisionId")), DecisionRecord = Schema.Struct({
+export const DecisionId = Schema.Trimmed.check(Schema.isNonEmpty()).pipe(Schema.brand("DecisionId")), DecisionRecord = Schema.Struct({
   version: Schema.Literal(1),
   id: DecisionId,
   family: Schema.NonEmptyString,
@@ -9,15 +9,15 @@ export const DecisionId = Schema.NonEmptyTrimmedString.pipe(Schema.brand("Decisi
   candidates: Schema.Array(Schema.Struct({ id: Schema.String, description: Schema.String })),
   attempts: Schema.Array(Schema.String),
   selection: Schema.OptionFromNullOr(Schema.String),
-  validation: Schema.Literal("accepted", "rejected", "abstained", "failed", "cancelled", "bypassed"),
+  validation: Schema.Literals(["accepted", "rejected", "abstained", "failed", "cancelled", "bypassed"]),
   fallback: Schema.OptionFromNullOr(Schema.String),
   applied: Schema.OptionFromNullOr(Schema.String),
-  probabilities: Schema.OptionFromNullOr(Schema.Record({ key: Schema.String, value: Schema.Number.pipe(Schema.between(0, 1)) }))
+  probabilities: Schema.OptionFromNullOr(Schema.Record(Schema.String, Schema.Number.pipe(Schema.check(Schema.isBetween({ minimum: 0, maximum: 1 })))))
 }), DecisionOutcome = Schema.Struct({
   version: Schema.Literal(1),
   decisionId: DecisionId,
   runId: Schema.String,
-  status: Schema.Literal("completed", "failed", "cancelled", "incomplete"),
+  status: Schema.Literals(["completed", "failed", "cancelled", "incomplete"]),
   toolInvocations: Schema.Array(Schema.String),
   modelAttempts: Schema.Array(Schema.String),
   deliveredSequences: Schema.Array(Schema.Int)

package/dist/domain/agent-failure.entity.d.ts

@@ -1,12 +1,12 @@
 import { Schema } from "effect";
 /** Stable, serializable failure context shared by products and evaluations. */
-export declare const AgentFailureCategory: Schema.Literal<["authentication", "authorization", "rate-limit", "timeout", "transport", "protocol", "validation", "tool", "persistence", "unknown"]>;
+export declare const AgentFailureCategory: Schema.Literals<readonly ["authentication", "authorization", "rate-limit", "timeout", "transport", "protocol", "validation", "tool", "persistence", "unknown"]>;
 export type AgentFailureCategory = typeof AgentFailureCategory.Type;
 export declare const AgentFailure: Schema.Struct<{
-    code: typeof Schema.String;
-    category: Schema.Literal<["authentication", "authorization", "rate-limit", "timeout", "transport", "protocol", "validation", "tool", "persistence", "unknown"]>;
-    stage: typeof Schema.String;
-    message: typeof Schema.String;
-    retryable: typeof Schema.Boolean;
+    readonly code: Schema.String;
+    readonly category: Schema.Literals<readonly ["authentication", "authorization", "rate-limit", "timeout", "transport", "protocol", "validation", "tool", "persistence", "unknown"]>;
+    readonly stage: Schema.String;
+    readonly message: Schema.String;
+    readonly retryable: Schema.Boolean;
 }>;
 export type AgentFailure = typeof AgentFailure.Type;

package/dist/domain/agent-failure.entity.js

@@ -1,5 +1,16 @@
 import { Schema } from "effect";
-export const AgentFailureCategory = Schema.Literal("authentication", "authorization", "rate-limit", "timeout", "transport", "protocol", "validation", "tool", "persistence", "unknown"), AgentFailure = Schema.Struct({
+export const AgentFailureCategory = Schema.Literals([
+  "authentication",
+  "authorization",
+  "rate-limit",
+  "timeout",
+  "transport",
+  "protocol",
+  "validation",
+  "tool",
+  "persistence",
+  "unknown"
+]), AgentFailure = Schema.Struct({
   code: Schema.String,
   category: AgentFailureCategory,
   stage: Schema.String,

package/dist/domain/failure.entity.d.ts

@@ -6,7 +6,7 @@ import { Schema } from "effect";
  * `message` says exactly what to fix; the model corrects in the same run.
  */
 export declare const Failure: Schema.Struct<{
-    error: typeof Schema.String;
-    message: typeof Schema.String;
+    readonly error: Schema.String;
+    readonly message: Schema.String;
 }>;
 export type Failure = typeof Failure.Type;

package/dist/domain/loop-event.entity.d.ts

@@ -67,6 +67,8 @@ export type LoopEvent = {
     readonly args: unknown;
     readonly ok: boolean;
     readonly result: unknown;
+    /** The schema-encoded result — the persisted, provider-visible form. */
+    readonly encoded?: unknown;
 }
 /** The mid-run fold: the buffer outgrew the healthy context range and the
  *  older turns were replaced by a handoff summary — `kept` verbatim

package/dist/domain/message.entity.d.ts

@@ -5,140 +5,127 @@ import { Schema } from "effect";
  * an opaque blob that round-trips provider-private fields (e.g. Gemini's
  * `thought_signature` on a reasoning part) without the engine inspecting them.
  */
-export declare const ConversationId: Schema.brand<typeof Schema.UUID, "ConversationId">;
+export declare const ConversationId: Schema.brand<Schema.String, "ConversationId">;
 export type ConversationId = typeof ConversationId.Type;
 /** A tool call's pairing key — the provider's id, or the loop's deterministic
  *  `<turnIndex>:<toolName>:<ordinal>` mint when the provider omits one. */
-export declare const ToolCallId: Schema.brand<typeof Schema.String, "ToolCallId">;
+export declare const ToolCallId: Schema.brand<Schema.String, "ToolCallId">;
 export type ToolCallId = typeof ToolCallId.Type;
-declare const Checkpoint_base: Schema.Class<Checkpoint, {
-    conversationId: Schema.brand<typeof Schema.UUID, "ConversationId">;
+declare const Checkpoint_base: Schema.Class<Checkpoint, Schema.Struct<{
+    readonly conversationId: Schema.brand<Schema.String, "ConversationId">;
     /** The absolute message position this fold covers (inclusive). */
-    messagePosition: typeof Schema.Number;
-    summary: typeof Schema.String;
-    createdAt: typeof Schema.Number;
-}, Schema.Struct.Encoded<{
-    conversationId: Schema.brand<typeof Schema.UUID, "ConversationId">;
-    /** The absolute message position this fold covers (inclusive). */
-    messagePosition: typeof Schema.Number;
-    summary: typeof Schema.String;
-    createdAt: typeof Schema.Number;
-}>, never, {
-    readonly conversationId: string & import("effect/Brand").Brand<"ConversationId">;
-} & {
-    readonly messagePosition: number;
-} & {
-    readonly summary: string;
-} & {
-    readonly createdAt: number;
-}, {}, {}>;
+    readonly messagePosition: Schema.Number;
+    readonly summary: Schema.String;
+    readonly createdAt: Schema.Number;
+}>, {}>;
 export declare class Checkpoint extends Checkpoint_base {
 }
 export declare const TextPart: Schema.Struct<{
-    type: Schema.Literal<["text"]>;
-    text: typeof Schema.String;
-    providerOptions: Schema.optional<typeof Schema.Unknown>;
+    readonly type: Schema.Literal<"text">;
+    readonly text: Schema.String;
+    readonly providerOptions: Schema.optional<Schema.Unknown>;
 }>;
 export type TextPart = typeof TextPart.Type;
 export declare const ReasoningPart: Schema.Struct<{
-    type: Schema.Literal<["reasoning"]>;
-    text: typeof Schema.String;
-    providerOptions: Schema.optional<typeof Schema.Unknown>;
+    readonly type: Schema.Literal<"reasoning">;
+    readonly text: Schema.String;
+    readonly providerOptions: Schema.optional<Schema.Unknown>;
 }>;
 export type ReasoningPart = typeof ReasoningPart.Type;
 export declare const ToolCallPart: Schema.Struct<{
-    type: Schema.Literal<["tool-call"]>;
-    toolCallId: Schema.brand<typeof Schema.String, "ToolCallId">;
-    toolName: typeof Schema.String;
-    input: typeof Schema.Unknown;
-    providerOptions: Schema.optional<typeof Schema.Unknown>;
-    providerExecuted: Schema.optional<typeof Schema.Boolean>;
+    readonly type: Schema.Literal<"tool-call">;
+    readonly toolCallId: Schema.brand<Schema.String, "ToolCallId">;
+    readonly toolName: Schema.String;
+    readonly input: Schema.Unknown;
+    readonly providerOptions: Schema.optional<Schema.Unknown>;
+    readonly providerExecuted: Schema.optional<Schema.Boolean>;
 }>;
 export type ToolCallPart = typeof ToolCallPart.Type;
 export declare const ToolResultPart: Schema.Struct<{
-    type: Schema.Literal<["tool-result"]>;
-    toolCallId: Schema.brand<typeof Schema.String, "ToolCallId">;
-    toolName: typeof Schema.String;
-    output: typeof Schema.Unknown;
-    providerOptions: Schema.optional<typeof Schema.Unknown>;
-    isError: Schema.optional<typeof Schema.Boolean>;
+    readonly type: Schema.Literal<"tool-result">;
+    readonly toolCallId: Schema.brand<Schema.String, "ToolCallId">;
+    readonly toolName: Schema.String;
+    readonly output: Schema.Unknown;
+    readonly providerOptions: Schema.optional<Schema.Unknown>;
+    readonly isError: Schema.optional<Schema.Boolean>;
 }>;
 export type ToolResultPart = typeof ToolResultPart.Type;
-export declare const UserMessage: Schema.Struct<{
-    role: Schema.Literal<["user"]>;
-    content: typeof Schema.String;
-    providerOptions: Schema.optional<typeof Schema.Unknown>;
+/** A model-visible message in the user role (the user's own words, turn context, host notes). */
+export declare const UserRoleMessage: Schema.Struct<{
+    readonly role: Schema.Literal<"user">;
+    readonly content: Schema.String;
+    readonly providerOptions: Schema.optional<Schema.Unknown>;
 }>;
-export type UserMessage = typeof UserMessage.Type;
+export type UserRoleMessage = typeof UserRoleMessage.Type;
 export declare const AssistantMessage: Schema.Struct<{
-    role: Schema.Literal<["assistant"]>;
-    content: Schema.Array$<Schema.Union<[Schema.Struct<{
-        type: Schema.Literal<["text"]>;
-        text: typeof Schema.String;
-        providerOptions: Schema.optional<typeof Schema.Unknown>;
+    readonly role: Schema.Literal<"assistant">;
+    readonly content: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"text">;
+        readonly text: Schema.String;
+        readonly providerOptions: Schema.optional<Schema.Unknown>;
     }>, Schema.Struct<{
-        type: Schema.Literal<["reasoning"]>;
-        text: typeof Schema.String;
-        providerOptions: Schema.optional<typeof Schema.Unknown>;
+        readonly type: Schema.Literal<"reasoning">;
+        readonly text: Schema.String;
+        readonly providerOptions: Schema.optional<Schema.Unknown>;
     }>, Schema.Struct<{
-        type: Schema.Literal<["tool-call"]>;
-        toolCallId: Schema.brand<typeof Schema.String, "ToolCallId">;
-        toolName: typeof Schema.String;
-        input: typeof Schema.Unknown;
-        providerOptions: Schema.optional<typeof Schema.Unknown>;
-        providerExecuted: Schema.optional<typeof Schema.Boolean>;
+        readonly type: Schema.Literal<"tool-call">;
+        readonly toolCallId: Schema.brand<Schema.String, "ToolCallId">;
+        readonly toolName: Schema.String;
+        readonly input: Schema.Unknown;
+        readonly providerOptions: Schema.optional<Schema.Unknown>;
+        readonly providerExecuted: Schema.optional<Schema.Boolean>;
     }>]>>;
-    providerOptions: Schema.optional<typeof Schema.Unknown>;
+    readonly providerOptions: Schema.optional<Schema.Unknown>;
 }>;
 export type AssistantMessage = typeof AssistantMessage.Type;
 export declare const ToolMessage: Schema.Struct<{
-    role: Schema.Literal<["tool"]>;
-    content: Schema.Array$<Schema.Struct<{
-        type: Schema.Literal<["tool-result"]>;
-        toolCallId: Schema.brand<typeof Schema.String, "ToolCallId">;
-        toolName: typeof Schema.String;
-        output: typeof Schema.Unknown;
-        providerOptions: Schema.optional<typeof Schema.Unknown>;
-        isError: Schema.optional<typeof Schema.Boolean>;
+    readonly role: Schema.Literal<"tool">;
+    readonly content: Schema.$Array<Schema.Struct<{
+        readonly type: Schema.Literal<"tool-result">;
+        readonly toolCallId: Schema.brand<Schema.String, "ToolCallId">;
+        readonly toolName: Schema.String;
+        readonly output: Schema.Unknown;
+        readonly providerOptions: Schema.optional<Schema.Unknown>;
+        readonly isError: Schema.optional<Schema.Boolean>;
     }>>;
-    providerOptions: Schema.optional<typeof Schema.Unknown>;
+    readonly providerOptions: Schema.optional<Schema.Unknown>;
 }>;
 export type ToolMessage = typeof ToolMessage.Type;
 /** The single conversation unit — persisted as-is, one row per entry. */
-export declare const AgentMessage: Schema.Union<[Schema.Struct<{
-    role: Schema.Literal<["user"]>;
-    content: typeof Schema.String;
-    providerOptions: Schema.optional<typeof Schema.Unknown>;
+export declare const AgentMessage: Schema.Union<readonly [Schema.Struct<{
+    readonly role: Schema.Literal<"user">;
+    readonly content: Schema.String;
+    readonly providerOptions: Schema.optional<Schema.Unknown>;
 }>, Schema.Struct<{
-    role: Schema.Literal<["assistant"]>;
-    content: Schema.Array$<Schema.Union<[Schema.Struct<{
-        type: Schema.Literal<["text"]>;
-        text: typeof Schema.String;
-        providerOptions: Schema.optional<typeof Schema.Unknown>;
+    readonly role: Schema.Literal<"assistant">;
+    readonly content: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"text">;
+        readonly text: Schema.String;
+        readonly providerOptions: Schema.optional<Schema.Unknown>;
     }>, Schema.Struct<{
-        type: Schema.Literal<["reasoning"]>;
-        text: typeof Schema.String;
-        providerOptions: Schema.optional<typeof Schema.Unknown>;
+        readonly type: Schema.Literal<"reasoning">;
+        readonly text: Schema.String;
+        readonly providerOptions: Schema.optional<Schema.Unknown>;
     }>, Schema.Struct<{
-        type: Schema.Literal<["tool-call"]>;
-        toolCallId: Schema.brand<typeof Schema.String, "ToolCallId">;
-        toolName: typeof Schema.String;
-        input: typeof Schema.Unknown;
-        providerOptions: Schema.optional<typeof Schema.Unknown>;
-        providerExecuted: Schema.optional<typeof Schema.Boolean>;
+        readonly type: Schema.Literal<"tool-call">;
+        readonly toolCallId: Schema.brand<Schema.String, "ToolCallId">;
+        readonly toolName: Schema.String;
+        readonly input: Schema.Unknown;
+        readonly providerOptions: Schema.optional<Schema.Unknown>;
+        readonly providerExecuted: Schema.optional<Schema.Boolean>;
     }>]>>;
-    providerOptions: Schema.optional<typeof Schema.Unknown>;
+    readonly providerOptions: Schema.optional<Schema.Unknown>;
 }>, Schema.Struct<{
-    role: Schema.Literal<["tool"]>;
-    content: Schema.Array$<Schema.Struct<{
-        type: Schema.Literal<["tool-result"]>;
-        toolCallId: Schema.brand<typeof Schema.String, "ToolCallId">;
-        toolName: typeof Schema.String;
-        output: typeof Schema.Unknown;
-        providerOptions: Schema.optional<typeof Schema.Unknown>;
-        isError: Schema.optional<typeof Schema.Boolean>;
+    readonly role: Schema.Literal<"tool">;
+    readonly content: Schema.$Array<Schema.Struct<{
+        readonly type: Schema.Literal<"tool-result">;
+        readonly toolCallId: Schema.brand<Schema.String, "ToolCallId">;
+        readonly toolName: Schema.String;
+        readonly output: Schema.Unknown;
+        readonly providerOptions: Schema.optional<Schema.Unknown>;
+        readonly isError: Schema.optional<Schema.Boolean>;
     }>>;
-    providerOptions: Schema.optional<typeof Schema.Unknown>;
+    readonly providerOptions: Schema.optional<Schema.Unknown>;
 }>]>;
 export type AgentMessage = typeof AgentMessage.Type;
 /**
@@ -147,81 +134,81 @@ export type AgentMessage = typeof AgentMessage.Type;
  * never reconstruct it by index arithmetic on `messages`.
  */
 export declare const AgentResult: Schema.Struct<{
-    finalText: typeof Schema.String;
-    messages: Schema.Array$<Schema.Union<[Schema.Struct<{
-        role: Schema.Literal<["user"]>;
-        content: typeof Schema.String;
-        providerOptions: Schema.optional<typeof Schema.Unknown>;
+    readonly finalText: Schema.String;
+    readonly messages: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly role: Schema.Literal<"user">;
+        readonly content: Schema.String;
+        readonly providerOptions: Schema.optional<Schema.Unknown>;
     }>, Schema.Struct<{
-        role: Schema.Literal<["assistant"]>;
-        content: Schema.Array$<Schema.Union<[Schema.Struct<{
-            type: Schema.Literal<["text"]>;
-            text: typeof Schema.String;
-            providerOptions: Schema.optional<typeof Schema.Unknown>;
+        readonly role: Schema.Literal<"assistant">;
+        readonly content: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"text">;
+            readonly text: Schema.String;
+            readonly providerOptions: Schema.optional<Schema.Unknown>;
         }>, Schema.Struct<{
-            type: Schema.Literal<["reasoning"]>;
-            text: typeof Schema.String;
-            providerOptions: Schema.optional<typeof Schema.Unknown>;
+            readonly type: Schema.Literal<"reasoning">;
+            readonly text: Schema.String;
+            readonly providerOptions: Schema.optional<Schema.Unknown>;
         }>, Schema.Struct<{
-            type: Schema.Literal<["tool-call"]>;
-            toolCallId: Schema.brand<typeof Schema.String, "ToolCallId">;
-            toolName: typeof Schema.String;
-            input: typeof Schema.Unknown;
-            providerOptions: Schema.optional<typeof Schema.Unknown>;
-            providerExecuted: Schema.optional<typeof Schema.Boolean>;
+            readonly type: Schema.Literal<"tool-call">;
+            readonly toolCallId: Schema.brand<Schema.String, "ToolCallId">;
+            readonly toolName: Schema.String;
+            readonly input: Schema.Unknown;
+            readonly providerOptions: Schema.optional<Schema.Unknown>;
+            readonly providerExecuted: Schema.optional<Schema.Boolean>;
         }>]>>;
-        providerOptions: Schema.optional<typeof Schema.Unknown>;
+        readonly providerOptions: Schema.optional<Schema.Unknown>;
     }>, Schema.Struct<{
-        role: Schema.Literal<["tool"]>;
-        content: Schema.Array$<Schema.Struct<{
-            type: Schema.Literal<["tool-result"]>;
-            toolCallId: Schema.brand<typeof Schema.String, "ToolCallId">;
-            toolName: typeof Schema.String;
-            output: typeof Schema.Unknown;
-            providerOptions: Schema.optional<typeof Schema.Unknown>;
-            isError: Schema.optional<typeof Schema.Boolean>;
+        readonly role: Schema.Literal<"tool">;
+        readonly content: Schema.$Array<Schema.Struct<{
+            readonly type: Schema.Literal<"tool-result">;
+            readonly toolCallId: Schema.brand<Schema.String, "ToolCallId">;
+            readonly toolName: Schema.String;
+            readonly output: Schema.Unknown;
+            readonly providerOptions: Schema.optional<Schema.Unknown>;
+            readonly isError: Schema.optional<Schema.Boolean>;
         }>>;
-        providerOptions: Schema.optional<typeof Schema.Unknown>;
+        readonly providerOptions: Schema.optional<Schema.Unknown>;
     }>]>>;
-    newTail: Schema.Array$<Schema.Union<[Schema.Struct<{
-        role: Schema.Literal<["user"]>;
-        content: typeof Schema.String;
-        providerOptions: Schema.optional<typeof Schema.Unknown>;
+    readonly newTail: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly role: Schema.Literal<"user">;
+        readonly content: Schema.String;
+        readonly providerOptions: Schema.optional<Schema.Unknown>;
     }>, Schema.Struct<{
-        role: Schema.Literal<["assistant"]>;
-        content: Schema.Array$<Schema.Union<[Schema.Struct<{
-            type: Schema.Literal<["text"]>;
-            text: typeof Schema.String;
-            providerOptions: Schema.optional<typeof Schema.Unknown>;
+        readonly role: Schema.Literal<"assistant">;
+        readonly content: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"text">;
+            readonly text: Schema.String;
+            readonly providerOptions: Schema.optional<Schema.Unknown>;
         }>, Schema.Struct<{
-            type: Schema.Literal<["reasoning"]>;
-            text: typeof Schema.String;
-            providerOptions: Schema.optional<typeof Schema.Unknown>;
+            readonly type: Schema.Literal<"reasoning">;
+            readonly text: Schema.String;
+            readonly providerOptions: Schema.optional<Schema.Unknown>;
         }>, Schema.Struct<{
-            type: Schema.Literal<["tool-call"]>;
-            toolCallId: Schema.brand<typeof Schema.String, "ToolCallId">;
-            toolName: typeof Schema.String;
-            input: typeof Schema.Unknown;
-            providerOptions: Schema.optional<typeof Schema.Unknown>;
-            providerExecuted: Schema.optional<typeof Schema.Boolean>;
+            readonly type: Schema.Literal<"tool-call">;
+            readonly toolCallId: Schema.brand<Schema.String, "ToolCallId">;
+            readonly toolName: Schema.String;
+            readonly input: Schema.Unknown;
+            readonly providerOptions: Schema.optional<Schema.Unknown>;
+            readonly providerExecuted: Schema.optional<Schema.Boolean>;
         }>]>>;
-        providerOptions: Schema.optional<typeof Schema.Unknown>;
+        readonly providerOptions: Schema.optional<Schema.Unknown>;
     }>, Schema.Struct<{
-        role: Schema.Literal<["tool"]>;
-        content: Schema.Array$<Schema.Struct<{
-            type: Schema.Literal<["tool-result"]>;
-            toolCallId: Schema.brand<typeof Schema.String, "ToolCallId">;
-            toolName: typeof Schema.String;
-            output: typeof Schema.Unknown;
-            providerOptions: Schema.optional<typeof Schema.Unknown>;
-            isError: Schema.optional<typeof Schema.Boolean>;
+        readonly role: Schema.Literal<"tool">;
+        readonly content: Schema.$Array<Schema.Struct<{
+            readonly type: Schema.Literal<"tool-result">;
+            readonly toolCallId: Schema.brand<Schema.String, "ToolCallId">;
+            readonly toolName: Schema.String;
+            readonly output: Schema.Unknown;
+            readonly providerOptions: Schema.optional<Schema.Unknown>;
+            readonly isError: Schema.optional<Schema.Boolean>;
         }>>;
-        providerOptions: Schema.optional<typeof Schema.Unknown>;
+        readonly providerOptions: Schema.optional<Schema.Unknown>;
     }>]>>;
     /** "ok" — the model finished on its own; "partial" — the step cap or the
      *  degenerate-loop breaker stopped it, so `finalText` is NOT a deliverable. */
-    outcome: Schema.Literal<["ok", "partial"]>;
-    reason: Schema.Literal<["completed", "step-cap", "degenerate-loop"]>;
+    readonly outcome: Schema.Literals<readonly ["ok", "partial"]>;
+    readonly reason: Schema.Literals<readonly ["completed", "step-cap", "degenerate-loop"]>;
 }>;
 export type AgentResult = typeof AgentResult.Type;
 export {};

package/dist/domain/message.entity.js

@@ -1,5 +1,5 @@
 import { Schema } from "effect";
-export const ConversationId = Schema.UUID.pipe(Schema.brand("ConversationId")), ToolCallId = Schema.String.pipe(Schema.brand("ToolCallId"));
+export const ConversationId = Schema.String.check(Schema.isUUID()).pipe(Schema.brand("ConversationId")), ToolCallId = Schema.String.pipe(Schema.brand("ToolCallId"));
 
 export class Checkpoint extends Schema.Class("Checkpoint")({
   conversationId: ConversationId,
@@ -30,22 +30,22 @@ export const TextPart = Schema.Struct({
   output: Schema.Unknown,
   providerOptions: Schema.optional(Schema.Unknown),
   isError: Schema.optional(Schema.Boolean)
-}), UserMessage = Schema.Struct({
+}), UserRoleMessage = Schema.Struct({
   role: Schema.Literal("user"),
   content: Schema.String,
   providerOptions: Schema.optional(Schema.Unknown)
 }), AssistantMessage = Schema.Struct({
   role: Schema.Literal("assistant"),
-  content: Schema.Array(Schema.Union(TextPart, ReasoningPart, ToolCallPart)),
+  content: Schema.Array(Schema.Union([TextPart, ReasoningPart, ToolCallPart])),
   providerOptions: Schema.optional(Schema.Unknown)
 }), ToolMessage = Schema.Struct({
   role: Schema.Literal("tool"),
   content: Schema.Array(ToolResultPart),
   providerOptions: Schema.optional(Schema.Unknown)
-}), AgentMessage = Schema.Union(UserMessage, AssistantMessage, ToolMessage), AgentResult = Schema.Struct({
+}), AgentMessage = Schema.Union([UserRoleMessage, AssistantMessage, ToolMessage]), AgentResult = Schema.Struct({
   finalText: Schema.String,
   messages: Schema.Array(AgentMessage),
   newTail: Schema.Array(AgentMessage),
-  outcome: Schema.Literal("ok", "partial"),
-  reason: Schema.Literal("completed", "step-cap", "degenerate-loop")
+  outcome: Schema.Literals(["ok", "partial"]),
+  reason: Schema.Literals(["completed", "step-cap", "degenerate-loop"])
 });

package/dist/domain/model-call-policy.entity.d.ts

@@ -3,10 +3,10 @@ import { Schema } from "effect";
  * subscription dialect (accepted, reasoning_tokens 0); `minimal` was
  * REJECTED there and stays out of the vocabulary. Non-codex adapters clamp
  * `none` to their nearest supported value. */
-export declare const ReasoningEffort: Schema.Literal<["none", "low", "medium", "high", "xhigh", "max"]>;
+export declare const ReasoningEffort: Schema.Literals<readonly ["none", "low", "medium", "high", "xhigh", "max"]>;
 export type ReasoningEffort = typeof ReasoningEffort.Type;
 export declare const ModelCallPolicy: Schema.Struct<{
-    effort: Schema.Literal<["none", "low", "medium", "high", "xhigh", "max"]>;
-    maxOutputTokens: Schema.optional<typeof Schema.Number>;
+    readonly effort: Schema.Literals<readonly ["none", "low", "medium", "high", "xhigh", "max"]>;
+    readonly maxOutputTokens: Schema.optional<Schema.Number>;
 }>;
 export type ModelCallPolicy = typeof ModelCallPolicy.Type;

package/dist/domain/model-call-policy.entity.js

@@ -1,5 +1,5 @@
 import { Schema } from "effect";
-export const ReasoningEffort = Schema.Literal("none", "low", "medium", "high", "xhigh", "max"), ModelCallPolicy = Schema.Struct({
+export const ReasoningEffort = Schema.Literals(["none", "low", "medium", "high", "xhigh", "max"]), ModelCallPolicy = Schema.Struct({
   effort: ReasoningEffort,
   maxOutputTokens: Schema.optional(Schema.Number)
 });